graphql-compose-mongoose/lib/resolvers/createMany.js

Plugin for `graphql-compose` which derive a graphql types from a mongoose model.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createMany = createMany;
const helpers_1 = require("./helpers");
const errorCatcher_1 = require("./helpers/errorCatcher");
const validate_1 = require("./helpers/validate");
const payloadRecordId_1 = require("./helpers/payloadRecordId");
function createMany(model, tc, opts) {
    if (!model || !model.modelName || !model.schema) {
        throw new Error('First arg for Resolver createMany() should be instance of Mongoose Model.');
    }
    if (!tc || tc.constructor.name !== 'ObjectTypeComposer') {
        throw new Error('Second arg for Resolver createMany() should be instance of ObjectTypeComposer.');
    }
    const tree = model.schema.obj;
    const requiredFields = [];
    for (const field in tree) {
        if (tree.hasOwnProperty(field)) {
            const fieldOptions = tree[field];
            if (fieldOptions.required && typeof fieldOptions.required !== 'function') {
                requiredFields.push(field);
            }
        }
    }
    const outputTypeName = `CreateMany${tc.getTypeName()}${(opts === null || opts === void 0 ? void 0 : opts.suffix) || ''}Payload`;
    const outputType = tc.schemaComposer.getOrCreateOTC(outputTypeName, (t) => {
        t.setFields(Object.assign(Object.assign({}, (0, payloadRecordId_1.payloadRecordIds)(tc, opts === null || opts === void 0 ? void 0 : opts.recordIds)), { records: {
                type: tc.NonNull.List,
                description: 'Created documents',
            }, createdCount: {
                type: 'Int!',
                description: 'Number of created documents',
                resolve: (s) => s.createdCount || 0,
            } }));
    });
    const resolver = tc.schemaComposer.createResolver({
        name: 'createMany',
        kind: 'mutation',
        description: 'Creates Many documents with mongoose defaults, setters, hooks and validation',
        type: outputType,
        args: {
            records: {
                type: (0, helpers_1.recordHelperArgs)(tc, Object.assign({ prefix: 'CreateMany', suffix: `${(opts === null || opts === void 0 ? void 0 : opts.suffix) || ''}Input`, removeFields: ['id', '_id'], isRequired: true, requiredFields }, opts === null || opts === void 0 ? void 0 : opts.records)).record.type.List.NonNull,
            },
        },
        resolve: (resolveParams) => __awaiter(this, void 0, void 0, function* () {
            var _a;
            const recordData = (_a = resolveParams === null || resolveParams === void 0 ? void 0 : resolveParams.args) === null || _a === void 0 ? void 0 : _a.records;
            if (!Array.isArray(recordData) || recordData.length === 0) {
                throw new Error(`${tc.getTypeName()}.createMany resolver requires args.records to be an Array and must contain at least one record`);
            }
            for (const record of recordData) {
                if (!(typeof record === 'object') || Object.keys(record).length === 0) {
                    throw new Error(`${tc.getTypeName()}.createMany resolver requires args.records to contain non-empty records, with at least one value`);
                }
            }
            const docs = [];
            for (const record of recordData) {
                let doc = new model(record);
                if (resolveParams.beforeRecordMutate) {
                    doc = yield resolveParams.beforeRecordMutate(doc, resolveParams);
                }
                docs.push(doc);
            }
            yield (0, validate_1.validateManyAndThrow)(docs);
            yield model.create(docs, { validateBeforeSave: false });
            return {
                records: docs,
                createdCount: docs.length,
            };
        }),
    });
    if (!(opts === null || opts === void 0 ? void 0 : opts.disableErrorField)) {
        (0, errorCatcher_1.addErrorCatcherField)(resolver);
    }
    return resolver;
}
//# sourceMappingURL=createMany.js.map