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

package/cjs/getDereferencedJSONSchemaFromOperations.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDereferencedJSONSchemaFromOperations = void 0;
+const json_machete_1 = require("json-machete");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const getReferencedJSONSchemaFromOperations_js_1 = require("./getReferencedJSONSchemaFromOperations.js");
+async function getDereferencedJSONSchemaFromOperations({ operations, cwd = cross_helpers_1.process.cwd(), logger, fetchFn, schemaHeaders, ignoreErrorResponses, endpoint, operationHeaders, queryParams, }) {
+    const referencedJSONSchema = await (0, getReferencedJSONSchemaFromOperations_js_1.getReferencedJSONSchemaFromOperations)({
+        operations,
+        cwd,
+        schemaHeaders,
+        ignoreErrorResponses,
+        fetchFn,
+        endpoint,
+        operationHeaders,
+        queryParams,
+    });
+    logger.debug(`Dereferencing JSON Schema to resolve all $refs`);
+    const schemaHeadersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(schemaHeaders);
+    const fullyDeferencedSchema = await (0, json_machete_1.dereferenceObject)(referencedJSONSchema, {
+        cwd,
+        fetchFn,
+        logger: logger.child('dereferenceObject'),
+        headers: schemaHeadersFactory({ env: cross_helpers_1.process.env }),
+    });
+    logger.debug(`Healing JSON Schema`);
+    const healedSchema = await (0, json_machete_1.healJSONSchema)(fullyDeferencedSchema, {
+        logger: logger.child('healJSONSchema'),
+    });
+    return healedSchema;
+}
+exports.getDereferencedJSONSchemaFromOperations = getDereferencedJSONSchemaFromOperations;

