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

package/esm/getDereferencedJSONSchemaFromOperations.js

@@ -0,0 +1,29 @@
+import { dereferenceObject, healJSONSchema } from 'json-machete';
+import { process } from '@graphql-mesh/cross-helpers';
+import { getInterpolatedHeadersFactory } from '@graphql-mesh/string-interpolation';
+import { getReferencedJSONSchemaFromOperations } from './getReferencedJSONSchemaFromOperations.js';
+export async function getDereferencedJSONSchemaFromOperations({ operations, cwd = process.cwd(), logger, fetchFn, schemaHeaders, ignoreErrorResponses, endpoint, operationHeaders, queryParams, }) {
+    const referencedJSONSchema = await getReferencedJSONSchemaFromOperations({
+        operations,
+        cwd,
+        schemaHeaders,
+        ignoreErrorResponses,
+        fetchFn,
+        endpoint,
+        operationHeaders,
+        queryParams,
+    });
+    logger.debug(`Dereferencing JSON Schema to resolve all $refs`);
+    const schemaHeadersFactory = getInterpolatedHeadersFactory(schemaHeaders);
+    const fullyDeferencedSchema = await dereferenceObject(referencedJSONSchema, {
+        cwd,
+        fetchFn,
+        logger: logger.child('dereferenceObject'),
+        headers: schemaHeadersFactory({ env: process.env }),
+    });
+    logger.debug(`Healing JSON Schema`);
+    const healedSchema = await healJSONSchema(fullyDeferencedSchema, {
+        logger: logger.child('healJSONSchema'),
+    });
+    return healedSchema;
+}

package/esm/getGraphQLSchemaFromDereferencedJSONSchema.js

@@ -0,0 +1,35 @@
+import { specifiedDirectives } from 'graphql';
+import { SchemaComposer } from 'graphql-compose';
+import { addExecutionDirectivesToComposer, } from './addExecutionLogicToComposer.js';
+import { getComposerFromJSONSchema } from './getComposerFromJSONSchema.js';
+export 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 getComposerFromJSONSchema(fullyDeferencedSchema, logger.child('getComposerFromJSONSchema'));
+    const schemaComposerWithoutExecutionLogic = visitorResult.output;
+    if (!(schemaComposerWithoutExecutionLogic instanceof 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 specifiedDirectives) {
+        schemaComposerWithoutExecutionLogic.addDirective(directive);
+    }
+    const schemaComposerWithExecutionLogic = await 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();
+}

package/esm/getJSONSchemaStringFormatScalarMap.js

