TypeScript ModelManager.getModelMeta方法代码示例

    /**
     * @private
     */
    async create<T extends IModel>(manager: ModelManager, model: T, params: ICreateParams, result: ModelOperationResult<T, ICreateMeta>): Promise<ModelOperationResult<T, ICreateMeta>> {
        const meta = manager.getModelMeta(model);

        const document: IKeyMap<number> = {};
        let fieldList = Object.keys(meta.fieldsByName);
        for (let fieldName of fieldList) {
            let field = meta.fieldsByName[fieldName];
            if (field.options.stored) {
                if (field instanceof fields.AutoNumberField
                        && typeof model[fieldName] == 'undefined') {
                    document[fieldName] = await this._getNextAutoNumberValue(meta.name, fieldName);
                }
                else if (typeof model[fieldName] != 'undefined') {
                    let value = field.toBackendValue(manager, model[fieldName]);
                    if (typeof value != 'undefined') {
                        document[fieldName] = value;
                    }
                }
            }
        }

        const colName = this._getCollectionName(meta);
        const createResult = await this.db.collection(colName).insertOne(document);
        if (createResult.insertedCount != 1) {
            throw new Error('mongodb insert failed'); // TODO: Something nicer
        }

        result.result = manager.hydrate(meta.ctor, document);
        return result;
    }

    /**
     * @private
     */
    async update<T extends IModel>(manager: ModelManager, model: T, params: IUpdateParams, result: ModelOperationResult<T, IUpdateMeta>): Promise<ModelOperationResult<T, IUpdateMeta>> {
        if (!params.where) {
            throw new Error(`update() requires the 'where' option to be set.`);
        }

        let meta = manager.getModelMeta(model);
        const mongoQuery = convertQuery(manager, meta.ctor, params.where);

        const fieldUpdates: IKeyMap<any> = {};
        params.fields!.forEach((fieldName) => {
            const field = meta.fieldsByName[fieldName];
            if (field.options.stored && typeof model[fieldName] != 'undefined') {
                let value = field.toBackendValue(manager, model[fieldName]);
                if (typeof value != 'undefined') {
                    fieldUpdates[fieldName] = value;
                }
            }
        });

        const colName = this._getCollectionName(meta);
        const updateResult = await this.db.collection(colName).updateMany(mongoQuery, { $set: fieldUpdates });

        result.setMeta({ totalCount: updateResult.matchedCount });
        return result;
    }

 /**
  * @private
  */
 async create<T extends IModel>(manager: ModelManager, model: T, options: ICreateOptions, result: ModelOperationResult<T, ICreateMeta>): Promise<ModelOperationResult<T, ICreateMeta>> {
     const meta = manager.getModelMeta(model);
     const data = this._buildGraphQLModelData(manager, meta, model);
     const mutationName = meta.name + '_create';
     const query = {
         mutation: {
             [mutationName]: {
                 __args: {
                     model: data
                 }
             }
         }
     };
     const httpResult = await this._getGraphQLQueryResult(query);
     if (!httpResult.data.data
         || !httpResult.data.data[mutationName]) {
         throw this._createHttpError('GraphQL response did not contain the expected operation results', httpResult);
     }
     const createResult: ModelOperationResult<any, ICreateMeta> = httpResult.data.data[mutationName];
     result.success = createResult.success;
     result.validation = createResult.validation;
     if (createResult.result) {
         result.result = manager.hydrate(meta.ctor, createResult.result);
     }
     return result;
 }

    /**
     * @private
     */
    async update<T extends IModel>(manager: ModelManager, model: T, options: IUpdateOptions, result: ModelOperationResult<T, IUpdateMeta>): Promise<ModelOperationResult<T, IUpdateMeta>> {

        if (!options.where) {
            throw new Error(`update() requires the 'where' option to be set.`);
        }

        const meta = manager.getModelMeta(model);
        const data = this._buildGraphQLModelData(manager, meta, model, options.fields);
        const mutationName = meta.name + '_update';
        let args: any = {
            model: data
        };
        if (options.where) {
            args.where = options.where;
        }
        const query = {
            mutation: {
                [mutationName]: {
                    __args: args
                }
            }
        };
        const httpResult = await this._getGraphQLQueryResult(query);
        if (!httpResult.data.data
            || !httpResult.data.data[mutationName]) {
            throw this._createHttpError('GraphQL response did not contain the expected operation results', httpResult);
        }
        const updateResult: ModelOperationResult<any, IUpdateMeta> = httpResult.data.data[mutationName];
        result.success = updateResult.success;
        result.validation = updateResult.validation;
        result.meta = updateResult.meta;
        return result;
    }

 /**
  * @private
  */
 async read<T extends IModel>(manager: ModelManager, model: new() => T, options: IReadOptions, result: ModelOperationResult<T, IReadMeta>): Promise<ModelOperationResult<T, IReadMeta>> {
     const meta = manager.getModelMeta(model);
     const query = this._buildGraphQLQuery(manager, meta, options);
     const httpResult = await this._getGraphQLQueryResult(query);
     if (!httpResult.data.data
         || !httpResult.data.data[meta.name]
         || !(httpResult.data.data[meta.name].results instanceof Array)) {
         throw this._createHttpError('GraphQL response did not contain the expected model results', httpResult);
     }
     const returnedData = httpResult.data.data[meta.name].results;
     result.results = [];
     returnedData.forEach((record: any) => {
         result.results!.push(this._hydrateRecordWithRelated(manager, meta, record, options.related));
     });
     const returnedMeta = httpResult.data.data[meta.name].meta;
     result.setMeta(returnedMeta);
     return result;
 }

 /**
  * Builds an object representing all the graphql nodes to select for the specified query
  */
 private _buildGraphQLSelectFields(manager: ModelManager, meta: IModelMeta<any>, fieldObj: any, related?: string[]) {
     for (const field of meta.fields) {
         if (field instanceof fields.RelatedModelFieldBase) {
             if (related) {
                 // If this field is a RelatedModel field and it is in the list of "related" fields to select, then
                 // select the field and all of its child scalar fields
                 const relFieldNames = getOwnRelatedFieldNames(related);
                 if (field instanceof fields.RelatedModelFieldBase && relFieldNames.indexOf(field.name) > -1) {
                     const relMeta = manager.getModelMeta(field.options.model);
                     fieldObj[field.name] = {};
                     const childRelFieldNames = getChildRelatedFieldNames(field.name, related);
                     this._buildGraphQLSelectFields(manager, relMeta, fieldObj[field.name], childRelFieldNames);
                 }
             }
         }
         else {
             fieldObj[field.name] = true;
         }
     }
     return fieldObj;
 }

            meta.fields.forEach((field) => {
                if (relFieldNames.indexOf(field.name) > -1 && typeof recordData[field.name] != 'undefined') {

                    const relMeta = manager.getModelMeta(field.options.model);
                    const childRelFieldNames = getChildRelatedFieldNames(field.name, related);

                    if (field instanceof fields.RelatedModelField) {
                        if (recordData[field.name] == null) {
                            model[field.name] = null;
                        }
                        else {
                            model[field.name] = this._hydrateRecordWithRelated(manager, relMeta, recordData[field.name], childRelFieldNames);
                        }
                    }
                    else if (field instanceof fields.RelatedModelListField && recordData[field.name] instanceof Array) {
                        model[field.name] = [];
                        recordData[field.name].forEach((record: any) => {
                            model[field.name].push(this._hydrateRecordWithRelated(manager, relMeta, record, childRelFieldNames));
                        });
                    }
                }
            });

    /**
     * @private
     */
    async read<T extends IModel>(manager: ModelManager, model: new() => T, params: IReadParams, result: ModelOperationResult<T, IReadMeta>): Promise<ModelOperationResult<T, IReadMeta>> {
        const meta = manager.getModelMeta(model);
        const colName = this._getCollectionName(meta);

        const mongoQuery = convertQuery(manager, model, params.where);

        const records = await this.db.collection(colName)
            .find(mongoQuery)
            .sort(this._convertOrderBy(params.orderBy))
            .skip(params.offset)
            .limit(params.limit)
            .toArray();

        const primaryKeyValues: any[] = [];
        const foreignKeyValues: IForeignKeyValues = {};
        const rawValues: IRawValues = [];
        const relatedFieldNames = getOwnRelatedFieldNames(params.related);

        result.results = [];
        records.forEach((record) => {

            const modelInstance = manager.hydrate(meta.ctor, record);
            result.results!.push(modelInstance);

            if (meta.primaryKey) {
                primaryKeyValues.push(modelInstance[meta.primaryKey]);
            }

            // TODO: Refactor this into a method shared with InMemoryBackend (and future backends)
            if (relatedFieldNames) {
                for (let fieldName of relatedFieldNames) {
                    let field = meta.fieldsByName[fieldName];
                    let keyValue = record[fieldName];
                    if (field instanceof fields.RelatedModelField) {
                        if (!(fieldName in foreignKeyValues)) {
                            foreignKeyValues[fieldName] = [];
                        }
                        if (typeof keyValue != 'undefined' && keyValue !== null) {
                            modelInstance[fieldName] = keyValue;
                            if (foreignKeyValues[fieldName].indexOf(keyValue) == -1) {
                                foreignKeyValues[fieldName].push(keyValue);
                            }
                        }
                        else {
                            modelInstance[fieldName] = null;
                        }
                    }
                }
            }

            if (params.rawValues) {
                let rawValueObj: IRawValueRow = {};
                for (let fieldName of params.rawValues) {
                    rawValueObj[fieldName] = record[fieldName];
                }
                rawValues.push(rawValueObj);
            }
        });

        // TODO: Refactor this into a method shared with InMemoryBackend (and future backends)
        if (relatedFieldNames) {
            // Get related record data
            const related = await Promise.all([
                getRelatedModelInstances(manager, meta, foreignKeyValues, params),
                getRelatedModelListInstances(manager, meta, primaryKeyValues, params)
            ]);
            const [relatedModelInstances, relatedModelListInstances] = related;

            for (let instance of result.results) {
                for (let fieldName of relatedFieldNames) {
                    let field = meta.fieldsByName[fieldName];
                    if (field instanceof fields.RelatedModelField) {
                        if (instance[fieldName] !== null
                            && relatedModelInstances[fieldName]
                            && relatedModelInstances[fieldName][instance[fieldName]]) {
                                instance[fieldName] = relatedModelInstances[fieldName][instance[fieldName]];
                        }
                        else {
                            instance[fieldName] = null;
                        }
                    }
                    else if (field instanceof fields.RelatedModelListField) {
                        if (relatedModelListInstances[fieldName]
                            && relatedModelListInstances[fieldName][instance[meta.primaryKey!]]) {
                                instance[fieldName] = relatedModelListInstances[fieldName][instance[meta.primaryKey!]];
                        }
                        else {
                            instance[fieldName] = [];
                        }
                    }
                }
            }
        }

        if (params.rawValues) {
            result.setMeta({ rawValues });
        }
//.........这里部分代码省略.........