@graphql-mesh/mongoose/index.esm.js

import { composeWithMongoose, composeWithMongooseDiscriminators } from 'graphql-compose-mongoose';
import { SchemaComposer } from 'graphql-compose';
import { camelCase } from 'camel-case';
import mongoose from 'mongoose';
import { loadFromModuleExportExpression } from '@graphql-mesh/utils';

const modelQueryOperations = ['findById', 'findByIds', 'findOne', 'findMany', 'count', 'connection', 'pagination'];
const modelMutationOperations = [
    'createOne',
    'createMany',
    'updateById',
    'updateOne',
    'updateMany',
    'removeById',
    'removeOne',
    'removeMany',
];
class MongooseHandler {
    constructor({ config, pubsub }) {
        this.config = config;
        this.pubsub = pubsub;
    }
    async getMeshSource() {
        var _a;
        if (this.config.connectionString) {
            await mongoose.connect(this.config.connectionString, {
                useNewUrlParser: true,
                useUnifiedTopology: true,
            });
            this.pubsub.subscribe('destroy', () => mongoose.disconnect());
        }
        const schemaComposer = new SchemaComposer();
        await Promise.all([
            Promise.all((_a = this.config.models) === null || _a === void 0 ? void 0 : _a.map(async (modelConfig) => {
                const model = await loadFromModuleExportExpression(modelConfig.path, modelConfig.name);
                const modelTC = composeWithMongoose(model, modelConfig.options);
                await Promise.all([
                    Promise.all(modelQueryOperations.map(async (queryOperation) => schemaComposer.Query.addFields({
                        [camelCase(`${modelConfig.name}_${queryOperation}`)]: modelTC.getResolver(queryOperation),
                    }))),
                    Promise.all(modelMutationOperations.map(async (mutationOperation) => schemaComposer.Mutation.addFields({
                        [camelCase(`${modelConfig.name}_${mutationOperation}`)]: modelTC.getResolver(mutationOperation),
                    }))),
                ]);
            })),
            Promise.all(this.config.discriminators.map(async (discriminatorConfig) => {
                const discriminator = await loadFromModuleExportExpression(discriminatorConfig.path, discriminatorConfig.name);
                const discriminatorTC = composeWithMongooseDiscriminators(discriminator, discriminatorConfig.options);
                await Promise.all([
                    Promise.all(modelQueryOperations.map(async (queryOperation) => schemaComposer.Query.addFields({
                        [camelCase(`${discriminatorConfig.name}_${queryOperation}`)]: discriminatorTC.getResolver(queryOperation),
                    }))),
                    Promise.all(modelMutationOperations.map(async (mutationOperation) => schemaComposer.Mutation.addFields({
                        [camelCase(`${discriminatorConfig.name}_${mutationOperation}`)]: discriminatorTC.getResolver(mutationOperation),
                    }))),
                ]);
            })),
        ]);
        const schema = schemaComposer.buildSchema();
        return {
            schema,
        };
    }
}

export default MongooseHandler;
//# sourceMappingURL=index.esm.js.map