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

package/esm/getJSONSchemaOptionsFromOpenAPIOptions.js

@@ -0,0 +1,467 @@
+import { OperationTypeNode } from 'graphql';
+import { dereferenceObject, handleUntitledDefinitions, resolvePath, } from 'json-machete';
+import { process } from '@graphql-mesh/cross-helpers';
+import { getInterpolatedHeadersFactory } from '@graphql-mesh/string-interpolation';
+import { defaultImportFn, DefaultLogger, readFileOrUrl, sanitizeNameForGraphQL, } from '@graphql-mesh/utils';
+import { getFieldNameFromPath } from './utils.js';
+export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams = {}, selectQueryOrMutationField = [], logger = new DefaultLogger('getJSONSchemaOptionsFromOpenAPIOptions'), }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const fieldTypeMap = {};
+    for (const { fieldName, type } of selectQueryOrMutationField) {
+        fieldTypeMap[fieldName] = type;
+    }
+    const schemaHeadersFactory = getInterpolatedHeadersFactory(schemaHeaders);
+    logger === null || logger === void 0 ? void 0 : logger.debug(`Fetching OpenAPI Document from ${source}`);
+    let oasOrSwagger = typeof source === 'string'
+        ? await readFileOrUrl(source, {
+            cwd,
+            fallbackFormat,
+            headers: schemaHeadersFactory({ env: process.env }),
+            fetch: fetchFn,
+            importFn: defaultImportFn,
+            logger,
+        })
+        : source;
+    handleUntitledDefinitions(oasOrSwagger);
+    oasOrSwagger = (await dereferenceObject(oasOrSwagger));
+    const operations = [];
+    let baseOperationArgTypeMap;
+    if (!endpoint) {
+        if ('servers' in oasOrSwagger) {
+            const serverObj = oasOrSwagger.servers[0];
+            endpoint = serverObj.url.split('{').join('{args.');
+            if (serverObj.variables) {
+                for (const variableName in serverObj.variables) {
+                    const variable = serverObj.variables[variableName];
+                    if (!variable.type) {
+                        variable.type = 'string';
+                    }
+                    baseOperationArgTypeMap = baseOperationArgTypeMap || {};
+                    baseOperationArgTypeMap[variableName] = variable;
+                    if (variable.default) {
+                        endpoint = endpoint.replace(`{args.${variableName}}`, `{args.${variableName}:${variable.default}}`);
+                    }
+                }
+            }
+        }
+        if ('schemes' in oasOrSwagger && oasOrSwagger.schemes.length > 0 && oasOrSwagger.host) {
+            endpoint = oasOrSwagger.schemes[0] + '://' + oasOrSwagger.host;
+            if ('basePath' in oasOrSwagger) {
+                endpoint += oasOrSwagger.basePath;
+            }
+        }
+    }
+    const methodObjFieldMap = new WeakMap();
+    for (const relativePath in oasOrSwagger.paths) {
+        const pathObj = oasOrSwagger.paths[relativePath];
+        const pathParameters = pathObj.parameters;
+        for (const method in pathObj) {
+            if (method === 'parameters' ||
+                method === 'summary' ||
+                method === 'description' ||
+                method === 'servers') {
+                continue;
+            }
+            const methodObj = pathObj[method];
+            const operationConfig = {
+                method: method.toUpperCase(),
+                path: relativePath,
+                type: method.toUpperCase() === 'GET' ? 'query' : 'mutation',
+                field: methodObj.operationId && sanitizeNameForGraphQL(methodObj.operationId),
+                description: methodObj.description || methodObj.summary,
+                schemaHeaders,
+                operationHeaders,
+                responseByStatusCode: {},
+                ...(baseOperationArgTypeMap
+                    ? {
+                        argTypeMap: {
+                            ...baseOperationArgTypeMap,
+                        },
+                    }
+                    : {}),
+            };
+            operations.push(operationConfig);
+            methodObjFieldMap.set(methodObj, operationConfig);
+            let allParams;
+            if (methodObj.parameters && Array.isArray(methodObj.parameters)) {
+                allParams = [...(pathParameters || []), ...methodObj.parameters];
+            }
+            else {
+                allParams = {
+                    ...(pathParameters || {}),
+                    ...(methodObj.parameters || {}),
+                };
+            }
+            for (const paramObjIndex in allParams) {
+                const paramObj = allParams[paramObjIndex];
+                const argName = sanitizeNameForGraphQL(paramObj.name);
+                const operationArgTypeMap = (operationConfig.argTypeMap =
+                    operationConfig.argTypeMap || {});
+                switch (paramObj.in) {
+                    case 'query':
+                        operationConfig.queryParamArgMap = operationConfig.queryParamArgMap || {};
+                        operationConfig.queryParamArgMap[paramObj.name] = argName;
+                        if (paramObj.name in queryParams) {
+                            paramObj.required = false;
+                            if (!((_a = paramObj.schema) === null || _a === void 0 ? void 0 : _a.default)) {
+                                paramObj.schema = paramObj.schema || {
+                                    type: 'string',
+                                };
+                                paramObj.schema.default = queryParams[paramObj.name];
+                            }
+                        }
+                        if ('explode' in paramObj) {
+                            operationConfig.queryStringOptionsByParam =
+                                operationConfig.queryStringOptionsByParam || {};
+                            operationConfig.queryStringOptionsByParam[paramObj.name] =
+                                operationConfig.queryStringOptionsByParam[paramObj.name] || {};
+                            if (paramObj.explode) {
+                                operationConfig.queryStringOptionsByParam[paramObj.name].arrayFormat = 'repeat';
+                                operationConfig.queryStringOptionsByParam[paramObj.name].destructObject = true;
+                            }
+                            else {
+                                if (paramObj.style === 'form') {
+                                    operationConfig.queryStringOptionsByParam[paramObj.name].arrayFormat = 'comma';
+                                }
+                                else {
+                                    logger.warn(`Other styles including ${paramObj.style} of query parameters are not supported yet.`);
+                                }
+                            }
+                        }
+                        break;
+                    case 'path': {
+                        // If it is in the path, let JSON Schema handler put it
+                        operationConfig.path = operationConfig.path.replace(`{${paramObj.name}}`, `{args.${argName}}`);
+                        break;
+                    }
+                    case 'header': {
+                        operationConfig.headers = operationConfig.headers || {};
+                        if (typeof operationHeaders === 'object' && operationHeaders[paramObj.name]) {
+                            paramObj.required = false;
+                            const valueFromGlobal = operationHeaders[paramObj.name];
+                            if (!valueFromGlobal.includes('{')) {
+                                if (paramObj.schema) {
+                                    paramObj.schema.default = valueFromGlobal;
+                                }
+                            }
+                            else {
+                                if ((_b = paramObj.schema) === null || _b === void 0 ? void 0 : _b.default) {
+                                    delete paramObj.schema.default;
+                                }
+                            }
+                        }
+                        if (typeof operationHeaders === 'function') {
+                            paramObj.required = false;
+                            if ((_c = paramObj.schema) === null || _c === void 0 ? void 0 : _c.default) {
+                                delete paramObj.schema.default;
+                            }
+                        }
+                        let defaultValueSuffix = '';
+                        if ((_d = paramObj.schema) === null || _d === void 0 ? void 0 : _d.default) {
+                            defaultValueSuffix = `:${paramObj.schema.default}`;
+                        }
+                        operationConfig.headers[paramObj.name] = `{args.${argName}${defaultValueSuffix}}`;
+                        break;
+                    }
+                    case 'cookie': {
+                        operationConfig.headers = operationConfig.headers || {};
+                        operationConfig.headers.cookie = operationConfig.headers.cookie || '';
+                        const cookieParams = operationConfig.headers.cookie.split(' ').filter(c => !!c);
+                        cookieParams.push(`${paramObj.name}={args.${argName}};`);
+                        operationConfig.headers.cookie = `${cookieParams.join(' ')}`;
+                        break;
+                    }
+                    case 'body':
+                        if (paramObj.schema && Object.keys(paramObj.schema).length > 0) {
+                            operationConfig.requestSchema = paramObj.schema;
+                        }
+                        if (paramObj.example) {
+                            operationConfig.requestSample = paramObj.example;
+                        }
+                        if (paramObj.examples) {
+                            operationConfig.requestSample = Object.values(paramObj.examples)[0];
+                        }
+                        break;
+                }
+                operationArgTypeMap[argName] =
+                    paramObj.schema || ((_f = (_e = paramObj.content) === null || _e === void 0 ? void 0 : _e['application/json']) === null || _f === void 0 ? void 0 : _f.schema) || paramObj;
+                if (!operationArgTypeMap[argName].title) {
+                    operationArgTypeMap[argName].name = paramObj.name;
+                }
+                if (!operationArgTypeMap[argName].description) {
+                    operationArgTypeMap[argName].description = paramObj.description;
+                }
+                if (paramObj.required) {
+                    operationArgTypeMap[argName].nullable = false;
+                }
+                if (!('type' in paramObj) &&
+                    !paramObj.schema &&
+                    !paramObj.content &&
+                    !paramObj.example &&
+                    !paramObj.examples) {
+                    operationArgTypeMap[argName].type = 'string';
+                }
+            }
+            if ('requestBody' in methodObj) {
+                const requestBodyObj = methodObj.requestBody;
+                if ('content' in requestBodyObj) {
+                    const contentKey = Object.keys(requestBodyObj.content)[0];
+                    const contentSchema = (_g = requestBodyObj.content[contentKey]) === null || _g === void 0 ? void 0 : _g.schema;
+                    if (contentSchema && Object.keys(contentSchema).length > 0) {
+                        operationConfig.requestSchema = contentSchema;
+                    }
+                    const examplesObj = (_h = requestBodyObj.content[contentKey]) === null || _h === void 0 ? void 0 : _h.examples;
+                    if (examplesObj) {
+                        operationConfig.requestSample = Object.values(examplesObj)[0];
+                    }
+                    if (!((_j = operationConfig.headers) === null || _j === void 0 ? void 0 : _j['Content-Type']) && typeof contentKey === 'string') {
+                        operationConfig.headers = operationConfig.headers || {};
+                        operationConfig.headers['Content-Type'] = contentKey;
+                    }
+                }
+            }
+            const responseByStatusCode = operationConfig.responseByStatusCode;
+            // Handling multiple response types
+            for (const responseKey in methodObj.responses) {
+                const responseObj = methodObj.responses[responseKey];
+                let schemaObj;
+                if ('consumes' in methodObj) {
+                    operationConfig.headers = operationConfig.headers || {};
+                    operationConfig.headers['Content-Type'] = methodObj.consumes.join(', ');
+                }
+                if ('produces' in methodObj) {
+                    operationConfig.headers = operationConfig.headers || {};
+                    operationConfig.headers.Accept = methodObj.produces.join(', ');
+                }
+                if ('content' in responseObj) {
+                    const responseObjForStatusCode = {
+                        oneOf: [],
+                    };
+                    let allMimeTypes = [];
+                    if (typeof operationHeaders === 'object') {
+                        const acceptFromOperationHeader = operationHeaders.accept || operationHeaders.Accept;
+                        if (acceptFromOperationHeader) {
+                            allMimeTypes = [acceptFromOperationHeader];
+                        }
+                    }
+                    if (allMimeTypes.length === 0) {
+                        allMimeTypes = Object.keys(responseObj.content);
+                    }
+                    const jsonLikeMimeTypes = allMimeTypes.filter(c => c !== '*/*' && c.toString().includes('json'));
+                    const mimeTypes = jsonLikeMimeTypes.length > 0 ? jsonLikeMimeTypes : allMimeTypes;
+                    // If we have a better accept header, overwrite User's choice
+                    if ((!((_k = operationConfig.headers) === null || _k === void 0 ? void 0 : _k.accept) && !((_l = operationConfig.headers) === null || _l === void 0 ? void 0 : _l.Accept)) ||
+                        mimeTypes.length === 1) {
+                        operationConfig.headers = operationConfig.headers || {};
+                        if (operationConfig.headers.Accept) {
+                            delete operationConfig.headers.Accept;
+                        }
+                        operationConfig.headers.accept =
+                            jsonLikeMimeTypes.length > 0
+                                ? jsonLikeMimeTypes.join(',')
+                                : allMimeTypes[0].toString();
+                    }
+                    for (const contentKey in responseObj.content) {
+                        if (!mimeTypes.includes(contentKey)) {
+                            continue;
+                        }
+                        schemaObj = responseObj.content[contentKey].schema;
+                        if (schemaObj && Object.keys(schemaObj).length > 0) {
+                            responseObjForStatusCode.oneOf.push(schemaObj);
+                        }
+                        else if (contentKey.toString().startsWith('text')) {
+                            responseObjForStatusCode.oneOf.push({ type: 'string' });
+                        }
+                        else {
+                            const examplesObj = responseObj.content[contentKey].examples;
+                            if (examplesObj) {
+                                let examples = Object.values(examplesObj);
+                                if (contentKey.includes('json')) {
+                                    examples = examples.map(example => {
+                                        if (typeof example === 'string') {
+                                            return JSON.parse(example);
+                                        }
+                                        return example;
+                                    });
+                                }
+                                responseObjForStatusCode.oneOf.push({
+                                    examples,
+                                });
+                            }
+                            let example = responseObj.content[contentKey].example;
+                            if (example) {
+                                if (typeof example === 'string' && contentKey.includes('json')) {
+                                    example = JSON.parse(example);
+                                }
+                                responseObjForStatusCode.oneOf.push({
+                                    examples: [example],
+                                });
+                            }
+                        }
+                    }
+                    if (responseObjForStatusCode.oneOf.length === 1) {
+                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
+                        responseByStatusCode[responseKey].responseSchema = responseObjForStatusCode.oneOf[0];
+                    }
+                    else if (responseObjForStatusCode.oneOf.length > 1) {
+                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
+                        responseByStatusCode[responseKey].responseSchema = responseObjForStatusCode;
+                    }
+                }
+                else if ('schema' in responseObj) {
+                    schemaObj = responseObj.schema;
+                    if (schemaObj && Object.keys(schemaObj).length > 0) {
+                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
+                        responseByStatusCode[responseKey].responseSchema = schemaObj;
+                    }
+                }
+                else if ('examples' in responseObj) {
+                    const examples = Object.values(responseObj.examples);
+                    responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
+                    let example = examples[0];
+                    if (typeof example === 'string') {
+                        try {
+                            // Parse if possible
+                            example = JSON.parse(example);
+                        }
+                        catch (e) {
+                            // Do nothing
+                        }
+                    }
+                    responseByStatusCode[responseKey].responseSample = example;
+                }
+                else if (responseKey.toString() === '204') {
+                    responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
+                    responseByStatusCode[responseKey].responseSchema = {
+                        type: 'null',
+                        description: responseObj.description,
+                    };
+                }
+                if ('links' in responseObj) {
+                    const dereferencedLinkObj = await dereferenceObject({
+                        links: responseObj.links,
+                    }, {
+                        cwd,
+                        root: oasOrSwagger,
+                        fetchFn,
+                        logger,
+                        headers: schemaHeaders,
+                    });
+                    responseByStatusCode[responseKey].links = responseByStatusCode[responseKey].links || {};
+                    for (const linkName in dereferencedLinkObj.links) {
+                        const linkObj = responseObj.links[linkName];
+                        let args;
+                        if (linkObj.parameters) {
+                            args = {};
+                            for (const parameterName in linkObj.parameters) {
+                                const parameterExp = linkObj.parameters[parameterName];
+                                const sanitizedParamName = sanitizeNameForGraphQL(parameterName);
+                                if (typeof parameterExp === 'string') {
+                                    args[sanitizedParamName] = parameterExp.startsWith('$')
+                                        ? `{root.${parameterExp}}`
+                                        : parameterExp.split('$').join('root.$');
+                                }
+                                else {
+                                    args[sanitizedParamName] = parameterExp;
+                                }
+                            }
+                        }
+                        const sanitizedLinkName = sanitizeNameForGraphQL(linkName);
+                        if ('operationRef' in linkObj) {
+                            const [externalPath, ref] = linkObj.operationRef.split('#');
+                            if (externalPath) {
+                                logger.debug(`Skipping external operation reference ${linkObj.operationRef}\n Use additionalTypeDefs and additionalResolvers instead.`);
+                            }
+                            else {
+                                const actualOperation = resolvePath(ref, oasOrSwagger);
+                                responseByStatusCode[responseKey].links[sanitizedLinkName] = {
+                                    get fieldName() {
+                                        const linkOperationConfig = methodObjFieldMap.get(actualOperation);
+                                        return linkOperationConfig.field;
+                                    },
+                                    args,
+                                    description: linkObj.description,
+                                };
+                            }
+                        }
+                        else if ('operationId' in linkObj) {
+                            responseByStatusCode[responseKey].links[sanitizedLinkName] = {
+                                fieldName: sanitizeNameForGraphQL(linkObj.operationId),
+                                args,
+                                description: linkObj.description,
+                            };
+                        }
+                    }
+                }
+                if (!operationConfig.field) {
+                    methodObj.operationId = getFieldNameFromPath(relativePath, method, schemaObj === null || schemaObj === void 0 ? void 0 : schemaObj.$resolvedRef);
+                    // Operation ID might not be avaiable so let's generate field name from path and response type schema
+                    operationConfig.field = sanitizeNameForGraphQL(methodObj.operationId);
+                }
+                // Give a better name to the request input object
+                if (typeof operationConfig.requestSchema === 'object' &&
+                    !operationConfig.requestSchema.title) {
+                    operationConfig.requestSchema.title = operationConfig.field + '_request';
+                }
+            }
+            if ('callbacks' in methodObj) {
+                for (const callbackKey in methodObj.callbacks) {
+                    const callbackObj = methodObj.callbacks[callbackKey];
+                    for (const callbackUrlRefKey in callbackObj) {
+                        if (callbackUrlRefKey.startsWith('$')) {
+                            continue;
+                        }
+                        const pubsubTopicSuffix = callbackUrlRefKey
+                            .split('$request.query')
+                            .join('args')
+                            .split('$request.body#/')
+                            .join('args.')
+                            .split('$response.body#/')
+                            .join('args.');
+                        const callbackOperationConfig = {
+                            type: OperationTypeNode.SUBSCRIPTION,
+                            field: '',
+                            pubsubTopic: '',
+                        };
+                        const callbackUrlObj = callbackObj[callbackUrlRefKey];
+                        for (const method in callbackUrlObj) {
+                            const callbackOperation = callbackUrlObj[method];
+                            callbackOperationConfig.pubsubTopic = `webhook:${method}:${pubsubTopicSuffix}`;
+                            callbackOperationConfig.field = callbackOperation.operationId;
+                            callbackOperationConfig.description =
+                                callbackOperation.description || callbackOperation.summary;
+                            const requestBodyContents = (_m = callbackOperation.requestBody) === null || _m === void 0 ? void 0 : _m.content;
+                            if (requestBodyContents) {
+                                callbackOperationConfig.responseSchema = requestBodyContents[Object.keys(requestBodyContents)[0]].schema;
+                            }
+                            const responses = callbackOperation.responses;
+                            if (responses) {
+                                const response = responses[Object.keys(responses)[0]];
+                                if (response) {
+                                    const responseContents = response.content;
+                                    if (responseContents) {
+                                        callbackOperationConfig.requestSchema = responseContents[Object.keys(responseContents)[0]].schema;
+                                    }
+                                }
+                            }
+                        }
+                        callbackOperationConfig.field =
+                            callbackOperationConfig.field || sanitizeNameForGraphQL(callbackKey);
+                        operations.push(callbackOperationConfig);
+                    }
+                }
+            }
+            if (fieldTypeMap[operationConfig.field]) {
+                operationConfig.type = fieldTypeMap[operationConfig.field];
+            }
+        }
+    }
+    return {
+        operations,
+        endpoint,
+        cwd,
+        fetch: fetchFn,
+        schemaHeaders,
+        operationHeaders,
+    };
+}

