apollo-modules/dist/schema.js

Modular system for building apollo schemas

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
require("./polyfills");
;
function init() {
    // schema = [];
    // resolver = {};
}
exports.init = init;
// export function schemas() { return schema; }
// export function resolvers() { return resolver; }
function addModules(apolloDefinitions) {
    let queries = '';
    let mutations = '';
    let options = [];
    let schema = [];
    let resolvers = {};
    for (let apolloDefinition of apolloDefinitions) {
        if (apolloDefinition.modifyOptions) {
            options.push(apolloDefinition.modifyOptions);
        }
        if (apolloDefinition.schema) {
            schema.push(apolloDefinition.schema);
        }
        if (apolloDefinition.queries) {
            if (!resolvers['Query']) {
                resolvers['Query'] = {};
            }
            Object.assign(resolvers['Query'], apolloDefinition.queries);
        }
        if (apolloDefinition.mutations) {
            if (!resolvers['Mutation']) {
                resolvers['Mutation'] = {};
            }
            Object.assign(resolvers['Mutation'], apolloDefinition.mutations);
        }
        if (apolloDefinition.resolvers) {
            Object.assign(resolvers, apolloDefinition.resolvers);
        }
        if (apolloDefinition.queryText) {
            queries += apolloDefinition.queryText + '\n';
        }
        if (apolloDefinition.mutationText) {
            mutations += apolloDefinition.mutationText + '\n';
        }
    }
    // add all the queries and mutations
    queries = `
    type Query {
      ${queries}
    }
    `;
    schema.push(queries);
    if (mutations) {
        mutations = `
    type Mutation {
      ${mutations}
    }
    `;
        schema.push(mutations);
    }
    return {
        schema,
        resolvers,
        options
    };
}
exports.addModules = addModules;
function createServer(apolloOptions) {
    const { schema, resolvers, options } = apolloOptions.modules;
    return function (req) {
        return __awaiter(this, void 0, void 0, function* () {
            const cloned = Object.assign({}, apolloOptions);
            cloned.context = Object.assign({}, cloned.context);
            // process all option modifiers
            if (options.length === 1) {
                yield options[0](req, cloned);
            }
            else if (options.length > 1) {
                yield Promise.all(options.map((o) => __awaiter(this, void 0, void 0, function* () { return yield o(req, cloned); })));
            }
            return cloned;
        });
    };
}
exports.createServer = createServer;