TypeScript ModelManager.register方法代码示例

 beforeEach(() => {
     models = new rev.ModelManager();
     models.registerBackend('default', new rev.InMemoryBackend());
     models.register(TestDecoratedModel);
     models.register(TestModel);
     apiManager = new ModelApiManager(models);
 });

export function getModelManager() {
    const modelManager = new ModelManager();
    modelManager.registerBackend('default', new InMemoryBackend());
    modelManager.register(User);
    modelManager.register(Post);
    modelManager.register(Comment);
    return modelManager;
}

(async () => {

    // Create a MongoDBBackend and connect to MongoDB

    const mongo = new MongoDBBackend({
        url: 'mongodb://localhost:27017',
        dbName: 'example_db'
    });
    await mongo.connect();

    // Create a ModelManager, and assign MongoDB as the default backend

    const modelManager = new ModelManager();
    modelManager.registerBackend('default', mongo);
    modelManager.register(TestModel);

    // Create some data, then disconnect afterwards

    await modelManager.create(new TestModel({
        name: 'data from RevJS!',
        description: 'This beautiful record was created by RevJS',
        score: 110
    }));
    console.log('Data successfully created in MongoDB!');

    await mongo.disconnect();

})();

export function getModelManager() {
    const modelManager = new ModelManager();
    modelManager.registerBackend('default', new InMemoryBackend());
    modelManager.register(User);
    modelManager.register(Post);
    modelManager.register(Comment);
    modelManager.register(UnrelatedModel);
    modelManager.register(ModelWithUnknownField, { fields: [
        new UnknownField('unknownField')
    ]});
    modelManager.register(ModelWithAllScalarFields);
    return modelManager;
}

import {
    AutoNumberField, TextField, IntegerField,
    ModelManager, InMemoryBackend
} from 'rev-models';

class TestModel {
    @AutoNumberField({ primaryKey: true })
        item_number: number;
    @TextField()
        name: string;
    @TextField({ required: false })
        description: string;
    @IntegerField()
        score: number;

    constructor(data: Partial<TestModel>) {
        Object.assign(this, data);
    }
}

// Create a ModelManager with an InMemoryBackend
const modelManager = new ModelManager();
modelManager.registerBackend('default', new InMemoryBackend());
modelManager.register(TestModel);

import { TextField, ModelManager, InMemoryBackend } from 'rev-models';

// Define models

export class User {
    @TextField()
        first_name: string;
    @TextField()
        last_name: string;
}

export class Post {
    @TextField()
        title: string;
    @TextField({ multiLine: true })
        body: string;
}

// Create ModelManager and register the models

export const modelManager = new ModelManager();
modelManager.registerBackend('default', new InMemoryBackend());

modelManager.register(User);
modelManager.register(Post);

// Define model

export class Comment {
    @TextField()
        comment: string;
    @SelectField({ selection: [['draft', 'Draft'], ['posted', 'Posted']]})
        status: string;

    constructor(data?: Partial<Comment>) {
        Object.assign(this, data);
    }
}

const modelManager = new ModelManager();
modelManager.registerBackend('default', new InMemoryBackend());
modelManager.register(Comment);

// Try to create an invalid Comment

(async () => {

    try {
        await modelManager.create(new Comment({
            comment: 'This comment has an invalid status',
            status: 'Awesome!'
        }));
    }
    catch (e) {
        if (e instanceof ValidationError) {
            console.log('Model Failed Validation :(');
            console.log('Field Errors:', e.validation.fieldErrors);

import * as models from './models';
import { createData } from './model_data';
import { ModelManager, InMemoryBackend } from 'rev-models';
import { ModelApiManager } from 'rev-api';

// Register server models

export const modelManager = new ModelManager();
const backend = new InMemoryBackend();
modelManager.registerBackend('default', backend);
modelManager.register(models.User);
modelManager.register(models.Post);
modelManager.register(models.Comment);
modelManager.register(models.ModelWithAllFields);

export const api = new ModelApiManager(modelManager);
api.register(models.User);
api.register(models.Post);
api.register(models.Comment);
api.register(models.ModelWithAllFields);

// Create Koa & Apollo GraphQL Server

import * as koa from 'koa';
import * as koaRouter from 'koa-router';
import * as koaBody from 'koa-bodyparser';
import { graphqlKoa, graphiqlKoa } from 'graphql-server-koa';

const schema = api.getGraphQLSchema();

        Object.assign(this, data);
    }
}

export class Customer {
    @AutoNumberField({ primaryKey: true })
        id: number;
    @TextField()
        first_name: string;
    @TextField()
        last_name: string;
    @IntegerField()
        age: number;
    @SelectField({ selection: [['M', 'Male'], ['F', 'Female']] })
        gender: string;
    @RelatedModel({ model: 'City', required: false })
        city: City;

    constructor(data?: Partial<Customer>) {
        Object.assign(this, data);
    }
}

// Create ModelManager and register the models

export const modelManager = new ModelManager();
modelManager.registerBackend('default', new InMemoryBackend());

modelManager.register(City);
modelManager.register(Customer);

                where: {
                    title: { _like: this.title }
                }
            });
            if (duplicates.meta.totalCount > 0) {
                ctx.result.addFieldError('title', 'Cannot create post with a duplicate title!');
            }
        }
    }
}

// Create ModelManager

export const modelManager = new ModelManager();
modelManager.registerBackend('default', new InMemoryBackend());
modelManager.register(Post);

// Create some data

(async () => {
    try {

        // Create a valid post
        await modelManager.create(new Post({
            title: 'This is a valid post',
            body: 'No alternative facts here!',
            is_published: true
        }));

        // Try to create a duplicate post...
        await modelManager.create(new Post({