package/esm/index.js

@@ -0,0 +1,3 @@
+export { loadGraphQLSchemaFromOpenAPI as default } from './loadGraphQLSchemaFromOpenAPI.js';
+export * from './loadGraphQLSchemaFromOpenAPI.js';
+export { getJSONSchemaOptionsFromOpenAPIOptions } from './getJSONSchemaOptionsFromOpenAPIOptions.js';

package/esm/loadGraphQLSchemaFromOpenAPI.js

@@ -0,0 +1,23 @@
+import { loadGraphQLSchemaFromJSONSchemas, loadNonExecutableGraphQLSchemaFromJSONSchemas, } from '@omnigraph/json-schema';
+import { getJSONSchemaOptionsFromOpenAPIOptions } from './getJSONSchemaOptionsFromOpenAPIOptions.js';
+/**
+ * Creates a local GraphQLSchema instance from a OpenAPI Document.
+ * Everytime this function is called, the OpenAPI file and its dependencies will be resolved on runtime.
+ * If you want to avoid this, use `createBundle` function to create a bundle once and save it to a storage
+ * then load it with `loadGraphQLSchemaFromBundle`.
+ */
+export async function loadGraphQLSchemaFromOpenAPI(name, options) {
+    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromOpenAPIOptions(name, options);
+    return loadGraphQLSchemaFromJSONSchemas(name, {
+        ...options,
+        ...extraJSONSchemaOptions,
+    });
+}
+export async function loadNonExecutableGraphQLSchemaFromOpenAPI(name, options) {
+    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromOpenAPIOptions(name, options);
+    return loadNonExecutableGraphQLSchemaFromJSONSchemas(name, {
+        ...options,
+        ...extraJSONSchemaOptions,
+    });
+}
+export { processDirectives } from '@omnigraph/json-schema';