package/cjs/getGraphQLSchemaFromDereferencedJSONSchema.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphQLSchemaFromDereferencedJSONSchema = void 0;
+const graphql_1 = require("graphql");
+const graphql_compose_1 = require("graphql-compose");
+const addExecutionLogicToComposer_js_1 = require("./addExecutionLogicToComposer.js");
+const getComposerFromJSONSchema_js_1 = require("./getComposerFromJSONSchema.js");
+async function getGraphQLSchemaFromDereferencedJSONSchema(name, opts) {
+    const { fullyDeferencedSchema, logger, operations, operationHeaders, endpoint, queryParams, queryStringOptions, } = opts;
+    logger.debug(`Generating GraphQL Schema from the bundled JSON Schema`);
+    const visitorResult = await (0, getComposerFromJSONSchema_js_1.getComposerFromJSONSchema)(fullyDeferencedSchema, logger.child('getComposerFromJSONSchema'));
+    const schemaComposerWithoutExecutionLogic = visitorResult.output;
+    if (!(schemaComposerWithoutExecutionLogic instanceof graphql_compose_1.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_1.specifiedDirectives) {
+        schemaComposerWithoutExecutionLogic.addDirective(directive);
+    }
+    const schemaComposerWithExecutionLogic = await (0, addExecutionLogicToComposer_js_1.addExecutionDirectivesToComposer)(name, {
+        schemaComposer: schemaComposerWithoutExecutionLogic,
+        logger,
+        operations,
+        operationHeaders,
+        endpoint,
+        queryParams,
+        queryStringOptions,
+    });
+    if (schemaComposerWithExecutionLogic.Query.getFieldNames().length === 0) {
+        schemaComposerWithExecutionLogic.Query.addFields({
+            dummy: {
+                type: 'String',
+                resolve: () => 'dummy',
+            },
+        });
+    }
+    return schemaComposerWithExecutionLogic.buildSchema();
+}
+exports.getGraphQLSchemaFromDereferencedJSONSchema = getGraphQLSchemaFromDereferencedJSONSchema;

package/cjs/getJSONSchemaStringFormatScalarMap.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSONSchemaStringFormatScalarMap = void 0;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+const graphql_1 = require("graphql");
+const pascal_case_1 = require("pascal-case");
+const JSONSchemaStringFormats = [
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+];
+function getJSONSchemaStringFormatScalarMap() {
+    const ajv = new ajv_1.default({
+        strict: false,
+    });
+    (0, ajv_formats_1.default)(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_1.GraphQLScalarType({
+            name: (0, pascal_case_1.pascalCase)(format),
+            description: `Represents ${format} values`,
+            serialize: coerceString,
+            parseValue: coerceString,
+            parseLiteral: ast => {
+                if (ast.kind === graphql_1.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;
+}
+exports.getJSONSchemaStringFormatScalarMap = getJSONSchemaStringFormatScalarMap;

package/cjs/getReferencedJSONSchemaFromOperations.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferencedJSONSchemaFromOperations = void 0;
+const tslib_1 = require("tslib");
+const json_machete_1 = require("json-machete");
+const to_json_schema_1 = tslib_1.__importDefault(require("to-json-schema"));
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_js_1 = require("./utils.js");
+async function handleOperationResponseConfig(operationResponseConfig, { schemaHeaders, cwd, fetchFn, logger = new utils_1.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 (0, utils_1.readFileOrUrl)(operationResponseConfig.responseSample, {
+                cwd,
+                fetch: fetchFn,
+                logger,
+                importFn: utils_1.defaultImportFn,
+                headers: schemaHeaders,
+            }).catch((e) => {
+                throw new Error(`responseSample - ${e.message}`);
+            });
+        const generatedSchema = (0, to_json_schema_1.default)(sample, {
+            required: false,
+            objects: {
+                additionalProperties: false,
+            },
+            strings: {
+                detectFormat: true,
+            },
+            arrays: {
+                mode: 'first',
+            },
+        });
+        generatedSchema.title = operationResponseConfig.responseTypeName;
+        generatedSchema.examples = [sample];
+        return generatedSchema;
+    }
+    else {
+        return json_machete_1.AnySchema;
+    }
+}
+async function getReferencedJSONSchemaFromOperations({ operations, cwd, schemaHeaders, ignoreErrorResponses, logger = new utils_1.DefaultLogger('getReferencedJSONSchemaFromOperations'), fetchFn, endpoint, operationHeaders, queryParams, }) {
+    const finalJsonSchema = {
+        type: 'object',
+        title: '_schema',
+        properties: {},
+        required: ['query'],
+    };
+    for (const operationConfig of operations) {
+        const { operationType, rootTypeName, fieldName } = (0, utils_js_1.getOperationMetadata)(operationConfig);
+        const rootTypeDefinition = (finalJsonSchema.properties[operationType] = finalJsonSchema
+            .properties[operationType] || {
+            type: 'object',
+            title: rootTypeName,
+            properties: {},
+            readOnly: true,
+        });
+        rootTypeDefinition.properties = rootTypeDefinition.properties || {};
+        const interpolationStrings = [
+            ...Object.values(operationHeaders || {}),
+            ...Object.values(queryParams || {}).map(val => val.toString()),
+            endpoint,
+        ];
+        if ('pubsubTopic' in operationConfig) {
+            interpolationStrings.push(operationConfig.pubsubTopic);
+        }
+        if ('headers' in operationConfig) {
+            interpolationStrings.push(...Object.values(operationConfig.headers || {}));
+        }
+        if ('path' in operationConfig) {
+            interpolationStrings.push(operationConfig.path);
+        }
+        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] = json_machete_1.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: {},
+                writeOnly: true,
+            });
+        if ('queryParamsSample' in operationConfig &&
+            operationConfig.queryParamsSample &&
+            typeof operationConfig.queryParamsSample === 'object') {
+            for (const queryParamName in operationConfig.queryParamsSample) {
+                const example = operationConfig.queryParamsSample[queryParamName];
+                const generatedSchema = (0, to_json_schema_1.default)(example, {
+                    required: false,
+                    objects: {
+                        additionalProperties: false,
+                    },
+                    strings: {
+                        detectFormat: true,
+                    },
+                    arrays: {
+                        mode: 'first',
+                    },
+                });
+                generatedSchema.examples = [example];
+                const argName = (0, utils_1.sanitizeNameForGraphQL)(queryParamName);
+                operationConfig.queryParamArgMap = operationConfig.queryParamArgMap || {};
+                operationConfig.queryParamArgMap[queryParamName] = argName;
+                operationConfig.argTypeMap = operationConfig.argTypeMap || {};
+                operationConfig.argTypeMap[argName] = generatedSchema;
+            }
+        }
+        const interpolationKeys = (0, string_interpolation_1.getInterpolationKeys)(...interpolationStrings);
+        if ('queryParamArgMap' in operationConfig) {
+            interpolationKeys.push(...Object.values(operationConfig.queryParamArgMap).map(key => `args.${key}`));
+        }
+        for (const interpolationKey of interpolationKeys) {
+            const [initialObjectName, varName] = interpolationKey.split('.');
+            if (initialObjectName === 'args') {
+                rootTypeInputTypeDefinition.properties[fieldName] = rootTypeInputTypeDefinition.properties[fieldName] || {
+                    title: `${rootTypeInputPropertyName}_${fieldName}`,
+                    type: 'object',
+                    properties: {},
+                };
+                if (operationConfig.argTypeMap != null && varName in operationConfig.argTypeMap) {
+                    const argTypeDef = operationConfig.argTypeMap[varName];
+                    if (typeof argTypeDef === 'object') {
+                        rootTypeInputTypeDefinition.properties[fieldName].properties[varName] = argTypeDef;
+                    }
+                    else {
+                        rootTypeInputTypeDefinition.properties[fieldName].properties[varName] = {
+                            $ref: argTypeDef,
+                        };
+                    }
+                }
+                else if (!rootTypeInputTypeDefinition.properties[fieldName].properties[varName]) {
+                    rootTypeInputTypeDefinition.properties[fieldName].properties[varName] = {
+                        type: 'string',
+                    };
+                }
+            }
+        }
+        if ('binary' in operationConfig) {
+            const generatedSchema = {
+                type: 'string',
+                format: 'binary',
+            };
+            rootTypeInputTypeDefinition.properties[fieldName] = rootTypeInputTypeDefinition.properties[fieldName] || {
+                title: `${rootTypeInputPropertyName}_${fieldName}`,
+                type: 'object',
+                properties: {},
+            };
+            rootTypeInputTypeDefinition.properties[fieldName].properties.input = generatedSchema;
+        }
+        else if ('requestSchema' in operationConfig && operationConfig.requestSchema) {
+            rootTypeInputTypeDefinition.properties[fieldName] = rootTypeInputTypeDefinition.properties[fieldName] || {
+                title: `${rootTypeInputPropertyName}_${fieldName}`,
+                type: 'object',
+                properties: {},
+            };
+            rootTypeInputTypeDefinition.properties[fieldName].properties.input =
+                typeof operationConfig.requestSchema === 'string'
+                    ? {
+                        $ref: operationConfig.requestSchema,
+                        title: operationConfig.requestTypeName,
+                    }
+                    : operationConfig.requestSchema;
+            if (operationConfig.requestSample) {
+                rootTypeInputTypeDefinition.properties[fieldName].properties.input.examples =
+                    rootTypeInputTypeDefinition.properties[fieldName].properties.input.examples || [
+                        operationConfig.requestSample,
+                    ];
+            }
+        }
+        else if ('requestSample' in operationConfig) {
+            const sample = typeof operationConfig.requestSample === 'object'
+                ? operationConfig.requestSample
+                : await (0, utils_1.readFileOrUrl)(operationConfig.requestSample, {
+                    cwd,
+                    headers: schemaHeaders,
+                    fetch: fetchFn,
+                    logger,
+                    importFn: utils_1.defaultImportFn,
+                }).catch((e) => {
+                    throw new Error(`${operationConfig.field}.requestSample: ${operationConfig.requestSample}; ${e.message}`);
+                });
+            const generatedSchema = (0, to_json_schema_1.default)(sample, {
+                required: false,
+                objects: {
+                    additionalProperties: false,
+                },
+                strings: {
+                    detectFormat: true,
+                },
+                arrays: {
+                    mode: 'first',
+                },
+            });
+            generatedSchema.title = operationConfig.requestTypeName;
+            generatedSchema.examples = [sample];
+            rootTypeInputTypeDefinition.properties[fieldName] = rootTypeInputTypeDefinition.properties[fieldName] || {
+                title: `${rootTypeInputPropertyName}_${fieldName}`,
+                type: 'object',
+                properties: {},
+            };
+            rootTypeInputTypeDefinition.properties[fieldName].properties.input = generatedSchema;
+        }
+    }
+    return finalJsonSchema;
+}
+exports.getReferencedJSONSchemaFromOperations = getReferencedJSONSchemaFromOperations;

package/cjs/getTypeResolverFromOutputTCs.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeResolverFromOutputTCs = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function getTypeResolverFromOutputTCs({ possibleTypes, discriminatorField, discriminatorMapping, statusCodeTypeNameMap, }) {
+    return function resolveType(data) {
+        if (data.__typename) {
+            return data.__typename;
+        }
+        else if (discriminatorField != null && data[discriminatorField]) {
+            const discriminatorValue = data[discriminatorField];
+            return (discriminatorMapping === null || discriminatorMapping === void 0 ? void 0 : discriminatorMapping[discriminatorValue]) || discriminatorValue;
+        }
+        if (data.$statusCode && statusCodeTypeNameMap) {
+            const typeName = statusCodeTypeNameMap[data.$statusCode.toString()] || statusCodeTypeNameMap.default;
+            if (typeName) {
+                return typeName;
+            }
+        }
+        // const validationErrors: Record<string, ErrorObject[]> = {};
+        const dataKeys = typeof data === 'object'
+            ? Object.keys(data)
+                // Remove metadata fields used to pass data
+                .filter(property => !property.toString().startsWith('$'))
+            : null;
+        for (const possibleType of possibleTypes) {
+            const typeName = possibleType.name;
+            if (dataKeys != null) {
+                const typeFields = Object.keys(possibleType.getFields());
+                if (dataKeys.length <= typeFields.length &&
+                    dataKeys.every(property => typeFields.includes(property.toString()))) {
+                    return typeName;
+                }
+            } /* else {
+              const validateFn = possibleType.extensions.validateWithJSONSchema as ValidateFunction;
+              if (validateFn) {
+                const isValid = validateFn(data);
+                if (isValid) {
+                  return typeName;
+                }
+                validationErrors[typeName] = ajv.errors || validateFn.errors;
+              }
+            } */
+        }
+        if (data.$response) {
+            const error = (0, utils_1.createGraphQLError)(`HTTP Error: ${data.$statusCode}`, {
+                extensions: {
+                    http: {
+                        status: data.$statusCode,
+                        headers: data.$response.header,
+                    },
+                    request: {
+                        url: data.$url,
+                        method: data.$method,
+                    },
+                    responseJson: data.$response,
+                },
+            });
+            return error;
+        }
+        /*
+        const error = new GraphQLError(`Received data doesn't met the union`, null, null, null, null, null, {
+          validationErrors,
+        });
+        return error;
+        */
+    };
+}
+exports.getTypeResolverFromOutputTCs = getTypeResolverFromOutputTCs;

package/cjs/getUnionTypeComposers.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnionTypeComposers = exports.getContainerTC = void 0;
+const graphql_compose_1 = require("graphql-compose");
+const directives_js_1 = require("./directives.js");
+function getContainerTC(schemaComposer, output) {
+    const containerTypeName = `${output.getTypeName()}_container`;
+    return schemaComposer.getOrCreateOTC(containerTypeName, otc => otc.addFields({
+        [output.getTypeName()]: {
+            type: output,
+            resolve: root => root,
+        },
+    }));
+}
+exports.getContainerTC = getContainerTC;
+function getUnionTypeComposers({ schemaComposer, typeComposersList, subSchemaAndTypeComposers, logger, }) {
+    var _a;
+    if (new Set(typeComposersList).size === 1) {
+        return typeComposersList[0];
+    }
+    const unionInputFields = {};
+    const outputTypeComposers = [];
+    typeComposersList.forEach(typeComposers => {
+        const { input, output } = typeComposers;
+        if ((0, graphql_compose_1.isSomeInputTypeComposer)(output)) {
+            outputTypeComposers.push(getContainerTC(schemaComposer, output));
+        }
+        else {
+            outputTypeComposers.push(output);
+        }
+        if (input) {
+            unionInputFields[input.getTypeName()] = {
+                type: input,
+            };
+        }
+        if (!input) {
+            logger.debug(`No input type composer found for ${output.getTypeName()}, skipping...`);
+        }
+    });
+    if (Object.keys(unionInputFields).length === 1) {
+        subSchemaAndTypeComposers.input = Object.values(unionInputFields)[0].type;
+    }
+    else {
+        subSchemaAndTypeComposers.input.addFields(unionInputFields);
+    }
+    if (new Set(outputTypeComposers).size === 1) {
+        subSchemaAndTypeComposers.output = outputTypeComposers[0];
+    }
+    else {
+        const directives = subSchemaAndTypeComposers.output.getDirectives() || [];
+        const statusCodeOneOfIndexMap = subSchemaAndTypeComposers.output.getExtension('statusCodeOneOfIndexMap');
+        const statusCodeOneOfIndexMapEntries = Object.entries(statusCodeOneOfIndexMap || {});
+        for (const outputTypeComposerIndex in outputTypeComposers) {
+            const outputTypeComposer = outputTypeComposers[outputTypeComposerIndex];
+            const statusCode = (_a = statusCodeOneOfIndexMapEntries.find(([statusCode, index]) => index.toString() === outputTypeComposerIndex.toString())) === null || _a === void 0 ? void 0 : _a[0];
+            if ('getFields' in outputTypeComposer) {
+                if (statusCode != null) {
+                    schemaComposer.addDirective(directives_js_1.StatusCodeTypeNameDirective);
+                    directives.push({
+                        name: 'statusCodeTypeName',
+                        args: {
+                            statusCode,
+                            typeName: outputTypeComposer.getTypeName(),
+                        },
+                    });
+                }
+                subSchemaAndTypeComposers.output.addType(outputTypeComposer);
+            }
+            else {
+                for (const possibleType of outputTypeComposer.getTypes()) {
+                    subSchemaAndTypeComposers.output.addType(possibleType);
+                }
+            }
+        }
+        subSchemaAndTypeComposers.output.setDirectives(directives);
+    }
+    return {
+        input: subSchemaAndTypeComposers.input,
+        output: subSchemaAndTypeComposers.output,
+        nullable: subSchemaAndTypeComposers.nullable,
+        readOnly: subSchemaAndTypeComposers.readOnly,
+        writeOnly: subSchemaAndTypeComposers.writeOnly,
+    };
+}
+exports.getUnionTypeComposers = getUnionTypeComposers;

package/cjs/getValidTypeName.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidTypeName = void 0;
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
+function getValidTypeName({ schemaComposer, isInput, subSchema, }) {
+    if (!subSchema.title) {
+        throw new Error('Missing title for schema; ' + (0, utils_2.inspect)(subSchema));
+    }
+    const sanitizedName = (0, utils_1.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;
+}
+exports.getValidTypeName = getValidTypeName;

package/cjs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDirectives = void 0;
+const tslib_1 = require("tslib");
+const loadGraphQLSchemaFromJSONSchemas_js_1 = require("./loadGraphQLSchemaFromJSONSchemas.js");
+exports.default = loadGraphQLSchemaFromJSONSchemas_js_1.loadGraphQLSchemaFromJSONSchemas;
+tslib_1.__exportStar(require("./loadGraphQLSchemaFromJSONSchemas.js"), exports);
+tslib_1.__exportStar(require("./getComposerFromJSONSchema.js"), exports);
+tslib_1.__exportStar(require("./getDereferencedJSONSchemaFromOperations.js"), exports);
+tslib_1.__exportStar(require("./getGraphQLSchemaFromDereferencedJSONSchema.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+var directives_js_1 = require("./directives.js");
+Object.defineProperty(exports, "processDirectives", { enumerable: true, get: function () { return directives_js_1.processDirectives; } });
+tslib_1.__exportStar(require("./bundle.js"), exports);

package/cjs/loadGraphQLSchemaFromJSONSchemas.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGraphQLSchemaFromJSONSchemas = exports.loadNonExecutableGraphQLSchemaFromJSONSchemas = void 0;
+const utils_1 = require("@graphql-mesh/utils");
+const fetch_1 = require("@whatwg-node/fetch");
+const bundle_js_1 = require("./bundle.js");
+const directives_js_1 = require("./directives.js");
+const getDereferencedJSONSchemaFromOperations_js_1 = require("./getDereferencedJSONSchemaFromOperations.js");
+const getGraphQLSchemaFromDereferencedJSONSchema_js_1 = require("./getGraphQLSchemaFromDereferencedJSONSchema.js");
+async function loadNonExecutableGraphQLSchemaFromJSONSchemas(name, options) {
+    options.logger = options.logger || new utils_1.DefaultLogger(name);
+    options.cwd = options.cwd || process.cwd();
+    const fullyDeferencedSchema = await (0, getDereferencedJSONSchemaFromOperations_js_1.getDereferencedJSONSchemaFromOperations)({
+        operations: options.operations,
+        operationHeaders: typeof options.operationHeaders === 'object' ? options.operationHeaders : {},
+        queryParams: options.queryParams,
+        endpoint: options.endpoint,
+        cwd: options.cwd,
+        logger: options.logger,
+        fetchFn: options.fetch,
+        schemaHeaders: options.schemaHeaders,
+        ignoreErrorResponses: options.ignoreErrorResponses,
+    });
+    const schema = await (0, getGraphQLSchemaFromDereferencedJSONSchema_js_1.getGraphQLSchemaFromDereferencedJSONSchema)(name, {
+        fullyDeferencedSchema,
+        logger: options.logger,
+        operations: options.operations,
+        operationHeaders: options.operationHeaders,
+        endpoint: options.endpoint,
+        queryParams: options.queryParams,
+        queryStringOptions: options.queryStringOptions,
+    });
+    if (options.bundle) {
+        schema.extensions = schema.extensions || {};
+        Object.defineProperty(schema.extensions, 'bundle', {
+            value: await (0, bundle_js_1.createBundleFromDereferencedSchema)(name, {
+                dereferencedSchema: fullyDeferencedSchema,
+                endpoint: options.endpoint,
+                operations: options.operations,
+                operationHeaders: typeof options.operationHeaders === 'object' ? options.operationHeaders : {},
+                logger: options.logger,
+            }),
+        });
+    }
+    return schema;
+}
+exports.loadNonExecutableGraphQLSchemaFromJSONSchemas = loadNonExecutableGraphQLSchemaFromJSONSchemas;
+async function loadGraphQLSchemaFromJSONSchemas(name, options) {
+    const graphqlSchema = await loadNonExecutableGraphQLSchemaFromJSONSchemas(name, options);
+    return (0, directives_js_1.processDirectives)({
+        ...options,
+        operationHeaders: typeof options.operationHeaders === 'object' ? options.operationHeaders : {},
+        schema: graphqlSchema,
+        globalFetch: options.fetch || fetch_1.fetch,
+        pubsub: options.pubsub,
+        logger: options.logger,
+    });
+}
+exports.loadGraphQLSchemaFromJSONSchemas = loadGraphQLSchemaFromJSONSchemas;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}