@omnigraph/json-schema 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/index.js

@@ -1,1890 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const utils = require('@graphql-mesh/utils');
-const toJsonSchema = _interopDefault(require('to-json-schema'));
-const jsonMachete = require('json-machete');
-const stringInterpolation = require('@graphql-mesh/string-interpolation');
-const crossHelpers = require('@graphql-mesh/cross-helpers');
-const graphql = require('graphql');
-const graphqlCompose = require('graphql-compose');
-const utils$1 = require('@graphql-tools/utils');
-const urlJoin = _interopDefault(require('url-join'));
-const qs = require('qs');
-const lodashSet = _interopDefault(require('lodash.set'));
-const graphqlScalars = require('graphql-scalars');
-const Ajv = _interopDefault(require('ajv'));
-const addFormats = _interopDefault(require('ajv-formats'));
-const pascalCase = require('pascal-case');
-const fetch = require('@whatwg-node/fetch');
-
-function isPubSubOperationConfig(operationConfig) {
-    return 'pubsubTopic' in operationConfig;
-}
-function getOperationMetadata(operationConfig) {
-    let httpMethod;
-    let operationType;
-    let rootTypeName;
-    if (isPubSubOperationConfig(operationConfig)) {
-        httpMethod = null;
-        operationType = 'subscription';
-        rootTypeName = 'Subscription';
-    }
-    else {
-        httpMethod = operationConfig.method;
-        // Fix compability with Mesh handler
-        operationType = operationConfig.type.toLowerCase();
-        if (!httpMethod) {
-            if (operationType === 'mutation') {
-                httpMethod = 'POST';
-            }
-            else {
-                httpMethod = 'GET';
-            }
-        }
-        if (!rootTypeName) {
-            if (httpMethod === 'GET') {
-                rootTypeName = 'Query';
-            }
-        }
-        rootTypeName = operationType === 'query' ? 'Query' : 'Mutation';
-    }
-    return {
-        httpMethod,
-        operationType,
-        rootTypeName,
-        fieldName: operationConfig.field,
-    };
-}
-function cleanObject(obj) {
-    if (typeof obj === 'object' && obj != null) {
-        const newObj = Array.isArray(obj) ? [] : {};
-        for (const key in obj) {
-            const newObjForKey = cleanObject(obj[key]);
-            if (newObjForKey != null) {
-                newObj[key] = newObjForKey;
-            }
-        }
-        return newObj;
-    }
-    return obj;
-}
-function isFileUpload(obj) {
-    return typeof obj.createReadStream === 'function';
-}
-
-const anySchema = {
-    title: 'Any',
-    anyOf: [
-        {
-            type: 'object',
-            additionalProperties: true,
-        },
-        {
-            type: 'string',
-        },
-        {
-            type: 'number',
-        },
-        {
-            type: 'boolean',
-        },
-    ],
-};
-async function handleOperationResponseConfig(operationResponseConfig, { schemaHeaders, cwd, fetchFn, logger = new utils.DefaultLogger('handleOperationResponseConfig'), }) {
-    if (operationResponseConfig.responseSchema) {
-        const schema = typeof operationResponseConfig.responseSchema === 'string'
-            ? {
-                $ref: operationResponseConfig.responseSchema,
-                title: operationResponseConfig.responseTypeName,
-            }
-            : operationResponseConfig.responseSchema;
-        if (operationResponseConfig.responseSample) {
-            schema.examples = schema.examples || [operationResponseConfig.responseSample];
-        }
-        return schema;
-    }
-    else if (operationResponseConfig.responseSample) {
-        const sample = typeof operationResponseConfig.responseSample === 'object'
-            ? operationResponseConfig.responseSample
-            : await utils.readFileOrUrl(operationResponseConfig.responseSample, {
-                cwd,
-                fetch: fetchFn,
-                logger,
-                importFn: utils.defaultImportFn,
-                headers: schemaHeaders,
-            }).catch((e) => {
-                throw new Error(`responseSample - ${e.message}`);
-            });
-        const generatedSchema = toJsonSchema(sample, {
-            required: false,
-            objects: {
-                additionalProperties: false,
-            },
-            strings: {
-                detectFormat: true,
-            },
-            arrays: {
-                mode: 'first',
-            },
-        });
-        generatedSchema.title = operationResponseConfig.responseTypeName;
-        generatedSchema.examples = [sample];
-        return generatedSchema;
-    }
-    else {
-        const generatedSchema = operationResponseConfig.responseTypeName
-            ? {
-                ...anySchema,
-                title: operationResponseConfig.responseTypeName,
-            }
-            : anySchema;
-        return generatedSchema;
-    }
-}
-async function getReferencedJSONSchemaFromOperations({ operations, cwd, schemaHeaders, ignoreErrorResponses, logger = new utils.DefaultLogger('getReferencedJSONSchemaFromOperations'), fetchFn, }) {
-    const finalJsonSchema = {
-        type: 'object',
-        title: '_schema',
-        properties: {},
-        required: ['query'],
-    };
-    for (const operationConfig of operations) {
-        const { operationType, rootTypeName, fieldName } = getOperationMetadata(operationConfig);
-        const rootTypeDefinition = (finalJsonSchema.properties[operationType] = finalJsonSchema.properties[operationType] || {
-            type: 'object',
-            title: rootTypeName,
-            properties: {},
-        });
-        rootTypeDefinition.properties = rootTypeDefinition.properties || {};
-        if ('responseByStatusCode' in operationConfig) {
-            rootTypeDefinition.properties[fieldName] = rootTypeDefinition.properties[fieldName] || {};
-            const statusCodeOneOfIndexMap = {};
-            const responseSchemas = [];
-            for (const statusCode in operationConfig.responseByStatusCode) {
-                if (ignoreErrorResponses && !statusCode.startsWith('2')) {
-                    continue;
-                }
-                const responseOperationConfig = operationConfig.responseByStatusCode[statusCode];
-                const responseOperationSchema = await handleOperationResponseConfig(responseOperationConfig, {
-                    cwd,
-                    schemaHeaders,
-                    fetchFn,
-                    logger,
-                });
-                statusCodeOneOfIndexMap[statusCode] = responseSchemas.length;
-                responseOperationSchema.title = responseOperationSchema.title || `${fieldName}_${statusCode}_response`;
-                responseSchemas.push(responseOperationSchema);
-            }
-            if (responseSchemas.length === 1) {
-                rootTypeDefinition.properties[fieldName] = responseSchemas[0];
-            }
-            else if (responseSchemas.length === 0) {
-                rootTypeDefinition.properties[fieldName] = anySchema;
-            }
-            else {
-                rootTypeDefinition.properties[fieldName] = {
-                    $comment: `statusCodeOneOfIndexMap:${JSON.stringify(statusCodeOneOfIndexMap)}`,
-                    title: fieldName + '_response',
-                    oneOf: responseSchemas,
-                };
-            }
-        }
-        else {
-            rootTypeDefinition.properties[fieldName] = await handleOperationResponseConfig(operationConfig, {
-                cwd,
-                schemaHeaders,
-                fetchFn,
-                logger,
-            });
-        }
-        const rootTypeInputPropertyName = operationType + 'Input';
-        const rootInputTypeName = rootTypeName + 'Input';
-        const rootTypeInputTypeDefinition = (finalJsonSchema.properties[rootTypeInputPropertyName] = finalJsonSchema
-            .properties[rootTypeInputPropertyName] || {
-            type: 'object',
-            title: rootInputTypeName,
-            properties: {},
-        });
-        if ('binary' in operationConfig) {
-            const generatedSchema = {
-                title: operationConfig.requestTypeName || 'File',
-                type: 'file',
-            };
-            rootTypeInputTypeDefinition.properties[fieldName] = generatedSchema;
-        }
-        else if ('requestSchema' in operationConfig && operationConfig.requestSchema) {
-            rootTypeInputTypeDefinition.properties[fieldName] =
-                typeof operationConfig.requestSchema === 'string'
-                    ? {
-                        $ref: operationConfig.requestSchema,
-                        title: operationConfig.requestTypeName,
-                    }
-                    : operationConfig.requestSchema;
-            if (operationConfig.requestSample) {
-                rootTypeInputTypeDefinition.properties[fieldName].examples = rootTypeInputTypeDefinition.properties[fieldName]
-                    .examples || [operationConfig.requestSample];
-            }
-        }
-        else if ('requestSample' in operationConfig) {
-            const sample = typeof operationConfig.requestSample === 'object'
-                ? operationConfig.requestSample
-                : await utils.readFileOrUrl(operationConfig.requestSample, {
-                    cwd,
-                    headers: schemaHeaders,
-                    fetch: fetchFn,
-                    logger,
-                    importFn: utils.defaultImportFn,
-                }).catch((e) => {
-                    throw new Error(`requestSample:${operationConfig.requestSample} cannot be read - ${e.message}`);
-                });
-            const generatedSchema = toJsonSchema(sample, {
-                required: false,
-                objects: {
-                    additionalProperties: false,
-                },
-                strings: {
-                    detectFormat: true,
-                },
-                arrays: {
-                    mode: 'first',
-                },
-            });
-            generatedSchema.title = operationConfig.requestTypeName;
-            generatedSchema.examples = [sample];
-            rootTypeInputTypeDefinition.properties[fieldName] = generatedSchema;
-        }
-    }
-    return finalJsonSchema;
-}
-
-async function getDereferencedJSONSchemaFromOperations({ operations, cwd = crossHelpers.process.cwd(), logger, fetchFn, schemaHeaders, ignoreErrorResponses, noDeduplication = false, }) {
-    const referencedJSONSchema = await getReferencedJSONSchemaFromOperations({
-        operations,
-        cwd,
-        schemaHeaders,
-        ignoreErrorResponses,
-        fetchFn,
-    });
-    logger.debug(`Dereferencing JSON Schema to resolve all $refs`);
-    const schemaHeadersFactory = stringInterpolation.getInterpolatedHeadersFactory(schemaHeaders);
-    const fullyDeferencedSchema = await jsonMachete.dereferenceObject(referencedJSONSchema, {
-        cwd,
-        fetchFn,
-        logger,
-        headers: schemaHeadersFactory({ env: crossHelpers.process.env }),
-    });
-    logger.debug(`Healing JSON Schema`);
-    const healedSchema = await jsonMachete.healJSONSchema(fullyDeferencedSchema, { noDeduplication });
-    return healedSchema;
-}
-
-function resolveDataByUnionInputType(data, type, schemaComposer) {
-    var _a;
-    if (data) {
-        if (graphql.isListType(type)) {
-            return utils$1.asArray(data).map(elem => resolveDataByUnionInputType(elem, type.ofType, schemaComposer));
-        }
-        if (graphql.isNonNullType(type)) {
-            return resolveDataByUnionInputType(data, type.ofType, schemaComposer);
-        }
-        if (graphql.isInputObjectType(type)) {
-            const fieldMap = type.getFields();
-            const isOneOf = schemaComposer.getAnyTC(type).getDirectiveByName('oneOf');
-            data = utils$1.asArray(data)[0];
-            for (const propertyName in data) {
-                const fieldName = utils.sanitizeNameForGraphQL(propertyName);
-                const field = fieldMap[fieldName];
-                if (field) {
-                    if (isOneOf) {
-                        const resolvedData = resolveDataByUnionInputType(data[fieldName], field.type, schemaComposer);
-                        return resolvedData;
-                    }
-                    const realFieldName = ((_a = field.extensions) === null || _a === void 0 ? void 0 : _a.propertyName) || fieldName;
-                    data[realFieldName] = resolveDataByUnionInputType(data[fieldName], field.type, schemaComposer);
-                }
-            }
-        }
-    }
-    return data;
-}
-
-const defaultQsOptions = {
-    indices: false,
-};
-const isListTypeOrNonNullListType = utils$1.memoize1(function isListTypeOrNonNullListType(type) {
-    if (graphql.isNonNullType(type)) {
-        return graphql.isListType(type.ofType);
-    }
-    return graphql.isListType(type);
-});
-function createError(message, extensions) {
-    return new graphql.GraphQLError(message, undefined, undefined, undefined, undefined, undefined, extensions);
-}
-function linkResolver(linkObjArgs, actualResolver, root, args, context, info) {
-    for (const argKey in linkObjArgs) {
-        const argInterpolation = linkObjArgs[argKey];
-        const actualValue = stringInterpolation.stringInterpolator.parse(argInterpolation, {
-            root,
-            args,
-            context,
-            info,
-            env: crossHelpers.process.env,
-        });
-        lodashSet(args, argKey, actualValue);
-        lodashSet(args, `input.${argKey}`, actualValue);
-    }
-    return actualResolver(root, args, context, info);
-}
-const responseMetadataType = new graphql.GraphQLObjectType({
-    name: 'ResponseMetadata',
-    fields: {
-        url: { type: graphql.GraphQLString },
-        method: { type: graphql.GraphQLString },
-        status: { type: graphql.GraphQLInt },
-        statusTest: { type: graphql.GraphQLString },
-        headers: { type: graphqlCompose.GraphQLJSON },
-        body: { type: graphqlCompose.GraphQLJSON },
-    },
-});
-async function addExecutionLogicToComposer(schemaComposer, { fetch: globalFetch, logger, operations, operationHeaders, baseUrl, pubsub: globalPubsub, queryParams, queryStringOptions = {}, }) {
-    logger.debug(`Attaching execution logic to the schema`);
-    const qsOptions = { ...defaultQsOptions, ...queryStringOptions };
-    for (const operationConfig of operations) {
-        const { httpMethod, rootTypeName, fieldName } = getOperationMetadata(operationConfig);
-        const operationLogger = logger.child(`${rootTypeName}.${fieldName}`);
-        const interpolationStrings = [
-            ...Object.values(operationHeaders || {}),
-            ...Object.values(queryParams || {}),
-            baseUrl,
-        ];
-        const rootTypeComposer = schemaComposer[rootTypeName];
-        const field = rootTypeComposer.getField(fieldName);
-        if (isPubSubOperationConfig(operationConfig)) {
-            field.description = operationConfig.description || `PubSub Topic: ${operationConfig.pubsubTopic}`;
-            field.subscribe = (root, args, context, info) => {
-                const pubsub = (context === null || context === void 0 ? void 0 : context.pubsub) || globalPubsub;
-                if (!pubsub) {
-                    return new graphql.GraphQLError(`You should have PubSub defined in either the config or the context!`);
-                }
-                const interpolationData = { root, args, context, info, env: crossHelpers.process.env };
-                const pubsubTopic = stringInterpolation.stringInterpolator.parse(operationConfig.pubsubTopic, interpolationData);
-                operationLogger.debug(`=> Subscribing to pubSubTopic: ${pubsubTopic}`);
-                return pubsub.asyncIterator(pubsubTopic);
-            };
-            field.resolve = root => {
-                operationLogger.debug('Received ', root, ' from ', operationConfig.pubsubTopic);
-                return root;
-            };
-            interpolationStrings.push(operationConfig.pubsubTopic);
-        }
-        else if (operationConfig.path) {
-            if (crossHelpers.process.env.DEBUG) {
-                field.description = `
-    ***Original Description***: ${operationConfig.description || '(none)'}
-    ***Method***: ${operationConfig.method}
-    ***Base URL***: ${baseUrl}
-    ***Path***: ${operationConfig.path}
-`;
-            }
-            else {
-                field.description = operationConfig.description;
-            }
-            field.resolve = async (root, args, context) => {
-                var _a, _b, _c;
-                operationLogger.debug(`=> Resolving`);
-                const interpolationData = { root, args, context, env: crossHelpers.process.env };
-                const interpolatedBaseUrl = stringInterpolation.stringInterpolator.parse(baseUrl, interpolationData);
-                const interpolatedPath = stringInterpolation.stringInterpolator.parse(operationConfig.path, interpolationData);
-                let fullPath = urlJoin(interpolatedBaseUrl, interpolatedPath);
-                const nonInterpolatedHeaders = {
-                    ...operationHeaders,
-                    ...operationConfig === null || operationConfig === void 0 ? void 0 : operationConfig.headers,
-                };
-                const headers = {};
-                for (const headerName in nonInterpolatedHeaders) {
-                    const nonInterpolatedValue = nonInterpolatedHeaders[headerName];
-                    const interpolatedValue = stringInterpolation.stringInterpolator.parse(nonInterpolatedValue, interpolationData);
-                    if (interpolatedValue) {
-                        headers[headerName] = interpolatedValue;
-                    }
-                }
-                const requestInit = {
-                    method: httpMethod,
-                    headers,
-                };
-                if (queryParams) {
-                    const interpolatedQueryParams = {};
-                    for (const queryParamName in queryParams) {
-                        interpolatedQueryParams[queryParamName] = stringInterpolation.stringInterpolator.parse(queryParams[queryParamName], interpolationData);
-                    }
-                    const queryParamsString = qs.stringify(interpolatedQueryParams, qsOptions);
-                    fullPath += fullPath.includes('?') ? '&' : '?';
-                    fullPath += queryParamsString;
-                }
-                // Handle binary data
-                if ('binary' in operationConfig) {
-                    const binaryUpload = await args.input;
-                    if (isFileUpload(binaryUpload)) {
-                        const readable = binaryUpload.createReadStream();
-                        const chunks = [];
-                        for await (const chunk of readable) {
-                            for (const byte of chunk) {
-                                chunks.push(byte);
-                            }
-                        }
-                        requestInit.body = new Uint8Array(chunks);
-                        const [, contentType] = Object.entries(headers).find(([key]) => key.toLowerCase() === 'content-type') || [];
-                        if (!contentType) {
-                            headers['content-type'] = binaryUpload.mimetype;
-                        }
-                    }
-                    requestInit.body = binaryUpload;
-                }
-                else {
-                    if (operationConfig.requestBaseBody != null) {
-                        args.input = args.input || {};
-                        for (const key in operationConfig.requestBaseBody) {
-                            const configValue = operationConfig.requestBaseBody[key];
-                            if (typeof configValue === 'string') {
-                                const value = stringInterpolation.stringInterpolator.parse(configValue, interpolationData);
-                                lodashSet(args.input, key, value);
-                            }
-                            else {
-                                args.input[key] = configValue;
-                            }
-                        }
-                    }
-                    // Resolve union input
-                    const input = (args.input = resolveDataByUnionInputType(cleanObject(args.input), (_c = (_b = (_a = field.args) === null || _a === void 0 ? void 0 : _a.input) === null || _b === void 0 ? void 0 : _b.type) === null || _c === void 0 ? void 0 : _c.getType(), schemaComposer));
-                    if (input != null) {
-                        switch (httpMethod) {
-                            case 'GET':
-                            case 'HEAD':
-                            case 'CONNECT':
-                            case 'OPTIONS':
-                            case 'TRACE': {
-                                fullPath += fullPath.includes('?') ? '&' : '?';
-                                fullPath += qs.stringify(input, qsOptions);
-                                break;
-                            }
-                            case 'POST':
-                            case 'PUT':
-                            case 'PATCH':
-                            case 'DELETE': {
-                                const [, contentType] = Object.entries(headers).find(([key]) => key.toLowerCase() === 'content-type') || [];
-                                if (contentType === null || contentType === void 0 ? void 0 : contentType.startsWith('application/x-www-form-urlencoded')) {
-                                    requestInit.body = qs.stringify(input, qsOptions);
-                                }
-                                else {
-                                    requestInit.body = JSON.stringify(input);
-                                }
-                                break;
-                            }
-                            default:
-                                return createError(`Unknown HTTP Method: ${httpMethod}`, {
-                                    url: fullPath,
-                                    method: httpMethod,
-                                });
-                        }
-                    }
-                }
-                // Delete unused queryparams
-                const [actualPath, queryString] = fullPath.split('?');
-                if (queryString) {
-                    const queryParams = qs.parse(queryString);
-                    const cleanedQueryParams = cleanObject(queryParams);
-                    fullPath = actualPath + '?' + qs.stringify(cleanedQueryParams, qsOptions);
-                }
-                operationLogger.debug(`=> Fetching `, fullPath, `=>`, requestInit);
-                const fetch = (context === null || context === void 0 ? void 0 : context.fetch) || globalFetch;
-                if (!fetch) {
-                    return createError(`You should have fetch defined in either the config or the context!`, {
-                        url: fullPath,
-                        method: httpMethod,
-                    });
-                }
-                const response = await fetch(fullPath, requestInit);
-                // If return type is a file
-                if (field.type.getTypeName() === 'File') {
-                    return response.blob();
-                }
-                const responseText = await response.text();
-                operationLogger.debug(`=> Received`, {
-                    headers: response.headers,
-                    text: responseText,
-                });
-                let responseJson;
-                try {
-                    responseJson = JSON.parse(responseText);
-                }
-                catch (error) {
-                    const returnNamedGraphQLType = graphql.getNamedType(field.type.getType());
-                    // The result might be defined as scalar
-                    if (graphql.isScalarType(returnNamedGraphQLType)) {
-                        operationLogger.debug(` => Return type is not a JSON so returning ${responseText}`);
-                        return responseText;
-                    }
-                    else if (response.status === 204) {
-                        responseJson = {};
-                    }
-                    else {
-                        return createError(`Unexpected response`, {
-                            url: fullPath,
-                            method: httpMethod,
-                            responseText,
-                            error,
-                        });
-                    }
-                }
-                if (!response.status.toString().startsWith('2')) {
-                    const returnNamedGraphQLType = graphql.getNamedType(field.type.getType());
-                    if (!graphql.isUnionType(returnNamedGraphQLType)) {
-                        return createError(`HTTP Error: ${response.status}`, {
-                            url: fullPath,
-                            method: httpMethod,
-                            ...(response.statusText ? { status: response.statusText } : {}),
-                            responseJson,
-                        });
-                    }
-                }
-                operationLogger.debug(`Returning `, responseJson);
-                // Sometimes API returns an array but the return type is not an array
-                const isListReturnType = isListTypeOrNonNullListType(field.type.getType());
-                const isArrayResponse = Array.isArray(responseJson);
-                if (isListReturnType && !isArrayResponse) {
-                    operationLogger.debug(`Response is not array but return type is list. Normalizing the response`);
-                    responseJson = [responseJson];
-                }
-                if (!isListReturnType && isArrayResponse) {
-                    operationLogger.debug(`Response is array but return type is not list. Normalizing the response`);
-                    responseJson = responseJson[0];
-                }
-                const addResponseMetadata = (obj) => {
-                    return {
-                        ...obj,
-                        $url: fullPath,
-                        $method: httpMethod,
-                        $request: {
-                            query: {
-                                ...obj,
-                                ...args,
-                                ...args.input,
-                            },
-                            path: {
-                                ...obj,
-                                ...args,
-                            },
-                            header: requestInit.headers,
-                        },
-                        $response: {
-                            url: fullPath,
-                            method: httpMethod,
-                            status: response.status,
-                            statusText: response.statusText,
-                            headers: utils.getHeadersObj(response.headers),
-                            body: obj,
-                        },
-                    };
-                };
-                operationLogger.debug(`Adding response metadata to the response object`);
-                return Array.isArray(responseJson)
-                    ? responseJson.map(obj => addResponseMetadata(obj))
-                    : addResponseMetadata(responseJson);
-            };
-            interpolationStrings.push(...Object.values(operationConfig.headers || {}));
-            interpolationStrings.push(operationConfig.path);
-            if ('links' in operationConfig) {
-                for (const linkName in operationConfig.links) {
-                    const linkObj = operationConfig.links[linkName];
-                    const typeTC = schemaComposer.getOTC(field.type.getTypeName());
-                    typeTC.addFields({
-                        [linkName]: () => {
-                            const targetField = schemaComposer.Query.getField(linkObj.fieldName);
-                            return {
-                                ...targetField,
-                                args: {},
-                                description: linkObj.description || targetField.description,
-                                resolve: (root, args, context, info) => linkResolver(linkObj.args, targetField.resolve, root, args, context, info),
-                            };
-                        },
-                    });
-                }
-            }
-            if ('exposeResponseMetadata' in operationConfig && operationConfig.exposeResponseMetadata) {
-                const typeTC = schemaComposer.getOTC(field.type.getTypeName());
-                typeTC.addFields({
-                    _response: {
-                        type: responseMetadataType,
-                        resolve: root => root.$response,
-                    },
-                });
-            }
-            if ('responseByStatusCode' in operationConfig) {
-                const unionOrSingleTC = schemaComposer.getAnyTC(graphql.getNamedType(field.type.getType()));
-                const types = 'getTypes' in unionOrSingleTC ? unionOrSingleTC.getTypes() : [unionOrSingleTC];
-                const statusCodeOneOfIndexMap = unionOrSingleTC.getExtension('statusCodeOneOfIndexMap') || {};
-                for (const statusCode in operationConfig.responseByStatusCode) {
-                    const responseConfig = operationConfig.responseByStatusCode[statusCode];
-                    if (responseConfig.links || responseConfig.exposeResponseMetadata) {
-                        const typeTCThunked = types[statusCodeOneOfIndexMap[statusCode] || 0];
-                        const typeTC = schemaComposer.getAnyTC(typeTCThunked.getTypeName());
-                        if ('addFieldArgs' in typeTC) {
-                            if (responseConfig.exposeResponseMetadata) {
-                                typeTC.addFields({
-                                    _response: {
-                                        type: responseMetadataType,
-                                        resolve: root => root.$response,
-                                    },
-                                });
-                            }
-                            for (const linkName in responseConfig.links || []) {
-                                typeTC.addFields({
-                                    [linkName]: () => {
-                                        const linkObj = responseConfig.links[linkName];
-                                        const targetField = schemaComposer.Query.getField(linkObj.fieldName);
-                                        return {
-                                            ...targetField,
-                                            args: {},
-                                            description: linkObj.description || targetField.description,
-                                            resolve: (root, args, context, info) => linkResolver(linkObj.args, targetField.resolve, root, args, context, info),
-                                        };
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        const { args: globalArgs } = stringInterpolation.parseInterpolationStrings(interpolationStrings, operationConfig.argTypeMap);
-        rootTypeComposer.addFieldArgs(fieldName, globalArgs);
-    }
-    logger.debug(`Building the executable schema.`);
-    return schemaComposer;
-}
-
-function getValidTypeName({ schemaComposer, isInput, subSchema, }) {
-    const sanitizedName = utils.sanitizeNameForGraphQL(isInput ? subSchema.title + '_Input' : subSchema.title);
-    if (schemaComposer.has(sanitizedName)) {
-        let i = 2;
-        while (schemaComposer.has(sanitizedName + i)) {
-            i++;
-        }
-        return sanitizedName + i;
-    }
-    return sanitizedName;
-}
-
-function getStringScalarWithMinMaxLength({ schemaComposer, subSchema, }) {
-    const name = getValidTypeName({
-        schemaComposer,
-        isInput: false,
-        subSchema,
-    });
-    function coerceString(value) {
-        if (value != null) {
-            const vStr = value.toString();
-            if (typeof subSchema.minLength !== 'undefined' && vStr.length < subSchema.minLength) {
-                throw new Error(`${name} cannot be less than ${subSchema.minLength} but given ${vStr}`);
-            }
-            if (typeof subSchema.maxLength !== 'undefined' && vStr.length > subSchema.maxLength) {
-                throw new Error(`${name} cannot be more than ${subSchema.maxLength} but given ${vStr}`);
-            }
-            return vStr;
-        }
-    }
-    return schemaComposer.createScalarTC({
-        name,
-        description: subSchema.description,
-        serialize: coerceString,
-        parseValue: coerceString,
-        parseLiteral: ast => {
-            if ('value' in ast) {
-                return coerceString(ast.value);
-            }
-            return null;
-        },
-        extensions: {
-            codegenScalarType: 'string',
-        },
-    });
-}
-
-const JSONSchemaStringFormats = [
-    'date',
-    'hostname',
-    'regex',
-    'json-pointer',
-    'relative-json-pointer',
-    'uri-reference',
-    'uri-template',
-];
-function getJSONSchemaStringFormatScalarMap(ajv) {
-    const map = new Map();
-    for (const format of JSONSchemaStringFormats) {
-        const schema = {
-            type: 'string',
-            format,
-        };
-        let validate;
-        try {
-            validate = ajv.compile(schema);
-        }
-        catch (e) {
-            validate = (value) => ajv.validate(schema, value);
-        }
-        const coerceString = (value) => {
-            if (validate(value)) {
-                return value;
-            }
-            throw new Error(`Expected ${format} but got: ${value}`);
-        };
-        const scalar = new graphql.GraphQLScalarType({
-            name: pascalCase.pascalCase(format),
-            description: `Represents ${format} values`,
-            serialize: coerceString,
-            parseValue: coerceString,
-            parseLiteral: ast => {
-                if (ast.kind === graphql.Kind.STRING) {
-                    return coerceString(ast.value);
-                }
-                throw new Error(`Expected string in ${format} format but got: ${ast.value}`);
-            },
-            extensions: {
-                codegenScalarType: 'string',
-            },
-        });
-        map.set(format, scalar);
-    }
-    return map;
-}
-
-function getTypeResolverFromOutputTCs(ajv, outputTypeComposers, statusCodeOneOfIndexMap) {
-    const statusCodeTypeMap = new Map();
-    for (const statusCode in statusCodeOneOfIndexMap) {
-        statusCodeTypeMap.set(statusCode.toString(), outputTypeComposers[statusCodeOneOfIndexMap[statusCode]]);
-    }
-    return function resolveType(data, context, info) {
-        if (data.__typename) {
-            return data.__typename;
-        }
-        else if (data.resourceType) {
-            return data.resourceType;
-        }
-        if (data.$response && statusCodeOneOfIndexMap) {
-            const responseData = data.$response;
-            const type = statusCodeTypeMap.get(responseData.status.toString()) || statusCodeTypeMap.get('default');
-            if (type) {
-                if ('getFields' in type) {
-                    return type.getTypeName();
-                }
-                else {
-                    return type.getResolveType()(data, context, info, type.getType());
-                }
-            }
-        }
-        const validationErrors = {};
-        for (const outputTypeComposer of outputTypeComposers) {
-            const validateFn = outputTypeComposer.getExtension('validateWithJSONSchema');
-            if (validateFn) {
-                const isValid = validateFn(data);
-                const typeName = outputTypeComposer.getTypeName();
-                if (isValid) {
-                    if ('getFields' in outputTypeComposer) {
-                        return outputTypeComposer.getTypeName();
-                    }
-                    else {
-                        return outputTypeComposer.getResolveType()(data, context, info, outputTypeComposer.getType());
-                    }
-                }
-                validationErrors[typeName] = ajv.errors || validateFn.errors;
-            }
-        }
-        if (data.$response) {
-            const responseData = data.$response;
-            const error = new graphql.GraphQLError(`HTTP Error: ${responseData.status}`, undefined, undefined, undefined, undefined, undefined, {
-                ...responseData,
-                responseJson: data,
-            });
-            console.error(error);
-            return error;
-        }
-        const error = new graphql.GraphQLError(`Received data doesn't met the union`, null, null, null, null, null, {
-            validationErrors,
-        });
-        console.error(error);
-        return error;
-    };
-}
-
-const ONE_OF_DEFINITION = /* GraphQL */ `
-  directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
-`;
-function getUnionTypeComposers({ schemaComposer, ajv, typeComposersList, subSchema, generateInterfaceFromSharedFields, statusCodeOneOfIndexMap, }) {
-    if (typeComposersList.length === 1) {
-        return typeComposersList[0];
-    }
-    const unionInputFields = {};
-    const outputTypeComposers = [];
-    typeComposersList.forEach(typeComposers => {
-        const { input, output } = typeComposers;
-        if (graphqlCompose.isSomeInputTypeComposer(output)) {
-            const containerTypeName = `${output.getTypeName()}_container`;
-            outputTypeComposers.push(schemaComposer.getOrCreateOTC(containerTypeName, otc => otc.addFields({
-                [output.getTypeName()]: {
-                    type: output,
-                    resolve: root => root,
-                },
-            })));
-        }
-        else {
-            outputTypeComposers.push(output);
-        }
-        unionInputFields[input.getTypeName()] = {
-            type: input,
-        };
-    });
-    const input = schemaComposer.createInputTC({
-        name: getValidTypeName({
-            schemaComposer,
-            isInput: true,
-            subSchema,
-        }),
-        description: subSchema.description,
-        fields: unionInputFields,
-    });
-    if (!schemaComposer.hasDirective('oneOf')) {
-        schemaComposer.addTypeDefs(ONE_OF_DEFINITION);
-    }
-    input.setDirectives([
-        {
-            name: 'oneOf',
-            args: {},
-        },
-    ]);
-    let output;
-    let sharedFields;
-    if (generateInterfaceFromSharedFields) {
-        for (const typeComposer of outputTypeComposers) {
-            const fieldMap = typeComposer.getFields();
-            if (!sharedFields) {
-                sharedFields = { ...fieldMap };
-            }
-            else {
-                for (const potentialSharedFieldName in sharedFields) {
-                    if (!(potentialSharedFieldName in fieldMap &&
-                        fieldMap[potentialSharedFieldName].type.getTypeName() ===
-                            sharedFields[potentialSharedFieldName].type.getTypeName())) {
-                        sharedFields[potentialSharedFieldName] = undefined;
-                        delete sharedFields[potentialSharedFieldName];
-                    }
-                }
-            }
-        }
-    }
-    const resolveType = getTypeResolverFromOutputTCs(ajv, outputTypeComposers, statusCodeOneOfIndexMap);
-    if (sharedFields && Object.keys(sharedFields).length > 0) {
-        output = schemaComposer.createInterfaceTC({
-            name: getValidTypeName({
-                schemaComposer,
-                isInput: false,
-                subSchema,
-            }),
-            description: subSchema.description,
-            fields: sharedFields,
-            resolveType,
-            extensions: {
-                statusCodeOneOfIndexMap,
-            },
-        });
-        for (const typeComposer of outputTypeComposers) {
-            typeComposer.addInterface(output);
-            // GraphQL removes implementations
-            schemaComposer.addSchemaMustHaveType(typeComposer);
-        }
-    }
-    else {
-        // If no shared fields found
-        output = schemaComposer.createUnionTC({
-            name: getValidTypeName({
-                schemaComposer,
-                isInput: false,
-                subSchema,
-            }),
-            description: subSchema.description,
-            types: () => {
-                const possibleTypes = [];
-                for (const outputTypeComposer of outputTypeComposers) {
-                    if ('getFields' in outputTypeComposer) {
-                        possibleTypes.push(outputTypeComposer);
-                    }
-                    else {
-                        for (const possibleType of outputTypeComposer.getTypes()) {
-                            possibleTypes.push(possibleType);
-                        }
-                    }
-                }
-                return possibleTypes;
-            },
-            resolveType,
-            extensions: {
-                statusCodeOneOfIndexMap,
-            },
-        });
-    }
-    return {
-        input,
-        output,
-    };
-}
-
-function getGenericJSONScalar({ isInput, subSchema, schemaComposer, validateWithJSONSchema, }) {
-    function coerceGenericJSONScalar(value) {
-        if (!validateWithJSONSchema(value)) {
-            throw new Error(`${crossHelpers.util.inspect(value)} is not valid!`);
-        }
-        return value;
-    }
-    const name = getValidTypeName({
-        schemaComposer,
-        isInput,
-        subSchema,
-    });
-    return schemaComposer.createScalarTC({
-        name,
-        description: subSchema.description,
-        serialize: coerceGenericJSONScalar,
-        parseValue: coerceGenericJSONScalar,
-        parseLiteral(...args) {
-            const value = graphqlCompose.GraphQLJSON.parseLiteral(...args);
-            return coerceGenericJSONScalar(value);
-        },
-        extensions: {
-            codegenScalarType: 'any',
-            examples: subSchema.examples,
-            default: subSchema.default,
-        },
-    });
-}
-
-const ajvMemoizedCompile = utils$1.memoize2(function ajvCompile(ajv, jsonSchema) {
-    const schema = typeof jsonSchema === 'object'
-        ? {
-            ...jsonSchema,
-            $schema: undefined,
-        }
-        : jsonSchema;
-    try {
-        return ajv.compile(schema);
-    }
-    catch (_a) {
-        // eslint-disable-next-line no-inner-declarations
-        function validateFn(value) {
-            return ajv.validate(schema, value);
-        }
-        Object.defineProperty(validateFn, 'errors', {
-            get() {
-                return ajv.errors;
-            },
-        });
-        return validateFn;
-    }
-});
-function getValidateFnForSchemaPath(ajv, path, schema) {
-    const subSchema = jsonMachete.resolvePath(path, schema);
-    const fn = function validateFn(data) {
-        const ajvValidateFn = ajvMemoizedCompile(ajv, subSchema);
-        return ajvValidateFn(data);
-    };
-    Object.defineProperty(fn, 'errors', {
-        get() {
-            return ajvMemoizedCompile(ajv, subSchema).errors;
-        },
-    });
-    return fn;
-}
-
-/* eslint-disable no-case-declarations */
-const isListTC = utils$1.memoize1(function isListTC(type) {
-    return type instanceof graphqlCompose.ListComposer;
-});
-const GraphQLVoid = new graphql.GraphQLScalarType({
-    name: 'Void',
-    description: 'Represents empty values',
-    serialize: () => '',
-    extensions: {
-        codegenScalarType: 'void',
-    },
-});
-const GraphQLFile = new graphql.GraphQLScalarType({
-    name: 'File',
-    extensions: {
-        codegenScalarType: 'File',
-    },
-});
-function getComposerFromJSONSchema(schema, logger, generateInterfaceFromSharedFields = false) {
-    const schemaComposer = new graphqlCompose.SchemaComposer();
-    const ajv = new Ajv({
-        strict: false,
-    });
-    addFormats(ajv);
-    const formatScalarMap = getJSONSchemaStringFormatScalarMap(ajv);
-    const futureTasks = new Set();
-    return jsonMachete.visitJSONSchema(schema, function mutateFn(subSchema, { path }) {
-        logger === null || logger === void 0 ? void 0 : logger.debug(`Processing ${path} for GraphQL Schema`);
-        const getTypeComposer = () => {
-            var _a, _b, _c, _d, _e;
-            if (typeof subSchema === 'boolean') {
-                const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLJSON);
-                return subSchema
-                    ? {
-                        input: typeComposer,
-                        output: typeComposer,
-                    }
-                    : undefined;
-            }
-            const validateWithJSONSchema = getValidateFnForSchemaPath(ajv, path, schema);
-            if (!subSchema) {
-                throw new Error(`Something is wrong with ${path}`);
-            }
-            if (subSchema.pattern) {
-                const scalarType = new graphqlScalars.RegularExpression(getValidTypeName({
-                    schemaComposer,
-                    isInput: false,
-                    subSchema,
-                }), new RegExp(subSchema.pattern), {
-                    description: subSchema.description,
-                });
-                const typeComposer = schemaComposer.getAnyTC(scalarType);
-                return {
-                    input: typeComposer,
-                    output: typeComposer,
-                };
-            }
-            if (subSchema.const) {
-                const tsTypeName = JSON.stringify(subSchema.const);
-                const scalarTypeName = getValidTypeName({
-                    schemaComposer,
-                    isInput: false,
-                    subSchema,
-                });
-                const scalarType = new graphqlScalars.RegularExpression(scalarTypeName, new RegExp(subSchema.const), {
-                    description: subSchema.description || `A field whose value is ${tsTypeName}`,
-                    errorMessage: (_r, v) => `Expected ${tsTypeName} but got ${JSON.stringify(v)}`,
-                });
-                scalarType.extensions = {
-                    codegenScalarType: tsTypeName,
-                };
-                const typeComposer = schemaComposer.createScalarTC(scalarType);
-                return {
-                    input: typeComposer,
-                    output: typeComposer,
-                };
-            }
-            if (subSchema.enum && subSchema.type !== 'boolean') {
-                const values = {};
-                for (const value of subSchema.enum) {
-                    let enumKey = utils.sanitizeNameForGraphQL(value.toString());
-                    if (enumKey === 'false' || enumKey === 'true' || enumKey === 'null') {
-                        enumKey = enumKey.toUpperCase();
-                    }
-                    if (typeof enumKey === 'string' && enumKey.length === 0) {
-                        enumKey = '_';
-                    }
-                    values[enumKey] = {
-                        // Falsy values are ignored by GraphQL
-                        // eslint-disable-next-line no-unneeded-ternary
-                        value: value ? value : value === null || value === void 0 ? void 0 : value.toString(),
-                    };
-                }
-                const typeComposer = schemaComposer.createEnumTC({
-                    name: getValidTypeName({
-                        schemaComposer,
-                        isInput: false,
-                        subSchema,
-                    }),
-                    values,
-                    description: subSchema.description,
-                    extensions: {
-                        examples: subSchema.examples,
-                        default: subSchema.default,
-                    },
-                });
-                return {
-                    input: typeComposer,
-                    output: typeComposer,
-                };
-            }
-            if (subSchema.oneOf && !subSchema.properties) {
-                let statusCodeOneOfIndexMap;
-                if ((_a = subSchema.$comment) === null || _a === void 0 ? void 0 : _a.startsWith('statusCodeOneOfIndexMap:')) {
-                    const statusCodeOneOfIndexMapStr = subSchema.$comment.replace('statusCodeOneOfIndexMap:', '');
-                    statusCodeOneOfIndexMap = JSON.parse(statusCodeOneOfIndexMapStr);
-                }
-                const isPlural = subSchema.oneOf.some(({ output }) => 'ofType' in output);
-                if (isPlural) {
-                    const { input, output } = getUnionTypeComposers({
-                        schemaComposer,
-                        ajv,
-                        typeComposersList: subSchema.oneOf.map(({ input, output }) => ({
-                            input: input.ofType || input,
-                            output: output.ofType || output,
-                        })),
-                        subSchema,
-                        generateInterfaceFromSharedFields,
-                        statusCodeOneOfIndexMap,
-                    });
-                    return {
-                        input: input.getTypePlural(),
-                        output: output.getTypePlural(),
-                    };
-                }
-                return getUnionTypeComposers({
-                    schemaComposer,
-                    ajv,
-                    typeComposersList: subSchema.oneOf,
-                    subSchema,
-                    generateInterfaceFromSharedFields,
-                    statusCodeOneOfIndexMap,
-                });
-            }
-            if (subSchema.allOf && !subSchema.properties) {
-                const inputFieldMap = {};
-                const fieldMap = {};
-                let ableToUseGraphQLInputObjectType = true;
-                for (const maybeTypeComposers of subSchema.allOf) {
-                    const { input: inputTypeComposer, output: outputTypeComposer } = maybeTypeComposers;
-                    if (inputTypeComposer instanceof graphqlCompose.ScalarTypeComposer) {
-                        ableToUseGraphQLInputObjectType = false;
-                    }
-                    else {
-                        const inputTypeElemFieldMap = inputTypeComposer.getFields();
-                        for (const fieldName in inputTypeElemFieldMap) {
-                            const field = inputTypeElemFieldMap[fieldName];
-                            inputFieldMap[fieldName] = field;
-                        }
-                    }
-                    if (outputTypeComposer instanceof graphqlCompose.ScalarTypeComposer) {
-                        fieldMap[outputTypeComposer.getTypeName()] = {
-                            type: outputTypeComposer,
-                            resolve: root => root,
-                        };
-                    }
-                    else if (outputTypeComposer instanceof graphqlCompose.UnionTypeComposer) {
-                        const outputTCElems = outputTypeComposer.getTypes();
-                        for (const outputTCElem of outputTCElems) {
-                            const outputTypeElemFieldMap = outputTCElem.getFields();
-                            for (const fieldName in outputTypeElemFieldMap) {
-                                const field = outputTypeElemFieldMap[fieldName];
-                                fieldMap[fieldName] = field;
-                            }
-                        }
-                    }
-                    else {
-                        const typeElemFieldMap = outputTypeComposer.getFields();
-                        for (const fieldName in typeElemFieldMap) {
-                            const field = typeElemFieldMap[fieldName];
-                            fieldMap[fieldName] = field;
-                        }
-                    }
-                }
-                let inputTypeComposer;
-                const outputTypeComposer = schemaComposer.createObjectTC({
-                    name: getValidTypeName({
-                        schemaComposer,
-                        isInput: false,
-                        subSchema,
-                    }),
-                    description: subSchema.description,
-                    fields: fieldMap,
-                    extensions: {
-                        validateWithJSONSchema,
-                        examples: subSchema.examples,
-                        default: subSchema.default,
-                    },
-                });
-                if (ableToUseGraphQLInputObjectType) {
-                    inputTypeComposer = schemaComposer.createInputTC({
-                        name: getValidTypeName({
-                            schemaComposer,
-                            isInput: true,
-                            subSchema,
-                        }),
-                        description: subSchema.description,
-                        fields: inputFieldMap,
-                        extensions: {
-                            examples: subSchema.examples,
-                            default: subSchema.default,
-                        },
-                    });
-                }
-                else {
-                    inputTypeComposer = graphqlCompose.isSomeInputTypeComposer(outputTypeComposer)
-                        ? outputTypeComposer
-                        : getGenericJSONScalar({
-                            schemaComposer,
-                            isInput: true,
-                            subSchema,
-                            validateWithJSONSchema,
-                        });
-                }
-                return {
-                    input: inputTypeComposer,
-                    output: outputTypeComposer,
-                };
-            }
-            if (subSchema.anyOf && !subSchema.properties) {
-                if (subSchema.title === 'Any') {
-                    const genericJSONScalar = getGenericJSONScalar({
-                        schemaComposer,
-                        isInput: false,
-                        subSchema,
-                        validateWithJSONSchema,
-                    });
-                    return {
-                        input: genericJSONScalar,
-                        output: genericJSONScalar,
-                    };
-                }
-                // It should not have `required` because it is `anyOf` not `allOf`
-                const inputFieldMap = {};
-                const fieldMap = {};
-                let ableToUseGraphQLInputObjectType = true;
-                for (const typeComposers of subSchema.anyOf) {
-                    const { input: inputTypeComposer, output: outputTypeComposer } = typeComposers;
-                    if (inputTypeComposer instanceof graphqlCompose.ScalarTypeComposer) {
-                        ableToUseGraphQLInputObjectType = false;
-                    }
-                    else {
-                        const inputTypeElemFieldMap = inputTypeComposer.getFields();
-                        for (const fieldName in inputTypeElemFieldMap) {
-                            const field = inputTypeElemFieldMap[fieldName];
-                            inputFieldMap[fieldName] = graphql.isNonNullType(field.type.getType())
-                                ? {
-                                    ...field,
-                                    type: () => field.type.ofType,
-                                }
-                                : field;
-                        }
-                    }
-                    if (outputTypeComposer instanceof graphqlCompose.ScalarTypeComposer) {
-                        const typeName = outputTypeComposer.getTypeName();
-                        fieldMap[typeName] = {
-                            type: outputTypeComposer,
-                            resolve: root => root,
-                        };
-                    }
-                    else {
-                        const typeElemFieldMap = outputTypeComposer.getFields();
-                        for (const fieldName in typeElemFieldMap) {
-                            const field = typeElemFieldMap[fieldName];
-                            fieldMap[fieldName] = {
-                                type: () => graphql.getNamedType(field.type.getType()),
-                                ...field,
-                            };
-                        }
-                    }
-                }
-                let inputTypeComposer;
-                const outputTypeComposer = schemaComposer.createObjectTC({
-                    name: getValidTypeName({
-                        schemaComposer,
-                        isInput: false,
-                        subSchema,
-                    }),
-                    description: subSchema.description,
-                    fields: fieldMap,
-                    extensions: {
-                        validateWithJSONSchema,
-                        examples: subSchema.examples,
-                        default: subSchema.default,
-                    },
-                });
-                if (ableToUseGraphQLInputObjectType) {
-                    inputTypeComposer = schemaComposer.createInputTC({
-                        name: getValidTypeName({
-                            schemaComposer,
-                            isInput: true,
-                            subSchema,
-                        }),
-                        description: subSchema.description,
-                        fields: inputFieldMap,
-                        extensions: {
-                            examples: subSchema.examples,
-                            default: subSchema.default,
-                        },
-                    });
-                }
-                else {
-                    inputTypeComposer = graphqlCompose.isSomeInputTypeComposer(outputTypeComposer)
-                        ? outputTypeComposer
-                        : getGenericJSONScalar({
-                            schemaComposer,
-                            isInput: true,
-                            subSchema,
-                            validateWithJSONSchema,
-                        });
-                }
-                return {
-                    input: inputTypeComposer,
-                    output: outputTypeComposer,
-                };
-            }
-            if (Array.isArray(subSchema.type)) {
-                const validTypes = subSchema.type.filter((typeName) => typeName !== 'null');
-                if (validTypes.length === 1) {
-                    subSchema.type = validTypes[0];
-                    // continue with the single type
-                }
-                else {
-                    const typeComposer = schemaComposer.getAnyTC(GraphQLVoid);
-                    return {
-                        input: typeComposer,
-                        output: typeComposer,
-                    };
-                }
-            }
-            switch (subSchema.type) {
-                case 'file': {
-                    const typeComposer = schemaComposer.getAnyTC(GraphQLFile);
-                    return {
-                        input: typeComposer,
-                        output: typeComposer,
-                        description: subSchema.description,
-                    };
-                }
-                case 'boolean': {
-                    const typeComposer = schemaComposer.getAnyTC(graphql.GraphQLBoolean);
-                    return {
-                        input: typeComposer,
-                        output: typeComposer,
-                        description: subSchema.description,
-                    };
-                }
-                case 'null': {
-                    const typeComposer = schemaComposer.getAnyTC(GraphQLVoid);
-                    return {
-                        input: typeComposer,
-                        output: typeComposer,
-                        description: subSchema.description,
-                    };
-                }
-                case 'integer': {
-                    if (subSchema.format === 'int64') {
-                        const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLBigInt);
-                        return {
-                            input: typeComposer,
-                            output: typeComposer,
-                            description: subSchema.description,
-                        };
-                    }
-                    const typeComposer = schemaComposer.getAnyTC(graphql.GraphQLInt);
-                    return {
-                        input: typeComposer,
-                        output: typeComposer,
-                        description: subSchema.description,
-                    };
-                }
-                case 'number': {
-                    const typeComposer = schemaComposer.getAnyTC(graphql.GraphQLFloat);
-                    return {
-                        input: typeComposer,
-                        output: typeComposer,
-                        description: subSchema.description,
-                    };
-                }
-                case 'string': {
-                    if (subSchema.minLength || subSchema.maxLength) {
-                        const scalarType = getStringScalarWithMinMaxLength({
-                            schemaComposer,
-                            subSchema,
-                        });
-                        const typeComposer = schemaComposer.getAnyTC(scalarType);
-                        return {
-                            input: typeComposer,
-                            output: typeComposer,
-                            description: subSchema.description,
-                        };
-                    }
-                    switch (subSchema.format) {
-                        case 'date-time': {
-                            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLDateTime);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                        case 'time': {
-                            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLTime);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                        case 'email': {
-                            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLEmailAddress);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                        case 'ipv4': {
-                            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLIPv4);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                        case 'ipv6': {
-                            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLIPv6);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                        case 'uri': {
-                            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLURL);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                        default: {
-                            const formatScalar = formatScalarMap.get(subSchema.format) || graphql.GraphQLString;
-                            const typeComposer = schemaComposer.getAnyTC(formatScalar);
-                            return {
-                                input: typeComposer,
-                                output: typeComposer,
-                                description: subSchema.description,
-                            };
-                        }
-                    }
-                }
-                case 'array':
-                    if (typeof subSchema.items === 'object' &&
-                        !Array.isArray(subSchema.items) &&
-                        Object.keys(subSchema.items).length > 0) {
-                        const typeComposers = subSchema.items;
-                        return {
-                            input: typeComposers.input.getTypePlural(),
-                            output: typeComposers.output.getTypePlural(),
-                            description: subSchema.description,
-                        };
-                    }
-                    if (subSchema.contains) {
-                        // Scalars cannot be in union type
-                        const typeComposer = getGenericJSONScalar({
-                            schemaComposer,
-                            isInput: false,
-                            subSchema,
-                            validateWithJSONSchema,
-                        }).getTypePlural();
-                        return {
-                            input: typeComposer,
-                            output: typeComposer,
-                        };
-                    }
-                    if (typeof subSchema.items === 'object' && Array.isArray(subSchema.items)) {
-                        const existingItems = [...subSchema.items];
-                        /* TODO
-                        if (subSchema.additionalItems) {
-                          existingItems.push(subSchema.additionalItems);
-                        }
-                        */
-                        const { input: inputTypeComposer, output: outputTypeComposer } = getUnionTypeComposers({
-                            schemaComposer,
-                            ajv,
-                            typeComposersList: existingItems,
-                            subSchema,
-                            generateInterfaceFromSharedFields,
-                        });
-                        return {
-                            input: inputTypeComposer.getTypePlural(),
-                            output: outputTypeComposer.getTypePlural(),
-                            description: subSchema.description,
-                        };
-                    }
-                    // If it doesn't have any clue
-                    {
-                        // const typeComposer = getGenericJSONScalar({
-                        //   schemaComposer,
-                        //   isInput: false,
-                        //   subSchema,
-                        //   validateWithJSONSchema,
-                        // }).getTypePlural();
-                        const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLJSON).getTypePlural();
-                        return {
-                            input: typeComposer,
-                            output: typeComposer,
-                            description: subSchema.description,
-                        };
-                    }
-                case 'object':
-                    const fieldMap = {};
-                    let inputFieldMap = {};
-                    if (subSchema.properties) {
-                        subSchema.type = 'object';
-                        for (const propertyName in subSchema.properties) {
-                            // TODO: needs to be fixed
-                            if (propertyName === 'additionalProperties') {
-                                continue;
-                            }
-                            const typeComposers = subSchema.properties[propertyName];
-                            const fieldName = utils.sanitizeNameForGraphQL(propertyName);
-                            fieldMap[fieldName] = {
-                                type: () => {
-                                    var _a;
-                                    return ((_a = subSchema.required) === null || _a === void 0 ? void 0 : _a.includes(propertyName))
-                                        ? typeComposers.output.getTypeNonNull()
-                                        : typeComposers.output;
-                                },
-                                // Make sure you get the right property
-                                resolve: root => {
-                                    const actualFieldObj = root[propertyName];
-                                    if (actualFieldObj != null) {
-                                        const isArray = Array.isArray(actualFieldObj);
-                                        const isListType = isListTC(typeComposers.output);
-                                        if (isListType && !isArray) {
-                                            return [actualFieldObj];
-                                        }
-                                        else if (!isListTC(typeComposers.output) && isArray) {
-                                            return actualFieldObj[0];
-                                        }
-                                    }
-                                    return actualFieldObj;
-                                },
-                                description: typeComposers.description || ((_b = typeComposers.output) === null || _b === void 0 ? void 0 : _b.description),
-                            };
-                            inputFieldMap[fieldName] = {
-                                type: () => {
-                                    var _a, _b;
-                                    return ((_a = subSchema.required) === null || _a === void 0 ? void 0 : _a.includes(propertyName))
-                                        ? (_b = typeComposers.input) === null || _b === void 0 ? void 0 : _b.getTypeNonNull()
-                                        : typeComposers.input;
-                                },
-                                // Let execution logic know what is the expected propertyName
-                                extensions: {
-                                    propertyName,
-                                },
-                                description: typeComposers.description || ((_c = typeComposers.input) === null || _c === void 0 ? void 0 : _c.description),
-                                defaultValue: ((_d = typeComposers === null || typeComposers === void 0 ? void 0 : typeComposers.extensions) === null || _d === void 0 ? void 0 : _d.default) || ((_e = typeComposers.input) === null || _e === void 0 ? void 0 : _e.default),
-                            };
-                        }
-                    }
-                    if (subSchema.allOf) {
-                        for (const typeComposers of subSchema.allOf) {
-                            const outputTC = typeComposers.output;
-                            if (schemaComposer.isObjectType(outputTC)) {
-                                for (const outputFieldName of outputTC.getFieldNames()) {
-                                    if (!fieldMap[outputFieldName]) {
-                                        fieldMap[outputFieldName] = outputTC.getField(outputFieldName);
-                                    }
-                                }
-                            }
-                            const inputTC = typeComposers.input;
-                            if (schemaComposer.isInputObjectType(inputTC)) {
-                                for (const inputFieldName of inputTC.getFieldNames()) {
-                                    if (!inputFieldMap[inputFieldName]) {
-                                        inputFieldMap[inputFieldName] = inputTC.getField(inputFieldName);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (subSchema.additionalProperties) {
-                        if (typeof subSchema.additionalProperties === 'object' &&
-                            subSchema.additionalProperties.output instanceof graphqlCompose.ObjectTypeComposer) {
-                            if (Object.keys(fieldMap).length === 0) {
-                                return subSchema.additionalProperties;
-                            }
-                            else {
-                                const outputTC = subSchema.additionalProperties.output;
-                                const outputTCFieldMap = outputTC.getFields();
-                                for (const fieldName in outputTCFieldMap) {
-                                    fieldMap[fieldName] = outputTCFieldMap[fieldName];
-                                }
-                                const inputTC = subSchema.additionalProperties.input;
-                                const inputTCFieldMap = inputTC.getFields();
-                                for (const fieldName in inputTCFieldMap) {
-                                    inputFieldMap[fieldName] = inputTCFieldMap[fieldName];
-                                }
-                            }
-                        }
-                        else {
-                            fieldMap.additionalProperties = {
-                                type: graphqlScalars.GraphQLJSON,
-                                resolve: (root) => root,
-                            };
-                            inputFieldMap = {};
-                        }
-                    }
-                    if (subSchema.title === '_schema') {
-                        futureTasks.forEach(futureTask => futureTask());
-                        return {
-                            output: schemaComposer,
-                        };
-                    }
-                    if (subSchema.title === 'Query') {
-                        const typeComposer = schemaComposer.Query;
-                        typeComposer.addFields(fieldMap);
-                        return {
-                            output: typeComposer,
-                        };
-                    }
-                    if (subSchema.title === 'Mutation') {
-                        const typeComposer = schemaComposer.Mutation;
-                        typeComposer.addFields(fieldMap);
-                        return {
-                            output: typeComposer,
-                        };
-                    }
-                    if (subSchema.title === 'Subscription') {
-                        const typeComposer = schemaComposer.Subscription;
-                        typeComposer.addFields(fieldMap);
-                        return {
-                            output: typeComposer,
-                        };
-                    }
-                    const getCorrectInputFieldType = (fieldName) => {
-                        const inputType = inputFieldMap[fieldName].type();
-                        const actualInputType = isListTC(inputType) ? inputType.ofType : inputType;
-                        if (!actualInputType.getFields) {
-                            return actualInputType;
-                        }
-                        const fieldMap = actualInputType.getFields();
-                        for (const fieldName in fieldMap) {
-                            const fieldConfig = fieldMap[fieldName];
-                            if (fieldConfig.type.getTypeName().endsWith('!')) {
-                                return inputType.getTypeNonNull();
-                            }
-                        }
-                        return inputType;
-                    };
-                    if (subSchema.title === 'QueryInput') {
-                        const typeComposer = schemaComposer.Query;
-                        for (const fieldName in inputFieldMap) {
-                            futureTasks.add(() => typeComposer.addFieldArgs(fieldName, {
-                                input: {
-                                    type: () => getCorrectInputFieldType(fieldName),
-                                    description: inputFieldMap[fieldName].description,
-                                },
-                            }));
-                        }
-                        return {
-                            output: typeComposer,
-                        };
-                    }
-                    if (subSchema.title === 'MutationInput') {
-                        const typeComposer = schemaComposer.Mutation;
-                        for (const fieldName in inputFieldMap) {
-                            futureTasks.add(() => typeComposer.addFieldArgs(fieldName, {
-                                input: {
-                                    type: () => getCorrectInputFieldType(fieldName),
-                                    description: inputFieldMap[fieldName].description,
-                                },
-                            }));
-                        }
-                        return {
-                            output: typeComposer,
-                        };
-                    }
-                    if (subSchema.title === 'SubscriptionInput') {
-                        const typeComposer = schemaComposer.Subscription;
-                        for (const fieldName in inputFieldMap) {
-                            futureTasks.add(() => typeComposer.addFieldArgs(fieldName, {
-                                input: {
-                                    type: () => getCorrectInputFieldType(fieldName),
-                                    description: inputFieldMap[fieldName].description,
-                                },
-                            }));
-                        }
-                        return {
-                            output: typeComposer,
-                        };
-                    }
-                    const output = Object.keys(fieldMap).length === 0
-                        ? getGenericJSONScalar({
-                            schemaComposer,
-                            isInput: false,
-                            subSchema,
-                            validateWithJSONSchema,
-                        })
-                        : schemaComposer.createObjectTC({
-                            name: getValidTypeName({
-                                schemaComposer,
-                                isInput: false,
-                                subSchema,
-                            }),
-                            description: subSchema.description,
-                            fields: fieldMap,
-                            extensions: {
-                                validateWithJSONSchema,
-                                examples: subSchema.examples,
-                                default: subSchema.default,
-                            },
-                        });
-                    const input = Object.keys(inputFieldMap).length === 0
-                        ? getGenericJSONScalar({
-                            schemaComposer,
-                            isInput: true,
-                            subSchema,
-                            validateWithJSONSchema,
-                        })
-                        : schemaComposer.createInputTC({
-                            name: getValidTypeName({
-                                schemaComposer,
-                                isInput: true,
-                                subSchema,
-                            }),
-                            description: subSchema.description,
-                            fields: inputFieldMap,
-                            extensions: {
-                                examples: subSchema.examples,
-                                default: subSchema.default,
-                            },
-                        });
-                    return {
-                        input,
-                        output,
-                    };
-            }
-            logger.warn(`GraphQL Type cannot be created for this JSON Schema definition;`, {
-                subSchema,
-                path,
-            });
-            const typeComposer = schemaComposer.getAnyTC(graphqlScalars.GraphQLJSON);
-            return {
-                input: typeComposer,
-                output: typeComposer,
-            };
-        };
-        const result = getTypeComposer();
-        return result;
-    });
-}
-
-async function getGraphQLSchemaFromDereferencedJSONSchema(fullyDeferencedSchema, { fetch, logger, operations, operationHeaders, baseUrl, pubsub, generateInterfaceFromSharedFields, queryParams, queryStringOptions, }) {
-    logger.debug(`Generating GraphQL Schema from the bundled JSON Schema`);
-    const visitorResult = await getComposerFromJSONSchema(fullyDeferencedSchema, logger, generateInterfaceFromSharedFields);
-    const schemaComposerWithoutExecutionLogic = visitorResult.output;
-    if (!(schemaComposerWithoutExecutionLogic instanceof graphqlCompose.SchemaComposer)) {
-        throw new Error('The visitor result should be a SchemaComposer instance.');
-    }
-    // graphql-compose doesn't add @defer and @stream to the schema
-    for (const directive of graphql.specifiedDirectives) {
-        schemaComposerWithoutExecutionLogic.addDirective(directive);
-    }
-    const schemaComposerWithExecutionLogic = await addExecutionLogicToComposer(schemaComposerWithoutExecutionLogic, {
-        fetch,
-        logger,
-        operations,
-        operationHeaders,
-        baseUrl,
-        pubsub,
-        queryParams,
-        queryStringOptions,
-    });
-    if (schemaComposerWithExecutionLogic.Query.getFieldNames().length === 0) {
-        schemaComposerWithExecutionLogic.Query.addFields({
-            dummy: {
-                type: 'String',
-                resolve: () => 'dummy',
-            },
-        });
-    }
-    return schemaComposerWithExecutionLogic.buildSchema();
-}
-
-async function loadGraphQLSchemaFromJSONSchemas(name, options) {
-    const logger = options.logger || new utils.DefaultLogger(name);
-    const operations = options.operations;
-    const cwd = options.cwd || process.cwd();
-    const fullyDeferencedSchema = await getDereferencedJSONSchemaFromOperations({
-        operations,
-        cwd,
-        logger,
-        fetchFn: options.fetch,
-        schemaHeaders: options.schemaHeaders,
-        ignoreErrorResponses: options.ignoreErrorResponses,
-        noDeduplication: options.noDeduplication,
-    });
-    const graphqlSchema = await getGraphQLSchemaFromDereferencedJSONSchema(fullyDeferencedSchema, {
-        fetch: options.fetch,
-        logger,
-        operations,
-        operationHeaders: options.operationHeaders,
-        baseUrl: options.baseUrl,
-        pubsub: options.pubsub,
-        generateInterfaceFromSharedFields: options.generateInterfaceFromSharedFields,
-        queryParams: options.queryParams,
-        queryStringOptions: options.queryStringOptions,
-    });
-    return graphqlSchema;
-}
-
-async function createBundle(name, { baseUrl, operations, schemaHeaders, operationHeaders, cwd = process.cwd(), fetch: fetch$1 = fetch.fetch, logger = new utils.DefaultLogger(name), ignoreErrorResponses = false, noDeduplication = false, }) {
-    logger.debug(`Creating the dereferenced schema from operations config`);
-    const dereferencedSchema = await getDereferencedJSONSchemaFromOperations({
-        operations,
-        cwd,
-        logger,
-        fetchFn: fetch$1,
-        schemaHeaders,
-        ignoreErrorResponses,
-        noDeduplication,
-    });
-    logger.debug(`Creating references from dereferenced schema`);
-    const referencedSchema = await jsonMachete.referenceJSONSchema(dereferencedSchema);
-    logger.debug(`Bundle generation finished`);
-    return {
-        name,
-        baseUrl,
-        operations,
-        operationHeaders,
-        referencedSchema,
-    };
-}
-/**
- * Generates a local GraphQLSchema instance from
- * previously generated JSON Schema bundle
- */
-async function getGraphQLSchemaFromBundle({ name, baseUrl: bundledBaseUrl, operations, operationHeaders: bundledOperationHeaders = {}, referencedSchema, }, { cwd = process.cwd(), fetch: fetch$1 = fetch.fetch, pubsub, logger = new utils.DefaultLogger(name), baseUrl: overwrittenBaseUrl, operationHeaders: additionalOperationHeaders = {}, queryParams, queryStringOptions, } = {}) {
-    logger.info(`Dereferencing the bundle`);
-    const fullyDeferencedSchema = await jsonMachete.dereferenceObject(referencedSchema, {
-        cwd,
-        fetchFn: fetch$1,
-        logger,
-    });
-    const operationHeaders = { ...bundledOperationHeaders, ...additionalOperationHeaders };
-    logger.info(`Creating the GraphQL Schema from dereferenced schema`);
-    return getGraphQLSchemaFromDereferencedJSONSchema(fullyDeferencedSchema, {
-        fetch: fetch$1,
-        pubsub,
-        logger,
-        baseUrl: overwrittenBaseUrl || bundledBaseUrl,
-        operations,
-        operationHeaders,
-        queryParams,
-        queryStringOptions,
-    });
-}
-
-exports.anySchema = anySchema;
-exports.createBundle = createBundle;
-exports.default = loadGraphQLSchemaFromJSONSchemas;
-exports.getComposerFromJSONSchema = getComposerFromJSONSchema;
-exports.getDereferencedJSONSchemaFromOperations = getDereferencedJSONSchemaFromOperations;
-exports.getGraphQLSchemaFromBundle = getGraphQLSchemaFromBundle;
-exports.getGraphQLSchemaFromDereferencedJSONSchema = getGraphQLSchemaFromDereferencedJSONSchema;
-exports.getReferencedJSONSchemaFromOperations = getReferencedJSONSchemaFromOperations;
-exports.loadGraphQLSchemaFromJSONSchemas = loadGraphQLSchemaFromJSONSchemas;