package/esm/utils.js

@@ -0,0 +1,40 @@
+import { camelCase } from 'change-case';
+export function getFieldNameFromPath(path, method, responseTypeSchemaRef) {
+    // Replace identifiers with "by"
+    path = path.split('{').join('by_').split('}').join('');
+    const [actualPartsStr, allQueryPartsStr] = path.split('?');
+    const actualParts = actualPartsStr.split('/').filter(Boolean);
+    let fieldNameWithoutMethod = actualParts.join('_');
+    // If path doesn't give any field name without identifiers, we can use the return type with HTTP Method name
+    if ((!fieldNameWithoutMethod || fieldNameWithoutMethod.startsWith('by')) &&
+        responseTypeSchemaRef) {
+        const refArr = responseTypeSchemaRef.split('/');
+        // lowercase looks better in the schema
+        const prefix = camelCase(refArr[refArr.length - 1]);
+        if (fieldNameWithoutMethod) {
+            fieldNameWithoutMethod = prefix + '_' + fieldNameWithoutMethod;
+        }
+        else {
+            fieldNameWithoutMethod = prefix;
+        }
+    }
+    if (fieldNameWithoutMethod.startsWith('by_')) {
+        fieldNameWithoutMethod = fieldNameWithoutMethod.replace('by_', '');
+    }
+    if (allQueryPartsStr) {
+        const queryParts = allQueryPartsStr.split('&');
+        for (const queryPart of queryParts) {
+            const [queryName] = queryPart.split('=');
+            fieldNameWithoutMethod += '_' + 'by' + '_' + queryName;
+        }
+    }
+    // get_ doesn't look good in field names
+    const methodPrefix = method.toLowerCase();
+    if (methodPrefix === 'get') {
+        return fieldNameWithoutMethod;
+    }
+    if (fieldNameWithoutMethod) {
+        return methodPrefix + '_' + fieldNameWithoutMethod;
+    }
+    return methodPrefix;
+}

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@omnigraph/openapi",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-mesh/string-interpolation": "0.3.0",
-    "@omnigraph/json-schema": "1.0.0-alpha-3fc47d119.0",
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@omnigraph/json-schema": "1.0.0-alpha-20230420181317-a95037648",
     "change-case": "4.1.2",
