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

package/typings/index.d.cts

@@ -0,0 +1,4 @@
+export { loadGraphQLSchemaFromOpenAPI as default } from './loadGraphQLSchemaFromOpenAPI.cjs';
+export * from './loadGraphQLSchemaFromOpenAPI.cjs';
+export { getJSONSchemaOptionsFromOpenAPIOptions } from './getJSONSchemaOptionsFromOpenAPIOptions.cjs';
+export { OpenAPILoaderOptions } from './types.cjs';

package/typings/index.d.ts

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

package/typings/loadGraphQLSchemaFromOpenAPI.d.cts

@@ -0,0 +1,10 @@
+import { OpenAPILoaderOptions } from './types.cjs';
+/**
+ * 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 declare function loadGraphQLSchemaFromOpenAPI(name: string, options: OpenAPILoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export declare function loadNonExecutableGraphQLSchemaFromOpenAPI(name: string, options: OpenAPILoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export { processDirectives } from '@omnigraph/json-schema';

package/{loadGraphQLSchemaFromOpenAPI.d.ts → typings/loadGraphQLSchemaFromOpenAPI.d.ts}

@@ -1,4 +1,4 @@
-import { OpenAPILoaderOptions } from '.';
+import { OpenAPILoaderOptions } from './types.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.
@@ -6,3 +6,5 @@ import { OpenAPILoaderOptions } from '.';
  * then load it with `loadGraphQLSchemaFromBundle`.
  */
 export declare function loadGraphQLSchemaFromOpenAPI(name: string, options: OpenAPILoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export declare function loadNonExecutableGraphQLSchemaFromOpenAPI(name: string, options: OpenAPILoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export { processDirectives } from '@omnigraph/json-schema';

package/typings/types.d.cts

@@ -0,0 +1,10 @@
+import { JSONSchemaLoaderOptions } from '@omnigraph/json-schema';
+export interface OpenAPILoaderOptions extends Partial<JSONSchemaLoaderOptions> {
+    source: string;
+    selectQueryOrMutationField?: OpenAPILoaderSelectQueryOrMutationFieldConfig[];
+    fallbackFormat?: 'json' | 'yaml' | 'js' | 'ts';
+}
+export interface OpenAPILoaderSelectQueryOrMutationFieldConfig {
+    type: 'query' | 'mutation' | 'Query' | 'Mutation';
+    fieldName: string;
+}

package/{types.d.ts → typings/types.d.ts}

@@ -1,10 +1,10 @@
 import { JSONSchemaLoaderOptions } from '@omnigraph/json-schema';
 export interface OpenAPILoaderOptions extends Partial<JSONSchemaLoaderOptions> {
-    oasFilePath: string;
+    source: string;
     selectQueryOrMutationField?: OpenAPILoaderSelectQueryOrMutationFieldConfig[];
     fallbackFormat?: 'json' | 'yaml' | 'js' | 'ts';
 }
 export interface OpenAPILoaderSelectQueryOrMutationFieldConfig {
-    type: 'query' | 'mutation';
+    type: 'query' | 'mutation' | 'Query' | 'Mutation';
     fieldName: string;
 }

package/typings/utils.d.ts

@@ -0,0 +1 @@
+export declare function getFieldNameFromPath(path: string, method: string, responseTypeSchemaRef: string): string;

package/bundle.d.ts

@@ -1,8 +0,0 @@
-import { getGraphQLSchemaFromBundle, JSONSchemaLoaderBundle as OpenAPILoaderBundle } from '@omnigraph/json-schema';
-import { OpenAPILoaderOptions } from './types';
-/**
- * Creates a bundle by downloading and resolving the internal references once
- * to load the schema locally later
- */
-export declare function createBundle(name: string, openApiLoaderOptions: OpenAPILoaderOptions): Promise<OpenAPILoaderBundle>;
-export { getGraphQLSchemaFromBundle, OpenAPILoaderBundle };

package/getJSONSchemaOptionsFromOpenAPIOptions.d.ts

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

package/index.d.ts

@@ -1,4 +0,0 @@
-export { loadGraphQLSchemaFromOpenAPI as default } from './loadGraphQLSchemaFromOpenAPI';
-export { getJSONSchemaOptionsFromOpenAPIOptions } from './getJSONSchemaOptionsFromOpenAPIOptions';
-export { OpenAPILoaderOptions } from './types';
-export * from './bundle';

package/index.js

@@ -1,355 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const jsonSchema = require('@omnigraph/json-schema');
-const utils = require('@graphql-mesh/utils');
-const jsonMachete = require('json-machete');
-const changeCase = require('change-case');
-const stringInterpolation = require('@graphql-mesh/string-interpolation');
-const crossHelpers = require('@graphql-mesh/cross-helpers');
-
-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 = changeCase.camelCase(refArr[refArr.length - 1]);
-        if (fieldNameWithoutMethod) {
-            fieldNameWithoutMethod = prefix + '_' + fieldNameWithoutMethod;
-        }
-        else {
-            fieldNameWithoutMethod = prefix;
-        }
-    }
-    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;
-}
-
-async function getJSONSchemaOptionsFromOpenAPIOptions({ oasFilePath, fallbackFormat, cwd, fetch: fetchFn, baseUrl, schemaHeaders, operationHeaders, selectQueryOrMutationField = [], logger = new utils.DefaultLogger('getJSONSchemaOptionsFromOpenAPIOptions'), }) {
-    var _a, _b, _c, _d, _e;
-    const fieldTypeMap = {};
-    for (const { fieldName, type } of selectQueryOrMutationField) {
-        fieldTypeMap[fieldName] = type;
-    }
-    const schemaHeadersFactory = stringInterpolation.getInterpolatedHeadersFactory(schemaHeaders);
-    logger === null || logger === void 0 ? void 0 : logger.debug(`Fetching OpenAPI Document from ${oasFilePath}`);
-    const oasOrSwagger = typeof oasFilePath === 'string'
-        ? await utils.readFileOrUrl(oasFilePath, {
-            cwd,
-            fallbackFormat,
-            headers: schemaHeadersFactory({ env: crossHelpers.process.env }),
-            fetch: fetchFn,
-            importFn: utils.defaultImportFn,
-            logger,
-        })
-        : oasFilePath;
-    const operations = [];
-    if ('servers' in oasOrSwagger) {
-        baseUrl = baseUrl || oasOrSwagger.servers[0].url;
-    }
-    for (const relativePath in oasOrSwagger.paths) {
-        const pathObj = oasOrSwagger.paths[relativePath];
-        for (const method in pathObj) {
-            const methodObj = pathObj[method];
-            const operationConfig = {
-                method: method.toUpperCase(),
-                path: relativePath,
-                type: method.toUpperCase() === 'GET' ? 'query' : 'mutation',
-                field: methodObj.operationId && utils.sanitizeNameForGraphQL(methodObj.operationId),
-                description: methodObj.description || methodObj.summary,
-                schemaHeaders,
-                operationHeaders,
-                responseByStatusCode: {},
-            };
-            operations.push(operationConfig);
-            for (const paramObjIndex in methodObj.parameters) {
-                const paramObj = methodObj.parameters[paramObjIndex];
-                const argName = utils.sanitizeNameForGraphQL(paramObj.name);
-                switch (paramObj.in) {
-                    case 'query':
-                        if (method.toUpperCase() === 'GET') {
-                            const requestSchema = (operationConfig.requestSchema = operationConfig.requestSchema || {
-                                type: 'object',
-                                properties: {},
-                            });
-                            requestSchema.properties[paramObj.name] =
-                                paramObj.schema || ((_b = (_a = paramObj.content) === null || _a === void 0 ? void 0 : _a['application/json']) === null || _b === void 0 ? void 0 : _b.schema) || paramObj;
-                            if (!requestSchema.properties[paramObj.name].title) {
-                                requestSchema.properties[paramObj.name].name = paramObj.name;
-                            }
-                            if (!requestSchema.properties[paramObj.name].description) {
-                                requestSchema.properties[paramObj.name].description = paramObj.description;
-                            }
-                            if (requestSchema.properties.__typename) {
-                                delete requestSchema.properties.__typename;
-                            }
-                            if (paramObj.required) {
-                                requestSchema.required = requestSchema.required || [];
-                                requestSchema.required.push(paramObj.name);
-                            }
-                        }
-                        else {
-                            if (!operationConfig.path.includes('?')) {
-                                operationConfig.path += '?';
-                            }
-                            operationConfig.path += `${paramObj.name}={args.${argName}}`;
-                        }
-                        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 || {};
-                        operationConfig.headers[paramObj.name] = `{args.${argName}}`;
-                        break;
-                    }
-                    case 'cookie': {
-                        operationConfig.headers = operationConfig.headers || {};
-                        operationConfig.headers.cookie = operationConfig.headers.cookie || '';
-                        const cookieParams = operationConfig.headers.cookie.split('; ');
-                        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 = `${oasFilePath}#/paths/${relativePath
-                                .split('/')
-                                .join('~1')}/${method}/parameters/${paramObjIndex}/schema`;
-                        }
-                        if (paramObj.example) {
-                            operationConfig.requestSample = paramObj.example;
-                        }
-                        if (paramObj.examples) {
-                            operationConfig.requestSample = Object.values(paramObj.examples)[0];
-                        }
-                        break;
-                }
-                switch (((_c = paramObj.schema) === null || _c === void 0 ? void 0 : _c.type) || paramObj.type) {
-                    case 'string':
-                        operationConfig.argTypeMap = operationConfig.argTypeMap || {};
-                        operationConfig.argTypeMap[argName] = 'String';
-                        break;
-                    case 'integer':
-                        operationConfig.argTypeMap = operationConfig.argTypeMap || {};
-                        operationConfig.argTypeMap[argName] = 'Int';
-                        break;
-                    case 'number':
-                        operationConfig.argTypeMap = operationConfig.argTypeMap || {};
-                        operationConfig.argTypeMap[argName] = 'Float';
-                        break;
-                    case 'boolean':
-                        operationConfig.argTypeMap = operationConfig.argTypeMap || {};
-                        operationConfig.argTypeMap[argName] = 'Boolean';
-                        break;
-                }
-                if (paramObj.required) {
-                    operationConfig.argTypeMap = operationConfig.argTypeMap || {};
-                    operationConfig.argTypeMap[argName] = operationConfig.argTypeMap[argName] || 'ID';
-                    operationConfig.argTypeMap[argName] += '!';
-                }
-            }
-            if ('requestBody' in methodObj) {
-                const requestBodyObj = methodObj.requestBody;
-                if ('content' in requestBodyObj) {
-                    const contentKey = Object.keys(requestBodyObj.content)[0];
-                    const contentSchema = (_d = requestBodyObj.content[contentKey]) === null || _d === void 0 ? void 0 : _d.schema;
-                    if (contentSchema && Object.keys(contentSchema).length > 0) {
-                        operationConfig.requestSchema = `${oasFilePath}#/paths/${relativePath
-                            .split('/')
-                            .join('~1')}/${method}/requestBody/content/${contentKey === null || contentKey === void 0 ? void 0 : contentKey.toString().split('/').join('~1')}/schema`;
-                    }
-                    const examplesObj = (_e = requestBodyObj.content[contentKey]) === null || _e === void 0 ? void 0 : _e.examples;
-                    if (examplesObj) {
-                        operationConfig.requestSample = Object.values(examplesObj)[0];
-                    }
-                }
-            }
-            const responseByStatusCode = operationConfig.responseByStatusCode;
-            // Handling multiple response types
-            for (const responseKey in methodObj.responses) {
-                const responseObj = methodObj.responses[responseKey];
-                let schemaObj;
-                if ('content' in responseObj) {
-                    const contentKey = Object.keys(responseObj.content)[0];
-                    schemaObj = responseObj.content[contentKey].schema;
-                    if (schemaObj && Object.keys(schemaObj).length > 0) {
-                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
-                        responseByStatusCode[responseKey].responseSchema = `${oasFilePath}#/paths/${relativePath
-                            .split('/')
-                            .join('~1')}/${method}/responses/${responseKey}/content/${contentKey === null || contentKey === void 0 ? void 0 : contentKey.toString().split('/').join('~1')}/schema`;
-                    }
-                    const examplesObj = responseObj.content[contentKey].examples;
-                    if (examplesObj) {
-                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
-                        responseByStatusCode[responseKey].responseSample = Object.values(examplesObj)[0];
-                    }
-                    const example = responseObj.content[contentKey].example;
-                    if (example) {
-                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
-                        responseByStatusCode[responseKey].responseSample = example;
-                    }
-                }
-                else if ('schema' in responseObj) {
-                    schemaObj = responseObj.schema;
-                    if (schemaObj && Object.keys(schemaObj).length > 0) {
-                        responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
-                        responseByStatusCode[responseKey].responseSchema = `${oasFilePath}#/paths/${relativePath
-                            .split('/')
-                            .join('~1')}/${method}/responses/${responseKey}/schema`;
-                    }
-                }
-                else if ('examples' in responseObj) {
-                    const examples = Object.values(responseObj.examples);
-                    responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
-                    responseByStatusCode[responseKey].responseSample = examples[0];
-                }
-                else if (responseKey.toString() === '204') {
-                    responseByStatusCode[responseKey] = responseByStatusCode[responseKey] || {};
-                    responseByStatusCode[responseKey].responseSchema = {
-                        type: 'null',
-                        description: responseObj.description,
-                    };
-                }
-                if ('links' in responseObj) {
-                    const dereferencedLinkObj = await jsonMachete.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];
-                        if ('$ref' in linkObj) {
-                            throw new Error('Unexpected $ref in dereferenced link object');
-                        }
-                        const args = {};
-                        for (const parameterName in linkObj.parameters || {}) {
-                            const parameterExp = linkObj.parameters[parameterName].split('-').join('_');
-                            args[utils.sanitizeNameForGraphQL(parameterName)] = parameterExp.startsWith('$')
-                                ? `{root.${parameterExp}}`
-                                : parameterExp.split('$').join('root.$');
-                        }
-                        if ('operationRef' in linkObj) {
-                            const [externalPath, ref] = linkObj.operationRef.split('#');
-                            if (externalPath) {
-                                if (crossHelpers.process.env.DEBUG) {
-                                    console.warn(`Skipping external operation reference ${linkObj.operationRef}\n Use additionalTypeDefs and additionalResolvers instead.`);
-                                }
-                            }
-                            else {
-                                const actualOperation = jsonMachete.resolvePath(ref, oasOrSwagger);
-                                if (actualOperation.operationId) {
-                                    const fieldName = utils.sanitizeNameForGraphQL(actualOperation.operationId);
-                                    responseByStatusCode[responseKey].links[linkName] = {
-                                        fieldName,
-                                        args,
-                                        description: linkObj.description,
-                                    };
-                                }
-                                else {
-                                    console.warn('Missing operationId skipping...');
-                                }
-                            }
-                        }
-                        else if ('operationId' in linkObj) {
-                            responseByStatusCode[responseKey].links[linkName] = {
-                                fieldName: utils.sanitizeNameForGraphQL(linkObj.operationId),
-                                args,
-                                description: linkObj.description,
-                            };
-                        }
-                    }
-                }
-                if (!operationConfig.field) {
-                    methodObj.operationId = getFieldNameFromPath(relativePath, method, schemaObj === null || schemaObj === void 0 ? void 0 : schemaObj.$ref);
-                    // Operation ID might not be avaiable so let's generate field name from path and response type schema
-                    operationConfig.field = utils.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 (fieldTypeMap[operationConfig.field]) {
-                operationConfig.type = fieldTypeMap[operationConfig.field];
-            }
-        }
-    }
-    return {
-        operations,
-        baseUrl,
-        cwd,
-        fetch: fetchFn,
-        schemaHeaders,
-        operationHeaders,
-    };
-}
-
-/**
- * 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`.
- */
-async function loadGraphQLSchemaFromOpenAPI(name, options) {
-    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromOpenAPIOptions(options);
-    return jsonSchema.loadGraphQLSchemaFromJSONSchemas(name, {
-        ...options,
-        ...extraJSONSchemaOptions,
-    });
-}
-
-/**
- * Creates a bundle by downloading and resolving the internal references once
- * to load the schema locally later
- */
-async function createBundle(name, openApiLoaderOptions) {
-    const { operations, baseUrl, cwd, fetch, schemaHeaders, operationHeaders } = await getJSONSchemaOptionsFromOpenAPIOptions(openApiLoaderOptions);
-    return jsonSchema.createBundle(name, {
-        operations,
-        baseUrl,
-        cwd,
-        fetch,
-        schemaHeaders,
-        operationHeaders,
-        ignoreErrorResponses: openApiLoaderOptions.ignoreErrorResponses,
-        logger: openApiLoaderOptions.logger,
-    });
-}
-
-Object.defineProperty(exports, 'getGraphQLSchemaFromBundle', {
-    enumerable: true,
-    get: function () {
-        return jsonSchema.getGraphQLSchemaFromBundle;
-    }
-});
-exports.createBundle = createBundle;
-exports.default = loadGraphQLSchemaFromOpenAPI;
-exports.getJSONSchemaOptionsFromOpenAPIOptions = getJSONSchemaOptionsFromOpenAPIOptions;