@omnigraph/openapi 0.109.10 → 0.109.11

package/cjs/getJSONSchemaOptionsFromOpenAPIOptions.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.futureLinks = void 0;
 exports.getJSONSchemaOptionsFromOpenAPIOptions = getJSONSchemaOptionsFromOpenAPIOptions;
+exports.getJSONSchemaOptionsFromMultipleOpenAPIOptions = getJSONSchemaOptionsFromMultipleOpenAPIOptions;
 const graphql_1 = require("graphql");
 const json_machete_1 = require("json-machete");
 const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
@@ -15,8 +17,12 @@ const defaultHateoasConfig = {
     linkObjectIdentifier: '_links',
     linkObjectExtensionIdentifier: 'x-links',
 };
-const futureLinks = new Set();
-async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams = {}, selectQueryOrMutationField = [], logger = new utils_1.DefaultLogger('getJSONSchemaOptionsFromOpenAPIOptions'), jsonApi, HATEOAS, }) {
+// Global fallback for backward compatibility - exported for testing
+exports.futureLinks = new Set();
+async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams = {}, selectQueryOrMutationField = [], logger = new utils_1.DefaultLogger('getJSONSchemaOptionsFromOpenAPIOptions'), jsonApi, HATEOAS, }, hateoasContext) {
+    // Use provided context or create/use global fallback
+    const contextFutureLinks = hateoasContext?.futureLinks || exports.futureLinks;
+    const loadedSchemas = hateoasContext?.loadedSchemas || new Map();
     const hateOasConfig = HATEOAS === true
         ? defaultHateoasConfig
         : HATEOAS === false
@@ -118,9 +124,18 @@ async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFo
         }
     }
     const methodObjFieldMap = new WeakMap();
-    for (const futureLink of futureLinks) {
+    // Try to resolve any pending future links with currently loaded schemas
+    for (const [schemaName, schemaData] of loadedSchemas) {
+        for (const futureLink of Array.from(contextFutureLinks)) {
+            if (futureLink(schemaName, schemaData.oasDoc, schemaData.methodObjFieldMap)) {
+                contextFutureLinks.delete(futureLink);
+            }
+        }
+    }
+    // Try to resolve future links with current schema
+    for (const futureLink of Array.from(contextFutureLinks)) {
         if (futureLink(name, oasOrSwagger, methodObjFieldMap)) {
-            break;
+            contextFutureLinks.delete(futureLink);
         }
     }
     for (const relativePath in oasOrSwagger.paths) {
@@ -445,16 +460,19 @@ async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFo
                         const xLinkObj = schemaObj.properties?.[hateOasConfig.linkObjectIdentifier]?.[hateOasConfig.linkObjectExtensionIdentifier]?.find(link => link[hateOasConfig.linkNameIdentifier] === linkName);
                         if (xLinkObj) {
                             const xLinkHref = xLinkObj[hateOasConfig.linkPathIdentifier];
-                            const cleanXLinkHref = xLinkHref.replace(/{[^}]+}/g, '{}');
+                            // Remove query parameters and path parameters for comparison
+                            const cleanXLinkHref = xLinkHref.split('?')[0].replace(/{[^}]+}/g, '{}');
                             const deferred = (0, utils_2.createDeferred)();
                             function findActualOperationAndPath(possibleName, possibleOasDoc, possibleMethodObjFieldMap) {
                                 let actualOperation;
                                 let actualPath;
                                 for (const path in possibleOasDoc.paths) {
-                                    const cleanPath = path.replace(/{[^}]+}/g, '{}');
+                                    const cleanPath = path.split('?')[0].replace(/{[^}]+}/g, '{}');
                                     if (cleanPath === cleanXLinkHref) {
                                         actualPath = path;
-                                        actualOperation = possibleOasDoc.paths[path][method];
+                                        // Find the operation by looking for GET method or first available method
+                                        const pathObj = possibleOasDoc.paths[path];
+                                        actualOperation = pathObj.get || pathObj[Object.keys(pathObj)[0]];
                                         break;
                                     }
                                 }
@@ -529,19 +547,26 @@ async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFo
                                             }
                                         }
                                     }
-                                    futureLinks.delete(findActualOperationAndPath);
+                                    contextFutureLinks.delete(findActualOperationAndPath);
                                     deferred.resolve();
                                     return true;
                                 }
                                 return false;
                             }
