@graphql-mesh/json-schema/index.cjs.js

'use strict';

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

const graphql = require('graphql');
const pascalCase = require('pascal-case');
const graphqlScalars = require('graphql-scalars');
const urlJoin = _interopDefault(require('url-join'));
const utils = require('@graphql-mesh/utils');
const AggregateError = _interopDefault(require('aggregate-error'));
const fetchache = require('fetchache');

const asArray = (maybeArray) => {
    if (Array.isArray(maybeArray)) {
        return maybeArray;
    }
    else if (maybeArray) {
        return [maybeArray];
    }
    else {
        return [];
    }
};
class JSONSchemaVisitorCache {
    constructor() {
        this.inputSpecificTypesByIdentifier = new Map();
        this.outputSpecificTypesByIdentifier = new Map();
        this.sharedTypesByIdentifier = new Map();
        this.typesByNames = new Map();
        this.prefixedNames = new Set();
        this.potentialPrefixes = new WeakMap();
    }
}
class JSONSchemaVisitor {
    constructor(cache = new JSONSchemaVisitorCache()) {
        this.cache = cache;
        this.warnedReferences = new Set();
    }
    getNameFromId(id) {
        const [actualTypePath, genericTypePart] = id.split('<');
        const actualTypePathParts = actualTypePath.split(':');
        const actualTypeName = actualTypePathParts[actualTypePathParts.length - 1];
        let finalTypeName = actualTypeName;
        if (genericTypePart) {
            const [genericTypePath] = genericTypePart.split('>');
            const genericTypeParts = genericTypePath.split(':');
            const genericTypeName = genericTypeParts[genericTypeParts.length - 1];
            finalTypeName = actualTypeName + '_' + genericTypeName;
        }
        return pascalCase.pascalCase(finalTypeName);
    }
    visit(def, propertyName, prefix, isInput) {
        if ('definitions' in def) {
            for (const propertyName in def.definitions) {
                const definition = def.definitions[propertyName];
                this.visit(definition, propertyName, prefix, isInput);
            }
        }
        if ('$defs' in def) {
            for (const propertyName in def.$defs) {
                const definition = def.$defs[propertyName];
                this.visit(definition, propertyName, prefix, isInput);
            }
        }
        switch (def.type) {
            case 'array':
                return this.visitArray(def, propertyName, prefix, isInput);
            case 'boolean':
                return this.visitBoolean();
            case 'integer':
                return this.visitInteger();
            case 'number':
                return this.visitNumber();
            case 'string':
                if ('enum' in def) {
                    return this.visitEnum(def, propertyName, prefix);
                }
                else {
                    return this.visitString();
                }
            case 'null':
            case 'any':
                return this.visitAny();
            case 'object':
                if ('$ref' in def) {
                    return this.visitObjectReference(def, isInput);
                }
                else if ('name' in def || 'title' in def) {
                    return this.visitTypedNamedObjectDefinition(def, prefix, isInput);
                }
                else if ('properties' in def) {
                    return this.visitTypedUnnamedObjectDefinition(def, propertyName, prefix, isInput);
                }
                else if ('additionalProperties' in def && def.additionalProperties) {
                    return this.visitAny();
                }
                break;
        }
        throw new Error(`Unexpected schema definition:
        ${JSON.stringify(def, null, 2)}`);
    }
    visitArray(arrayDef, propertyName, prefix, isInput) {
        const [itemsDef] = asArray(arrayDef.items);
        return new graphql.GraphQLList(itemsDef ? this.visit(itemsDef, propertyName, prefix, isInput) : this.visitAny());
    }
    visitBoolean() {
        return graphql.GraphQLBoolean;
    }
    visitInteger() {
        return graphql.GraphQLInt;
    }
    visitNumber() {
        return graphql.GraphQLFloat;
    }
    visitString() {
        return graphql.GraphQLString;
    }
    visitEnum(enumDef, propertyName, prefix) {
        const enumIdentifier = JSON.stringify(enumDef);
        if (!this.cache.sharedTypesByIdentifier.has(enumIdentifier)) {
            // If there is a different enum but with the same name,
            // just change the existing one's name and use prefixes from now on
            let name = pascalCase.pascalCase(propertyName);
            if (!this.cache.prefixedNames.has(name) && this.cache.typesByNames.has(name)) {
                const existingType = this.cache.typesByNames.get(name);
                if ('name' in existingType) {
                    const prefix = this.cache.potentialPrefixes.get(existingType);
                    existingType.name = pascalCase.pascalCase(prefix + '_' + name);
                    this.cache.prefixedNames.add(name);
                    this.cache.typesByNames.delete(name);
                    if (this.cache.typesByNames.has(existingType.name)) {
                        throw existingType.name;
                    }
                    this.cache.typesByNames.set(existingType.name, existingType);
                }
            }
            if (this.cache.prefixedNames.has(name)) {
                name = pascalCase.pascalCase(prefix + '_' + name);
            }
            const type = new graphql.GraphQLEnumType({
                name,
                description: enumDef.description,
                values: enumDef.enum.reduce((values, enumValue) => ({ ...values, [enumValue]: {} }), {}),
            });
            this.cache.potentialPrefixes.set(type, prefix);
            this.cache.sharedTypesByIdentifier.set(enumIdentifier, type);
            if (this.cache.typesByNames.has(name)) {
                throw name;
            }
            this.cache.typesByNames.set(name, type);
        }
        return this.cache.sharedTypesByIdentifier.get(enumIdentifier);
    }
    createFieldsMapFromProperties(objectDef, prefix, isInput) {
        var _a;
        const fieldMap = {};
        for (const propertyName in objectDef.properties) {
            const fieldName = propertyName.split(':').join('_');
            const property = objectDef.properties[propertyName];
            const type = this.visit(property, propertyName, prefix, isInput);
            const isRequired = 'required' in objectDef && ((_a = objectDef.required) === null || _a === void 0 ? void 0 : _a.includes(propertyName));
            fieldMap[fieldName] = {
                type: isRequired ? new graphql.GraphQLNonNull(type) : type,
                description: property.description,
            };
            if (fieldName !== propertyName) {
                fieldMap[fieldName].resolve = (root) => root[propertyName];
            }
        }
        return fieldMap;
    }
    getSpecificTypeByIdentifier(identifier, isInput) {
        return (this.cache.sharedTypesByIdentifier.get(identifier) ||
            (isInput
                ? this.cache.inputSpecificTypesByIdentifier.get(identifier)
                : this.cache.outputSpecificTypesByIdentifier.get(identifier)));
    }
    getGraphQLObjectTypeWithTypedObjectDef(objectDef, objectIdentifier, rawName, prefix, isInput) {
        const specificType = this.getSpecificTypeByIdentifier(objectIdentifier, isInput);
        if (!specificType) {
            let name = rawName;
            // If there is a different object but with the same name,
            // just change the existing one's name and use prefixes from now on
            if (!this.cache.prefixedNames.has(name) && this.cache.typesByNames.has(name)) {
                const existingType = this.cache.typesByNames.get(name);
                if ('name' in existingType) {
                    const existingTypePrefix = this.cache.potentialPrefixes.get(existingType);
                    existingType.name = pascalCase.pascalCase(existingTypePrefix + '_' + name);
                    this.cache.prefixedNames.add(name);
                    this.cache.typesByNames.delete(name);
                    if (this.cache.typesByNames.has(existingType.name)) {
                        throw existingType.name;
                    }
                    this.cache.typesByNames.set(existingType.name, existingType);
                }
            }
            // If this name should be prefixed
            if (this.cache.prefixedNames.has(name)) {
                name = pascalCase.pascalCase(prefix + '_' + name);
            }
            if (this.cache.typesByNames.has(name)) {
                const suffix = isInput ? 'Input' : 'Output';
                name = pascalCase.pascalCase(name + '_' + suffix);
            }
            if (isInput) {
                const inputType = new graphql.GraphQLInputObjectType({
                    name,
                    description: objectDef.description,
                    fields: this.createFieldsMapFromProperties(objectDef, name, true),
                });
                this.cache.inputSpecificTypesByIdentifier.set(objectIdentifier, inputType);
                this.cache.typesByNames.set(inputType.name, inputType);
                this.cache.potentialPrefixes.set(inputType, prefix);
                return inputType;
            }
            else {
                const outputType = new graphql.GraphQLObjectType({
                    name,
                    description: objectDef.description,
                    fields: this.createFieldsMapFromProperties(objectDef, name, false),
                });
                this.cache.outputSpecificTypesByIdentifier.set(objectIdentifier, outputType);
                this.cache.typesByNames.set(outputType.name, outputType);
                this.cache.potentialPrefixes.set(outputType, prefix);
                return outputType;
            }
        }
        return specificType;
    }
    visitTypedUnnamedObjectDefinition(typedUnnamedObjectDef, propertyName, prefix, isInput) {
        const objectIdentifier = 'id' in typedUnnamedObjectDef
            ? typedUnnamedObjectDef.id
            : '$id' in typedUnnamedObjectDef
                ? typedUnnamedObjectDef.$id
                : `${prefix}_${propertyName}`;
        const name = this.getNameFromId(objectIdentifier);
        return this.getGraphQLObjectTypeWithTypedObjectDef(typedUnnamedObjectDef, objectIdentifier, name, prefix, isInput);
    }
    visitTypedNamedObjectDefinition(typedNamedObjectDef, prefix, isInput) {
        const objectIdentifier = 'name' in typedNamedObjectDef ? typedNamedObjectDef.name : typedNamedObjectDef.title;
        const name = pascalCase.pascalCase(objectIdentifier);
        return this.getGraphQLObjectTypeWithTypedObjectDef(typedNamedObjectDef, objectIdentifier, name, prefix, isInput);
    }
    visitObjectReference(objectRef, isInput) {
        const referenceParts = objectRef.$ref.split('/');
        const reference = referenceParts[referenceParts.length - 1];
        const specificType = this.getSpecificTypeByIdentifier(reference, isInput);
        if (!specificType) {
            if (!this.warnedReferences.has(reference) && !this.warnedReferences.has(reference)) {
                console.warn(`Missing JSON Schema reference: ${reference}. GraphQLJSON will be used instead!`);
                this.warnedReferences.add(reference);
            }
            return this.visitAny();
        }
        return specificType;
    }
    visitAny() {
        return graphqlScalars.JSONResolver;
    }
}

