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

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

const graphqlComposeMongoose = require('graphql-compose-mongoose');
const graphqlCompose = require('graphql-compose');
const camelCase = require('camel-case');
const mongoose = _interopDefault(require('mongoose'));
const utils = require('@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 graphqlCompose.SchemaComposer();
        await Promise.all([
            Promise.all((_a = this.config.models) === null || _a === void 0 ? void 0 : _a.map(async (modelConfig) => {
                const model = await utils.loadFromModuleExportExpression(modelConfig.path, modelConfig.name);
                const modelTC = graphqlComposeMongoose.composeWithMongoose(model, modelConfig.options);
                await Promise.all([
                    Promise.all(modelQueryOperations.map(async (queryOperation) => schemaComposer.Query.addFields({
                        [camelCase.camelCase(`${modelConfig.name}_${queryOperation}`)]: modelTC.getResolver(queryOperation),
                    }))),
                    Promise.all(modelMutationOperations.map(async (mutationOperation) => schemaComposer.Mutation.addFields({
                        [camelCase.camelCase(`${modelConfig.name}_${mutationOperation}`)]: modelTC.getResolver(mutationOperation),
                    }))),
                ]);
            })),
            Promise.all(this.config.discriminators.map(async (discriminatorConfig) => {
                const discriminator = await utils.loadFromModuleExportExpression(discriminatorConfig.path, discriminatorConfig.name);
                const discriminatorTC = graphqlComposeMongoose.composeWithMongooseDiscriminators(discriminator, discriminatorConfig.options);
                await Promise.all([
                    Promise.all(modelQueryOperations.map(async (queryOperation) => schemaComposer.Query.addFields({
                        [camelCase.camelCase(`${discriminatorConfig.name}_${queryOperation}`)]: discriminatorTC.getResolver(queryOperation),
                    }))),
                    Promise.all(modelMutationOperations.map(async (mutationOperation) => schemaComposer.Mutation.addFields({
                        [camelCase.camelCase(`${discriminatorConfig.name}_${mutationOperation}`)]: discriminatorTC.getResolver(mutationOperation),
                    }))),
                ]);
            })),
        ]);
        const schema = schemaComposer.buildSchema();
        return {
            schema,
        };
    }
}

module.exports = MongooseHandler;
//# sourceMappingURL=index.cjs.js.map