-                            setTimeout(() => {
-                                logger.warn(`Could not find operation for link ${linkName} in ${name} for ${xLinkHref}`);
-                                futureLinks.delete(findActualOperationAndPath);
-                                deferred.resolve();
-                            }, 5000);
+                            // Only set timeout if we're not in batch mode (no context provided)
+                            if (!hateoasContext) {
+                                setTimeout(() => {
+                                    logger.warn(`Could not find operation for link ${linkName} in ${name} for ${xLinkHref}`);
+                                    contextFutureLinks.delete(findActualOperationAndPath);
+                                    deferred.resolve();
+                                }, 5000);
+                            }
                             if (!findActualOperationAndPath(name, oasOrSwagger, methodObjFieldMap)) {
-                                futureLinks.add(findActualOperationAndPath);
+                                contextFutureLinks.add(findActualOperationAndPath);
+                            }
+                            // In batch mode, resolve immediately since we'll handle resolution later
+                            if (hateoasContext) {
+                                deferred.resolve();
                             }
                             return deferred.promise;
                         }
@@ -664,6 +689,13 @@ async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFo
             }
         }
     }
+    // Register this schema in the context for future cross-references
+    if (hateoasContext) {
+        loadedSchemas.set(name, {
+            oasDoc: oasOrSwagger,
+            methodObjFieldMap,
+        });
+    }
     return {
         operations,
         endpoint,
@@ -673,3 +705,44 @@ async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFo
         operationHeaders,
     };
 }
+/**
+ * Loads multiple OpenAPI schemas with proper HATEOAS cross-reference resolution.
+ * This function ensures that schemas referencing operations from other schemas
+ * are resolved correctly regardless of loading order.
+ */
+async function getJSONSchemaOptionsFromMultipleOpenAPIOptions(schemas) {
+    // Create shared context for cross-schema HATEOAS resolution
+    const hateoasContext = {
+        futureLinks: new Set(),
+        loadedSchemas: new Map(),
+    };
+    const results = [];
+    // First pass: Load all schemas
+    for (const { name, options } of schemas) {
+        const result = await getJSONSchemaOptionsFromOpenAPIOptions(name, options, hateoasContext);
+        results.push({ name, result });
+    }
+    // Second pass: Attempt to resolve any remaining future links
+    let maxAttempts = schemas.length * 2; // Prevent infinite loops
+    while (hateoasContext.futureLinks.size > 0 && maxAttempts > 0) {
+        const initialSize = hateoasContext.futureLinks.size;
+        for (const [schemaName, schemaData] of hateoasContext.loadedSchemas) {
+            for (const futureLink of Array.from(hateoasContext.futureLinks)) {
+                if (futureLink(schemaName, schemaData.oasDoc, schemaData.methodObjFieldMap)) {
+                    hateoasContext.futureLinks.delete(futureLink);
+                }
+            }
+        }
+        // If no progress was made, break to avoid infinite loop
+        if (hateoasContext.futureLinks.size === initialSize) {
+            break;
+        }
+        maxAttempts--;
+    }
+    // Log remaining unresolved links
+    if (hateoasContext.futureLinks.size > 0) {
+        const logger = new utils_1.DefaultLogger('getJSONSchemaOptionsFromMultipleOpenAPIOptions');
+        logger.warn(`${hateoasContext.futureLinks.size} HATEOAS links could not be resolved after loading all schemas. This may indicate missing operations or circular dependencies.`);
+    }
+    return results;
+}

package/esm/getJSONSchemaOptionsFromOpenAPIOptions.js

@@ -12,8 +12,12 @@ const defaultHateoasConfig = {
     linkObjectIdentifier: '_links',
     linkObjectExtensionIdentifier: 'x-links',
 };