const handler = {
    async getMeshSource({ config, cache }) {
        var _a, _b;
        const visitorCache = new JSONSchemaVisitorCache();
        await Promise.all(((_a = config.typeReferences) === null || _a === void 0 ? void 0 : _a.map(typeReference => Promise.all(Object.keys(typeReference).map(async (key) => {
            switch (key) {
                case 'sharedType': {
                    const sharedType = await utils.loadFromModuleExportExpression(typeReference.sharedType);
                    visitorCache.sharedTypesByIdentifier.set(typeReference.reference, sharedType);
                    break;
                }
                case 'outputType': {
                    const outputType = await utils.loadFromModuleExportExpression(typeReference.outputType);
                    visitorCache.outputSpecificTypesByIdentifier.set(typeReference.reference, outputType);
                    break;
                }
                case 'inputType': {
                    const inputType = await utils.loadFromModuleExportExpression(typeReference.inputType);
                    visitorCache.inputSpecificTypesByIdentifier.set(typeReference.reference, inputType);
                    break;
                }
                case 'reference':
                    break;
                default:
                    throw new Error(`Unexpected type reference field: ${key}`);
            }
        })))) || []);
        const queryFields = {};
        const mutationFields = {};
        const schemaVisitor = new JSONSchemaVisitor(visitorCache);
        const contextVariables = [];
        await Promise.all(((_b = config.operations) === null || _b === void 0 ? void 0 : _b.map(async (operationConfig) => {
            const [requestSchema, responseSchema] = await Promise.all([
                operationConfig.requestSchema
                    ? utils.readFileOrUrlWithCache(operationConfig.requestSchema, cache, {
                        headers: config.schemaHeaders,
                    })
                    : undefined,
                utils.readFileOrUrlWithCache(operationConfig.responseSchema, cache, {
                    headers: config.schemaHeaders,
                }),
            ]);
            operationConfig.method = operationConfig.method || (operationConfig.type === 'Mutation' ? 'POST' : 'GET');
            operationConfig.type = operationConfig.type || (operationConfig.method === 'GET' ? 'Query' : 'Mutation');
            const destination = operationConfig.type === 'Query' ? queryFields : mutationFields;
            const type = schemaVisitor.visit(responseSchema, 'Response', operationConfig.field, false);
            const { args, contextVariables: specificContextVariables } = utils.parseInterpolationStrings([
                ...Object.values(config.operationHeaders || {}),
                ...Object.values(operationConfig.headers || {}),
                operationConfig.path,
            ]);
            contextVariables.push(...specificContextVariables);
            if (requestSchema) {
                args.input = {
                    type: schemaVisitor.visit(requestSchema, 'Request', operationConfig.field, true),
                };
            }
            destination[operationConfig.field] = {
                description: operationConfig.description ||
                    responseSchema.description ||
                    `${operationConfig.method} ${operationConfig.path}`,
                type,
                args,
                resolve: async (root, args, context, info) => {
                    const interpolationData = { root, args, context, info };
                    const interpolatedPath = utils.stringInterpolator.parse(operationConfig.path, interpolationData);
                    const fullPath = urlJoin(config.baseUrl, interpolatedPath);
                    const method = operationConfig.method;
                    const headers = {
                        ...config.operationHeaders,
                        ...operationConfig === null || operationConfig === void 0 ? void 0 : operationConfig.headers,
                    };
                    for (const headerName in headers) {
                        headers[headerName] = utils.stringInterpolator.parse(headers[headerName], interpolationData);
                    }
                    const requestInit = {
                        method,
                        headers,
                    };
                    const urlObj = new URL(fullPath);
                    const input = args.input;
                    if (input) {
                        switch (method) {
                            case 'GET':
                            case 'DELETE': {
                                const newSearchParams = new URLSearchParams(input);
                                newSearchParams.forEach((value, key) => {
                                    urlObj.searchParams.set(key, value);
                                });
                                break;
                            }
                            case 'POST':
                            case 'PUT': {
                                requestInit.body = JSON.stringify(input);
                                break;
                            }
                            default:
                                throw new Error(`Unknown method ${operationConfig.method}`);
                        }
                    }
                    const request = new fetchache.Request(urlObj.toString(), requestInit);
                    const response = await fetchache.fetchache(request, cache);
                    const responseText = await response.text();
                    let responseJson;
                    try {
                        responseJson = JSON.parse(responseText);
                    }
                    catch (e) {
                        throw responseText;
                    }
                    if (responseJson.errors) {
                        throw new AggregateError(responseJson.errors);
                    }
                    if (responseJson._errors) {
                        throw new AggregateError(responseJson._errors);
                    }
                    if (responseJson.error) {
                        throw responseJson.error;
                    }
                    return responseJson;
                },
            };
        })) || []);
        const schema = new graphql.GraphQLSchema({
            query: new graphql.GraphQLObjectType({
                name: 'Query',
                fields: Object.keys(queryFields).length > 0 ? queryFields : { ping: { type: graphql.GraphQLBoolean, resolve: () => true } },
            }),
            mutation: Object.keys(mutationFields).length > 0
                ? new graphql.GraphQLObjectType({
                    name: 'Mutation',
                    fields: mutationFields,
                })
                : undefined,
        });
        return {
            schema,
            contextVariables,
        };
    },
};

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