-    "json-machete": "1.0.0-alpha-3fc47d119.0",
-    "openapi-types": "12.0.0",
-    "tslib": "^2.4.0"
+    "json-machete": "1.0.0-alpha-20230420181317-a95037648",
+    "openapi-types": "12.1.0"
   },
   "repository": {
     "type": "git",
@@ -22,21 +22,28 @@
     "directory": "packages/loaders/openapi"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/getJSONSchemaOptionsFromOpenAPIOptions.d.cts

@@ -0,0 +1,26 @@
+/// <reference types="@cloudflare/workers-types" />
+import { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig, OperationHeadersConfiguration } from '@omnigraph/json-schema';
+import { OpenAPILoaderSelectQueryOrMutationFieldConfig } from './types.cjs';
+interface GetJSONSchemaOptionsFromOpenAPIOptionsParams {
+    source: OpenAPIV3.Document | OpenAPIV2.Document | string;
+    fallbackFormat?: 'json' | 'yaml' | 'js' | 'ts';
+    cwd?: string;
+    fetch?: WindowOrWorkerGlobalScope['fetch'];
+    endpoint?: string;
+    schemaHeaders?: Record<string, string>;
+    operationHeaders?: OperationHeadersConfiguration;
+    queryParams?: Record<string, any>;
+    selectQueryOrMutationField?: OpenAPILoaderSelectQueryOrMutationFieldConfig[];
+    logger?: Logger;
+}
+export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams, selectQueryOrMutationField, logger, }: GetJSONSchemaOptionsFromOpenAPIOptionsParams): Promise<{
+    operations: JSONSchemaOperationConfig[];
+    endpoint: string;
+    cwd: string;
+    fetch: (input: RequestInfo | URL, init?: RequestInit<CfProperties<unknown>>) => Promise<Response>;
+    schemaHeaders: Record<string, string>;
+    operationHeaders: OperationHeadersConfiguration;
+}>;
+export {};