-const futureLinks = new Set();
-export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams = {}, selectQueryOrMutationField = [], logger = new DefaultLogger('getJSONSchemaOptionsFromOpenAPIOptions'), jsonApi, HATEOAS, }) {
+// Global fallback for backward compatibility - exported for testing
+export const futureLinks = new Set();
+export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams = {}, selectQueryOrMutationField = [], logger = new DefaultLogger('getJSONSchemaOptionsFromOpenAPIOptions'), jsonApi, HATEOAS, }, hateoasContext) {
+    // Use provided context or create/use global fallback
+    const contextFutureLinks = hateoasContext?.futureLinks || futureLinks;
+    const loadedSchemas = hateoasContext?.loadedSchemas || new Map();
     const hateOasConfig = HATEOAS === true
         ? defaultHateoasConfig
         : HATEOAS === false
@@ -115,9 +119,18 @@ export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fal
         }
     }
     const methodObjFieldMap = new WeakMap();
-    for (const futureLink of futureLinks) {
+    // Try to resolve any pending future links with currently loaded schemas
+    for (const [schemaName, schemaData] of loadedSchemas) {
+        for (const futureLink of Array.from(contextFutureLinks)) {
+            if (futureLink(schemaName, schemaData.oasDoc, schemaData.methodObjFieldMap)) {
+                contextFutureLinks.delete(futureLink);
+            }
+        }
+    }
+    // Try to resolve future links with current schema
+    for (const futureLink of Array.from(contextFutureLinks)) {
         if (futureLink(name, oasOrSwagger, methodObjFieldMap)) {
-            break;
+            contextFutureLinks.delete(futureLink);
         }
     }
     for (const relativePath in oasOrSwagger.paths) {
@@ -442,16 +455,19 @@ export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fal
                         const xLinkObj = schemaObj.properties?.[hateOasConfig.linkObjectIdentifier]?.[hateOasConfig.linkObjectExtensionIdentifier]?.find(link => link[hateOasConfig.linkNameIdentifier] === linkName);
                         if (xLinkObj) {
                             const xLinkHref = xLinkObj[hateOasConfig.linkPathIdentifier];
-                            const cleanXLinkHref = xLinkHref.replace(/{[^}]+}/g, '{}');
+                            // Remove query parameters and path parameters for comparison
+                            const cleanXLinkHref = xLinkHref.split('?')[0].replace(/{[^}]+}/g, '{}');
                             const deferred = createDeferred();
                             function findActualOperationAndPath(possibleName, possibleOasDoc, possibleMethodObjFieldMap) {
                                 let actualOperation;
                                 let actualPath;
                                 for (const path in possibleOasDoc.paths) {
-                                    const cleanPath = path.replace(/{[^}]+}/g, '{}');
+                                    const cleanPath = path.split('?')[0].replace(/{[^}]+}/g, '{}');
                                     if (cleanPath === cleanXLinkHref) {
                                         actualPath = path;
-                                        actualOperation = possibleOasDoc.paths[path][method];
+                                        // Find the operation by looking for GET method or first available method
+                                        const pathObj = possibleOasDoc.paths[path];
+                                        actualOperation = pathObj.get || pathObj[Object.keys(pathObj)[0]];
                                         break;
                                     }
                                 }
@@ -526,19 +542,26 @@ export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fal
                                             }
                                         }
                                     }
-                                    futureLinks.delete(findActualOperationAndPath);
+                                    contextFutureLinks.delete(findActualOperationAndPath);
                                     deferred.resolve();
                                     return true;
                                 }
                                 return false;
                             }
-                            setTimeout(() => {
-                                logger.warn(`Could not find operation for link ${linkName} in ${name} for ${xLinkHref}`);
-                                futureLinks.delete(findActualOperationAndPath);
-                                deferred.resolve();
-                            }, 5000);
+                            // Only set timeout if we're not in batch mode (no context provided)
+                            if (!hateoasContext) {
+                                setTimeout(() => {
+                                    logger.warn(`Could not find operation for link ${linkName} in ${name} for ${xLinkHref}`);
+                                    contextFutureLinks.delete(findActualOperationAndPath);
+                                    deferred.resolve();
+                                }, 5000);
+                            }
                             if (!findActualOperationAndPath(name, oasOrSwagger, methodObjFieldMap)) {
-                                futureLinks.add(findActualOperationAndPath);
+                                contextFutureLinks.add(findActualOperationAndPath);
+                            }
+                            // In batch mode, resolve immediately since we'll handle resolution later
+                            if (hateoasContext) {
+                                deferred.resolve();
                             }
                             return deferred.promise;
                         }
@@ -661,6 +684,13 @@ export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fal
             }
         }
     }
