2/node_modules/apollo-graphql/lib/schema/buildSchemaFromSDL.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.addResolversToSchema = exports.buildSchemaFromSDL = exports.modulesFromSDL = void 0;
const graphql_1 = require("graphql");
const validate_1 = require("graphql/validation/validate");
const graphql_2 = require("../utilities/graphql");
const GraphQLSchemaValidationError_1 = require("./GraphQLSchemaValidationError");
const specifiedRules_1 = require("graphql/validation/specifiedRules");
const flat_1 = __importDefault(require("core-js-pure/features/array/flat"));
const validation_1 = require("graphql/validation");
const mapValues_1 = require("../utilities/mapValues");
const skippedSDLRules = [
    validation_1.KnownTypeNamesRule,
    validation_1.UniqueDirectivesPerLocationRule,
];
try {
    const PossibleTypeExtensions = require("graphql/validation/rules/PossibleTypeExtensions").PossibleTypeExtensions;
    if (PossibleTypeExtensions) {
        skippedSDLRules.push(PossibleTypeExtensions);
    }
}
catch (e) {
}
const sdlRules = specifiedRules_1.specifiedSDLRules.filter((rule) => !skippedSDLRules.includes(rule));
function modulesFromSDL(modulesOrSDL) {
    if (Array.isArray(modulesOrSDL)) {
        return modulesOrSDL.map((moduleOrSDL) => {
            if ((0, graphql_2.isNode)(moduleOrSDL) && (0, graphql_2.isDocumentNode)(moduleOrSDL)) {
                return { typeDefs: moduleOrSDL };
            }
            else {
                return moduleOrSDL;
            }
        });
    }
    else {
        return [{ typeDefs: modulesOrSDL }];
    }
}
exports.modulesFromSDL = modulesFromSDL;
function buildSchemaFromSDL(modulesOrSDL, schemaToExtend) {
    const modules = modulesFromSDL(modulesOrSDL);
    const documentAST = (0, graphql_1.concatAST)(modules.map((module) => module.typeDefs));
    const errors = (0, validate_1.validateSDL)(documentAST, schemaToExtend, sdlRules);
    if (errors.length > 0) {
        throw new GraphQLSchemaValidationError_1.GraphQLSchemaValidationError(errors);
    }
    const definitionsMap = Object.create(null);
    const extensionsMap = Object.create(null);
    const directiveDefinitions = [];
    const schemaDefinitions = [];
    const schemaExtensions = [];
    const schemaDirectives = [];
    for (const definition of documentAST.definitions) {
        if ((0, graphql_1.isTypeDefinitionNode)(definition)) {
            const typeName = definition.name.value;
            if (definitionsMap[typeName]) {
                definitionsMap[typeName].push(definition);
            }
            else {
                definitionsMap[typeName] = [definition];
            }
        }
        else if ((0, graphql_1.isTypeExtensionNode)(definition)) {
            const typeName = definition.name.value;
            if (extensionsMap[typeName]) {
                extensionsMap[typeName].push(definition);
            }
            else {
                extensionsMap[typeName] = [definition];
            }
        }
        else if (definition.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) {
            directiveDefinitions.push(definition);
        }
        else if (definition.kind === graphql_1.Kind.SCHEMA_DEFINITION) {
            schemaDefinitions.push(definition);
            schemaDirectives.push(...(definition.directives ? definition.directives : []));
        }
        else if (definition.kind === graphql_1.Kind.SCHEMA_EXTENSION) {
            schemaExtensions.push(definition);
        }
    }
    let schema = schemaToExtend
        ? schemaToExtend
        : new graphql_1.GraphQLSchema({
            query: undefined,
        });
    const missingTypeDefinitions = [];
    for (const [extendedTypeName, extensions] of Object.entries(extensionsMap)) {
        if (!definitionsMap[extendedTypeName]) {
            const extension = extensions[0];
            const kind = extension.kind;
            const definition = {
                kind: extKindToDefKind[kind],
                name: extension.name,
            };
            missingTypeDefinitions.push(definition);
        }
    }
    schema = (0, graphql_1.extendSchema)(schema, {
        kind: graphql_1.Kind.DOCUMENT,
        definitions: [
            ...(0, flat_1.default)(Object.values(definitionsMap)),
            ...missingTypeDefinitions,
            ...directiveDefinitions,
        ],
    }, {
        assumeValidSDL: true,
    });
    schema = (0, graphql_1.extendSchema)(schema, {
        kind: graphql_1.Kind.DOCUMENT,
        definitions: (0, flat_1.default)(Object.values(extensionsMap)),
    }, {
        assumeValidSDL: true,
    });
    let operationTypeMap;
    if (schemaDefinitions.length > 0 || schemaExtensions.length > 0) {
        operationTypeMap = {};
        const operationTypes = (0, flat_1.default)([...schemaDefinitions, ...schemaExtensions]
            .map((node) => node.operationTypes)
            .filter(isNotNullOrUndefined));
        for (const { operation, type } of operationTypes) {
            operationTypeMap[operation] = type.name.value;
        }
    }
    else {
        operationTypeMap = {
            query: "Query",
            mutation: "Mutation",
            subscription: "Subscription",
        };
    }
    schema = new graphql_1.GraphQLSchema(Object.assign(Object.assign(Object.assign({}, schema.toConfig()), (0, mapValues_1.mapValues)(operationTypeMap, (typeName) => typeName
        ? schema.getType(typeName)
        : undefined)), { astNode: {
            kind: graphql_1.Kind.SCHEMA_DEFINITION,
            directives: schemaDirectives,
            operationTypes: [],
        } }));
    for (const module of modules) {
        if (!module.resolvers)
            continue;
        addResolversToSchema(schema, module.resolvers);
    }
    return schema;
}
exports.buildSchemaFromSDL = buildSchemaFromSDL;
const extKindToDefKind = {
    [graphql_1.Kind.SCALAR_TYPE_EXTENSION]: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
    [graphql_1.Kind.OBJECT_TYPE_EXTENSION]: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
    [graphql_1.Kind.INTERFACE_TYPE_EXTENSION]: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
    [graphql_1.Kind.UNION_TYPE_EXTENSION]: graphql_1.Kind.UNION_TYPE_DEFINITION,
    [graphql_1.Kind.ENUM_TYPE_EXTENSION]: graphql_1.Kind.ENUM_TYPE_DEFINITION,
    [graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION]: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
};
function addResolversToSchema(schema, resolvers) {
    for (const [typeName, fieldConfigs] of Object.entries(resolvers)) {
        const type = schema.getType(typeName);
        if ((0, graphql_1.isAbstractType)(type)) {
            for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
                if (fieldName.startsWith("__")) {
                    type[fieldName.substring(2)] = fieldConfig;
                }
            }
        }
        if ((0, graphql_1.isScalarType)(type)) {
            for (const fn in fieldConfigs) {
                type[fn] = fieldConfigs[fn];
            }
        }
        if ((0, graphql_1.isEnumType)(type)) {
            const values = type.getValues();
            const newValues = {};
            values.forEach((value) => {
                let newValue = fieldConfigs[value.name];
                if (newValue === undefined) {
                    newValue = value.name;
                }
                newValues[value.name] = {
                    value: newValue,
                    deprecationReason: value.deprecationReason,
                    description: value.description,
                    astNode: value.astNode,
                    extensions: undefined,
                };
            });
            Object.assign(type, new graphql_1.GraphQLEnumType(Object.assign(Object.assign({}, type.toConfig()), { values: newValues })));
        }
        if (!(0, graphql_1.isObjectType)(type))
            continue;
        const fieldMap = type.getFields();
        for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
            if (fieldName.startsWith("__")) {
                type[fieldName.substring(2)] = fieldConfig;
                continue;
            }
            const field = fieldMap[fieldName];
            if (!field)
                continue;
            if (typeof fieldConfig === "function") {
                field.resolve = fieldConfig;
            }
            else {
                field.resolve = fieldConfig.resolve;
            }
        }
    }
}
exports.addResolversToSchema = addResolversToSchema;
function isNotNullOrUndefined(value) {
    return value !== null && typeof value !== "undefined";
}
//# sourceMappingURL=buildSchemaFromSDL.js.map