@@ -0,0 +1,56 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { GraphQLScalarType, Kind } from 'graphql';
+import { pascalCase } from 'pascal-case';
+const JSONSchemaStringFormats = [
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+];
+export function getJSONSchemaStringFormatScalarMap() {
+    const ajv = new Ajv({
+        strict: false,
+    });
+    addFormats(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 GraphQLScalarType({
+            name: pascalCase(format),
+            description: `Represents ${format} values`,
+            serialize: coerceString,
+            parseValue: coerceString,
+            parseLiteral: ast => {
+                if (ast.kind === 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;
+}

package/esm/getReferencedJSONSchemaFromOperations.js

@@ -0,0 +1,255 @@
+import { AnySchema } from 'json-machete';
+import toJsonSchema from 'to-json-schema';
+import { getInterpolationKeys } from '@graphql-mesh/string-interpolation';
+import { defaultImportFn, DefaultLogger, readFileOrUrl, sanitizeNameForGraphQL, } from '@graphql-mesh/utils';
+import { getOperationMetadata } from './utils.js';
+async function handleOperationResponseConfig(operationResponseConfig, { schemaHeaders, cwd, fetchFn, logger = new 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 readFileOrUrl(operationResponseConfig.responseSample, {
+                cwd,
+                fetch: fetchFn,
+                logger,
+                importFn: 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 {
+        return AnySchema;
+    }
+}
+export async function getReferencedJSONSchemaFromOperations({ operations, cwd, schemaHeaders, ignoreErrorResponses, logger = new DefaultLogger('getReferencedJSONSchemaFromOperations'), fetchFn, endpoint, operationHeaders, queryParams, }) {
+    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: {},
+            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] = 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 = toJsonSchema(example, {
+                    required: false,
+                    objects: {
+                        additionalProperties: false,
+                    },
+                    strings: {
+                        detectFormat: true,
+                    },
+                    arrays: {
+                        mode: 'first',
+                    },
+                });
+                generatedSchema.examples = [example];
+                const argName = sanitizeNameForGraphQL(queryParamName);
+                operationConfig.queryParamArgMap = operationConfig.queryParamArgMap || {};
+                operationConfig.queryParamArgMap[queryParamName] = argName;
+                operationConfig.argTypeMap = operationConfig.argTypeMap || {};
+                operationConfig.argTypeMap[argName] = generatedSchema;
+            }
+        }
+        const interpolationKeys = 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 readFileOrUrl(operationConfig.requestSample, {
+                    cwd,
+                    headers: schemaHeaders,
+                    fetch: fetchFn,
+                    logger,
+                    importFn: defaultImportFn,
+                }).catch((e) => {
+                    throw new Error(`${operationConfig.field}.requestSample: ${operationConfig.requestSample}; ${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] = rootTypeInputTypeDefinition.properties[fieldName] || {
+                title: `${rootTypeInputPropertyName}_${fieldName}`,
+                type: 'object',
+                properties: {},
+            };
+            rootTypeInputTypeDefinition.properties[fieldName].properties.input = generatedSchema;
+        }
+    }
+    return finalJsonSchema;
+}

package/esm/getTypeResolverFromOutputTCs.js

@@ -0,0 +1,65 @@
+import { createGraphQLError } from '@graphql-tools/utils';
+export 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 = 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;
+        */
+    };
+}

package/esm/getUnionTypeComposers.js

@@ -0,0 +1,80 @@
+import { isSomeInputTypeComposer, } from 'graphql-compose';
+import { StatusCodeTypeNameDirective } from './directives.js';
+export function getContainerTC(schemaComposer, output) {
+    const containerTypeName = `${output.getTypeName()}_container`;
+    return schemaComposer.getOrCreateOTC(containerTypeName, otc => otc.addFields({
+        [output.getTypeName()]: {
+            type: output,
+            resolve: root => root,
+        },
+    }));
+}
+export 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 (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(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,
+    };
+}

package/esm/getValidTypeName.js

@@ -0,0 +1,16 @@
+import { sanitizeNameForGraphQL } from '@graphql-mesh/utils';
+import { inspect } from '@graphql-tools/utils';
+export function getValidTypeName({ schemaComposer, isInput, subSchema, }) {
+    if (!subSchema.title) {
+        throw new Error('Missing title for schema; ' + inspect(subSchema));
+    }
+    const sanitizedName = 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;
+}

package/esm/index.js

@@ -0,0 +1,9 @@
+import { loadGraphQLSchemaFromJSONSchemas } from './loadGraphQLSchemaFromJSONSchemas.js';
+export default loadGraphQLSchemaFromJSONSchemas;
+export * from './loadGraphQLSchemaFromJSONSchemas.js';
+export * from './getComposerFromJSONSchema.js';
+export * from './getDereferencedJSONSchemaFromOperations.js';
+export * from './getGraphQLSchemaFromDereferencedJSONSchema.js';
+export * from './types.js';
+export { processDirectives } from './directives.js';
+export * from './bundle.js';

package/esm/loadGraphQLSchemaFromJSONSchemas.js

@@ -0,0 +1,54 @@
+import { DefaultLogger } from '@graphql-mesh/utils';
+import { fetch } from '@whatwg-node/fetch';
+import { createBundleFromDereferencedSchema } from './bundle.js';
+import { processDirectives } from './directives.js';
+import { getDereferencedJSONSchemaFromOperations } from './getDereferencedJSONSchemaFromOperations.js';
+import { getGraphQLSchemaFromDereferencedJSONSchema } from './getGraphQLSchemaFromDereferencedJSONSchema.js';
+export async function loadNonExecutableGraphQLSchemaFromJSONSchemas(name, options) {
+    options.logger = options.logger || new DefaultLogger(name);
+    options.cwd = options.cwd || process.cwd();
+    const fullyDeferencedSchema = await 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 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 createBundleFromDereferencedSchema(name, {
+                dereferencedSchema: fullyDeferencedSchema,
+                endpoint: options.endpoint,
+                operations: options.operations,
+                operationHeaders: typeof options.operationHeaders === 'object' ? options.operationHeaders : {},
+                logger: options.logger,
+            }),
+        });
+    }
+    return schema;
+}
+export async function loadGraphQLSchemaFromJSONSchemas(name, options) {
+    const graphqlSchema = await loadNonExecutableGraphQLSchemaFromJSONSchemas(name, options);
+    return processDirectives({
+        ...options,
+        operationHeaders: typeof options.operationHeaders === 'object' ? options.operationHeaders : {},
+        schema: graphqlSchema,
+        globalFetch: options.fetch || fetch,
+        pubsub: options.pubsub,
+        logger: options.logger,
+    });
+}

package/esm/resolveDataByUnionInputType.js

@@ -0,0 +1,36 @@
+import { isInputObjectType, isListType, isNonNullType, } from 'graphql';
+import { sanitizeNameForGraphQL } from '@graphql-mesh/utils';
+import { asArray, getDirective } from '@graphql-tools/utils';
+export function resolveDataByUnionInputType(data, type, schema) {
+    var _a;
+    if (data) {
+        if (isListType(type)) {
+            return asArray(data).map(elem => resolveDataByUnionInputType(elem, type.ofType, schema));
+        }
+        if (isNonNullType(type)) {
+            return resolveDataByUnionInputType(data, type.ofType, schema);
+        }
+        if (isInputObjectType(type)) {
+            const typeOneOfDirectives = getDirective(schema, type, 'oneOf');
+            const isOneOf = typeOneOfDirectives === null || typeOneOfDirectives === void 0 ? void 0 : typeOneOfDirectives.length;
+            const fieldMap = type.getFields();
+            data = asArray(data)[0];
+            for (const propertyName in data) {
+                const fieldName = sanitizeNameForGraphQL(propertyName);
+                const field = fieldMap[fieldName];
+                if (field) {
+                    if (isOneOf) {
+                        const resolvedData = resolveDataByUnionInputType(data[fieldName], field.type, schema);
+                        return resolvedData;
+                    }
+                    const fieldData = data[fieldName];
+                    data[fieldName] = undefined;
+                    const fieldResolveRootFieldDirectives = getDirective(schema, field, 'resolveRootField');
+                    const realFieldName = ((_a = fieldResolveRootFieldDirectives === null || fieldResolveRootFieldDirectives === void 0 ? void 0 : fieldResolveRootFieldDirectives[0]) === null || _a === void 0 ? void 0 : _a.field) || fieldName;
+                    data[realFieldName] = resolveDataByUnionInputType(fieldData, field.type, schema);
+                }
+            }
+        }
+    }
+    return data;
+}

package/esm/scalars.js

@@ -0,0 +1,27 @@
+import { GraphQLScalarType } from 'graphql';
+export const GraphQLFile = new GraphQLScalarType({
+    name: 'File',
+    description: 'The `File` scalar type represents a file upload.',
+    extensions: {
+        codegenScalarType: 'File',
+    },
+});
+export const GraphQLVoid = new GraphQLScalarType({
+    name: 'Void',
+    description: 'Represents empty values',
+    serialize: () => '',
+    extensions: {
+        codegenScalarType: 'void',
+    },
+});
+export const ObjMapScalar = new GraphQLScalarType({
+    name: 'ObjMap',
+    serialize: value => JSON.stringify(value),
+    parseValue: value => JSON.parse(value.toString()),
+    parseLiteral: ast => {
+        if (ast.kind === 'StringValue') {
+            return JSON.parse(ast.value);
+        }
+        return null;
+    },
+});