+    // Register this schema in the context for future cross-references
+    if (hateoasContext) {
+        loadedSchemas.set(name, {
+            oasDoc: oasOrSwagger,
+            methodObjFieldMap,
+        });
+    }
     return {
         operations,
         endpoint,
@@ -670,3 +700,44 @@ export async function getJSONSchemaOptionsFromOpenAPIOptions(name, { source, fal
         operationHeaders,
     };
 }
+/**
+ * Loads multiple OpenAPI schemas with proper HATEOAS cross-reference resolution.
+ * This function ensures that schemas referencing operations from other schemas
+ * are resolved correctly regardless of loading order.
+ */
+export async function getJSONSchemaOptionsFromMultipleOpenAPIOptions(schemas) {
+    // Create shared context for cross-schema HATEOAS resolution
+    const hateoasContext = {
+        futureLinks: new Set(),
+        loadedSchemas: new Map(),
+    };
+    const results = [];
+    // First pass: Load all schemas
+    for (const { name, options } of schemas) {
+        const result = await getJSONSchemaOptionsFromOpenAPIOptions(name, options, hateoasContext);
+        results.push({ name, result });
+    }
+    // Second pass: Attempt to resolve any remaining future links
+    let maxAttempts = schemas.length * 2; // Prevent infinite loops
+    while (hateoasContext.futureLinks.size > 0 && maxAttempts > 0) {
+        const initialSize = hateoasContext.futureLinks.size;
+        for (const [schemaName, schemaData] of hateoasContext.loadedSchemas) {
+            for (const futureLink of Array.from(hateoasContext.futureLinks)) {
+                if (futureLink(schemaName, schemaData.oasDoc, schemaData.methodObjFieldMap)) {
+                    hateoasContext.futureLinks.delete(futureLink);
+                }
+            }
+        }
+        // If no progress was made, break to avoid infinite loop
+        if (hateoasContext.futureLinks.size === initialSize) {
+            break;
+        }
+        maxAttempts--;
+    }
+    // Log remaining unresolved links
+    if (hateoasContext.futureLinks.size > 0) {
+        const logger = new DefaultLogger('getJSONSchemaOptionsFromMultipleOpenAPIOptions');
+        logger.warn(`${hateoasContext.futureLinks.size} HATEOAS links could not be resolved after loading all schemas. This may indicate missing operations or circular dependencies.`);
+    }
+    return results;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnigraph/openapi",
-  "version": "0.109.10",
+  "version": "0.109.11",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "*"

package/typings/getJSONSchemaOptionsFromOpenAPIOptions.d.cts

@@ -1,6 +1,6 @@
 import type { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
 import type { Logger, MeshFetch } from '@graphql-mesh/types';
-import type { JSONSchemaOperationConfig, OperationHeadersConfiguration } from '@omnigraph/json-schema';
+import type { JSONSchemaHTTPJSONOperationConfig, JSONSchemaOperationConfig, JSONSchemaOperationResponseConfig, OperationHeadersConfiguration } from '@omnigraph/json-schema';
 import type { SelectQueryOrMutationFieldConfig } from './types.cjs';
 export interface HATEOASConfig {
     /**
@@ -34,7 +34,19 @@ interface GetJSONSchemaOptionsFromOpenAPIOptionsParams {
     jsonApi?: boolean;
     HATEOAS?: Partial<HATEOASConfig> | boolean;
 }
-export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams, selectQueryOrMutationField, logger, jsonApi, HATEOAS, }: GetJSONSchemaOptionsFromOpenAPIOptionsParams): Promise<{
+type FutureLink = (name: string, oasDoc: OpenAPIV3.Document | OpenAPIV2.Document, methodObjFieldMap: MethodObjFieldMap) => boolean;
+type MethodObjFieldMap = WeakMap<OpenAPIV2.OperationObject | OpenAPIV3.OperationObject, JSONSchemaHTTPJSONOperationConfig & {
+    responseByStatusCode: Record<string, JSONSchemaOperationResponseConfig>;
+}>;
+export interface HATEOASContext {
+    futureLinks: Set<FutureLink>;
+    loadedSchemas: Map<string, {
+        oasDoc: OpenAPIV3.Document | OpenAPIV2.Document;
+        methodObjFieldMap: MethodObjFieldMap;
+    }>;
+}
+export declare const futureLinks: Set<FutureLink>;
+export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams, selectQueryOrMutationField, logger, jsonApi, HATEOAS, }: GetJSONSchemaOptionsFromOpenAPIOptionsParams, hateoasContext?: HATEOASContext): Promise<{
     operations: JSONSchemaOperationConfig[];
     endpoint: string;
     cwd: string;
@@ -42,4 +54,16 @@ export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { s
     schemaHeaders: Record<string, string>;
     operationHeaders: OperationHeadersConfiguration;
 }>;
+/**
+ * Loads multiple OpenAPI schemas with proper HATEOAS cross-reference resolution.
+ * This function ensures that schemas referencing operations from other schemas
+ * are resolved correctly regardless of loading order.
+ */
+export declare function getJSONSchemaOptionsFromMultipleOpenAPIOptions(schemas: Array<{
+    name: string;
+    options: GetJSONSchemaOptionsFromOpenAPIOptionsParams;
+}>): Promise<Array<{
+    name: string;
+    result: Awaited<ReturnType<typeof getJSONSchemaOptionsFromOpenAPIOptions>>;
+}>>;
 export {};

package/typings/getJSONSchemaOptionsFromOpenAPIOptions.d.ts

@@ -1,6 +1,6 @@
 import type { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
 import type { Logger, MeshFetch } from '@graphql-mesh/types';
-import type { JSONSchemaOperationConfig, OperationHeadersConfiguration } from '@omnigraph/json-schema';
+import type { JSONSchemaHTTPJSONOperationConfig, JSONSchemaOperationConfig, JSONSchemaOperationResponseConfig, OperationHeadersConfiguration } from '@omnigraph/json-schema';
 import type { SelectQueryOrMutationFieldConfig } from './types.js';
 export interface HATEOASConfig {
     /**
@@ -34,7 +34,19 @@ interface GetJSONSchemaOptionsFromOpenAPIOptionsParams {
     jsonApi?: boolean;
     HATEOAS?: Partial<HATEOASConfig> | boolean;
 }
-export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams, selectQueryOrMutationField, logger, jsonApi, HATEOAS, }: GetJSONSchemaOptionsFromOpenAPIOptionsParams): Promise<{
+type FutureLink = (name: string, oasDoc: OpenAPIV3.Document | OpenAPIV2.Document, methodObjFieldMap: MethodObjFieldMap) => boolean;
+type MethodObjFieldMap = WeakMap<OpenAPIV2.OperationObject | OpenAPIV3.OperationObject, JSONSchemaHTTPJSONOperationConfig & {
+    responseByStatusCode: Record<string, JSONSchemaOperationResponseConfig>;
+}>;
+export interface HATEOASContext {
+    futureLinks: Set<FutureLink>;
+    loadedSchemas: Map<string, {
+        oasDoc: OpenAPIV3.Document | OpenAPIV2.Document;
+        methodObjFieldMap: MethodObjFieldMap;
+    }>;
+}
+export declare const futureLinks: Set<FutureLink>;
+export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { source, fallbackFormat, cwd, fetch: fetchFn, endpoint, schemaHeaders, operationHeaders, queryParams, selectQueryOrMutationField, logger, jsonApi, HATEOAS, }: GetJSONSchemaOptionsFromOpenAPIOptionsParams, hateoasContext?: HATEOASContext): Promise<{
     operations: JSONSchemaOperationConfig[];
     endpoint: string;
     cwd: string;
@@ -42,4 +54,16 @@ export declare function getJSONSchemaOptionsFromOpenAPIOptions(name: string, { s
     schemaHeaders: Record<string, string>;
     operationHeaders: OperationHeadersConfiguration;
 }>;
+/**
+ * Loads multiple OpenAPI schemas with proper HATEOAS cross-reference resolution.
+ * This function ensures that schemas referencing operations from other schemas
+ * are resolved correctly regardless of loading order.
+ */
+export declare function getJSONSchemaOptionsFromMultipleOpenAPIOptions(schemas: Array<{
+    name: string;
+    options: GetJSONSchemaOptionsFromOpenAPIOptionsParams;
+}>): Promise<Array<{
+    name: string;
+    result: Awaited<ReturnType<typeof getJSONSchemaOptionsFromOpenAPIOptions>>;
+}>>;
 export {};