package/typings/getJSONSchemaOptionsFromOpenAPIOptions.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="@cloudflare/workers-types" />
+import { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig, OperationHeadersConfiguration } from '@omnigraph/json-schema';
+import { OpenAPILoaderSelectQueryOrMutationFieldConfig } from './types.js';
+interface GetJSONSchemaOptionsFromOpenAPIOptionsParams {
+    source: OpenAPIV3.Document | OpenAPIV2.Document | string;
+    fallbackFormat?: 'json' | 'yaml' | 'js' | 'ts';
+    cwd?: string;
+    fetch?: WindowOrWorkerGlobalScope['fetch'];
+    endpoint?: string;
+    schemaHeaders?: Record<string, string>;
+    operationHeaders?: OperationHeadersConfiguration;
+    queryParams?: Record<string, any>;
+    selectQueryOrMutationField?: OpenAPILoaderSelectQueryOrMutationFieldConfig[];
+    logger?: Logger;
+}
+export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams, selectQueryOrMutationField, logger, }: GetJSONSchemaOptionsFromOpenAPIOptionsParams): Promise<{
+    operations: JSONSchemaOperationConfig[];
+    endpoint: string;
+    cwd: string;
+    fetch: (input: RequestInfo | URL, init?: RequestInit<CfProperties<unknown>>) => Promise<Response>;
+    schemaHeaders: Record<string, string>;
+    operationHeaders: OperationHeadersConfiguration;
+}>;
+export {};