@grapi/server/lib/grapi.js

Grapi Schema Generator For GraphQL Server

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Grapi = void 0;
const schema_1 = require("@graphql-tools/schema");
const constants_1 = require("./constants");
const dataModel_1 = require("./dataModel");
const generator_1 = __importDefault(require("./generator"));
const mergeHooks_1 = __importDefault(require("./hooks/mergeHooks"));
const relationHook_1 = require("./hooks/relationHook");
const lodash_1 = require("./lodash");
const parse_1 = require("./parse");
const plugins_1 = require("./plugins");
const constants_2 = require("./plugins/constants");
const printer_1 = require("./printer");
const combine_1 = __importDefault(require("./resolver/combine"));
const scalars_1 = require("./scalars");
class Grapi {
    sdl;
    dataSources;
    scalars;
    enums;
    schemaDirectives;
    context;
    rootNode;
    models;
    userDefinedPlugins;
    config;
    skipPrint;
    constructor({ sdl, dataSources, scalars, enums, context, skipPrint, rootNode, models, plugins, schemaDirectives, }) {
        this.sdl = sdl ? sdl.concat(...[constants_2.scalarSchema]) : ``;
        this.dataSources = dataSources;
        this.scalars = (0, lodash_1.assign)(scalars_1.customScalars, scalars);
        this.enums = enums;
        this.context = context;
        this.skipPrint = skipPrint;
        this.rootNode = rootNode;
        this.models = models;
        this.userDefinedPlugins = plugins;
        this.schemaDirectives = schemaDirectives;
        this.createServerConfig();
    }
    bindDataSourceInModels(models, modelMap) {
        models.forEach(model => {
            modelMap[model.getName()] = model;
            if (!model.getDataSource()) {
                const dataSourceArgs = model.getMetadata(constants_1.MODEL_DIRECTIVE);
                const dataSourceIdentifier = dataSourceArgs[constants_1.MODEL_DIRECTIVE_SOURCE_NAME];
                const createDataSource = this.dataSources[dataSourceIdentifier];
                if (!createDataSource) {
                    throw new Error(`dataSource ${dataSourceIdentifier} does not exist`);
                }
                const args = (0, lodash_1.omit)(dataSourceArgs, constants_1.MODEL_DIRECTIVE_SOURCE_NAME);
                const dataSource = createDataSource(args);
                model.setDataSource(dataSource);
            }
        });
    }
    createServerConfig() {
        const ifSkipPrint = this.skipPrint || false;
        let rootNode;
        let models;
        if ((0, lodash_1.isUndefined)(this.rootNode) || (0, lodash_1.isEmpty)(this.models)) {
            const parseResult = (0, parse_1.parse)(this.sdl);
            rootNode = parseResult.rootNode;
            models = parseResult.models;
        }
        else {
            rootNode = this.rootNode;
            models = this.models;
        }
        const modelMap = {};
        this.bindDataSourceInModels(models, modelMap);
        const relations = (0, dataModel_1.createRelation)(models);
        const relationHooks = (0, relationHook_1.createRelationHooks)(relations);
        if (!ifSkipPrint) {
            (0, printer_1.printModels)(models);
            (0, printer_1.printRelations)(relations);
        }
        const hookMap = (0, mergeHooks_1.default)(relationHooks);
        const plugins = [
            new plugins_1.BaseTypePlugin(),
            new plugins_1.WhereInputPlugin(),
            new plugins_1.OrderInputPlugin(),
            new plugins_1.QueryPlugin(),
            new plugins_1.RelayPlugin(),
            new plugins_1.CreatePlugin({ hook: hookMap }),
            new plugins_1.UpdatePlugin({ hook: hookMap }),
            new plugins_1.DeletePlugin({ hook: hookMap }),
            ...this.userDefinedPlugins || [],
        ];
        (0, lodash_1.forEach)(hookMap, (hook, key) => {
            if (!modelMap[key]) {
                throw new Error(`model ${key} not found for hooks`);
            }
            modelMap[key].mergeResolver(hook.resolveFields);
        });
        models.forEach(model => {
            if (model.getDataSource().resolveFields) {
                model.mergeResolver(model.getDataSource().resolveFields());
            }
        });
        rootNode.addSdl(constants_2.orderByInputEnum);
        rootNode.addInput(constants_2.inputIntBetween);
        rootNode.addInput(constants_2.inputFloatBetween);
        rootNode.addInput(constants_2.inputDateTimeBetween);
        const generator = new generator_1.default({ plugins, rootNode });
        const resolvers = (0, combine_1.default)(plugins, models);
        const typeDefs = generator.generate(models);
        this.config = {
            schema: (0, schema_1.makeExecutableSchema)({
                resolvers: (0, lodash_1.assign)(resolvers, this.scalars),
                typeDefs: typeDefs.concat(constants_2.scalarSchema),
            }),
            context: this.context
        };
    }
    createApolloConfig() {
        return this.config;
    }
}
exports.Grapi = Grapi;