@conduit-client/model 3.9.0 → 3.11.0

package/dist/v1/index.js

@@ -7,6 +7,7 @@ import * as url from "url";
 import amf from "amf-client-js";
 import path from "path";
 import SwaggerParser from "@apidevtools/swagger-parser";
+import { MissingPointerError, ResolverError } from "@apidevtools/json-schema-ref-parser";
 const BindingTypesEnum = ["wire", "imperative", "imperative-legacy", "mutation"];
 class BaseTypeRegistry extends Map {
   nameOf(t) {
@@ -13338,6 +13339,7 @@ const annotationSchema = z.object({
 });
 class SwaggerBaseType {
   constructor(api, schema2, schemaName, typeRegistry, factory, logger, fileParserLogger, jsonPath) {
+    var _a;
     this.api = api;
     this.schema = schema2;
     this.schemaName = schemaName;
@@ -13347,13 +13349,18 @@ class SwaggerBaseType {
     this.fileParserLogger = fileParserLogger;
     this.resolved = false;
     this.parsedExtensions = { type: "unidentifiable" };
+    const defaultPosition = {
+      line: 0,
+      column: 0,
+      filePath: ((_a = api.sourceUrl) == null ? void 0 : _a.pathname) ?? ""
+    };
     if (jsonPath) {
-      this.schemaPosition = api.getPosition(jsonPath) ?? { line: 0, column: 0 };
+      this.schemaPosition = api.getPosition(jsonPath) ?? defaultPosition;
     } else if (schemaName) {
       const defaultPath = `components/schemas/${schemaName}`;
-      this.schemaPosition = api.getPosition(defaultPath) ?? { line: 0, column: 0 };
+      this.schemaPosition = api.getPosition(defaultPath) ?? defaultPosition;
     } else {
-      this.schemaPosition = { line: 0, column: 0 };
+      this.schemaPosition = defaultPosition;
     }
   }
   resolve() {
@@ -13516,6 +13523,12 @@ class SwaggerNilTypeImpl extends SwaggerBaseType {
 function isReferenceObject(obj) {
   return obj !== null && typeof obj === "object" && "$ref" in obj;
 }
+function isSchemaObject(obj) {
+  return obj !== null && typeof obj === "object" && !("$ref" in obj) && ("type" in obj || "properties" in obj || "allOf" in obj || "anyOf" in obj || "oneOf" in obj || "items" in obj);
+}
+function isOpenAPISchema(obj) {
+  return isSchemaObject(obj) || isReferenceObject(obj);
+}
 function isArraySchema(schema2) {
   return schema2.type === "array";
 }
@@ -13590,6 +13603,14 @@ function mapScalarType(schema2) {
   }
 }
 function getRefTypeName(ref) {
+  const hashIndex = ref.lastIndexOf("#");
+  if (hashIndex !== -1) {
+    const fragment = ref.substring(hashIndex + 1);
+    const parts2 = fragment.split("/").filter((p) => p !== "");
+    if (parts2.length > 0) {
+      return parts2[parts2.length - 1];
+    }
+  }
   const parts = ref.split("/");
   return parts[parts.length - 1];
 }
@@ -13607,6 +13628,28 @@ function getEnumValues(schema2, schemaName) {
     );
   });
 }
+const OPENAPI_DOCUMENT_PROPERTIES = /* @__PURE__ */ new Set([
+  "openapi",
+  "info",
+  "servers",
+  "paths",
+  "components",
+  "security",
+  "tags",
+  "externalDocs",
+  "webhooks",
+  "jsonSchemaDialect"
+]);
+function extractRootLevelSchemas(file) {
+  const schemas2 = {};
+  for (const [key, value] of Object.entries(file)) {
+    if (OPENAPI_DOCUMENT_PROPERTIES.has(key) || key.startsWith("x-")) continue;
+    if (isOpenAPISchema(value)) {
+      schemas2[key] = value;
+    }
+  }
+  return schemas2;
+}
 class SwaggerEnumerableScalarType extends SwaggerBaseType {
   typeResolve() {
     if (this.schema.enum && this.schema.enum.length > 0) {
@@ -13894,6 +13937,12 @@ class SwaggerRefTypeImpl extends SwaggerBaseType {
     };
     this.resolved = false;
     this.refString = this.schema.$ref || "";
+    if (this.schemaPosition.line === 0 && this.schemaPosition.column === 0 && this.refString && this.api) {
+      const refPosition = this.api.getRefPosition(this.refString);
+      if (refPosition) {
+        this.schemaPosition = refPosition;
+      }
+    }
   }
   typeResolve() {
     if (this.refString) {
@@ -13905,7 +13954,7 @@ class SwaggerRefTypeImpl extends SwaggerBaseType {
         inheritedType.resolve();
         this.$ref = inheritedType;
       } else {
-        const errorMessage = `Failed to resolve $ref: ${typeName}`;
+        const errorMessage = `Failed to resolve $ref: ${this.refString}`;
         this.fileParserLogger.error(this.schemaPosition, errorMessage);
         throw new Error(errorMessage);
       }
@@ -14133,7 +14182,7 @@ function swaggerTypeFactory(api, schema2, schemaName, typeRegistry, logger, file
 }
 class SwaggerBaseOperation {
   constructor(operation, methodStr, swaggerTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
-    var _a, _b;
+    var _a, _b, _c;
     this.operation = operation;
     this.methodStr = methodStr;
     this.swaggerTypeFactory = swaggerTypeFactory2;
@@ -14145,7 +14194,12 @@ class SwaggerBaseOperation {
     this.defaults = endpoint.api.defaults;
     this.method = methodStr.toUpperCase();
     const jsonPath = `paths/${endpoint.path}/${methodStr}`;
-    this.position = ((_b = (_a = endpoint.api).getPosition) == null ? void 0 : _b.call(_a, jsonPath)) ?? { line: 0, column: 0 };
+    const defaultPosition = {
+      line: 0,
+      column: 0,
+      filePath: ((_a = endpoint.api.sourceUrl) == null ? void 0 : _a.pathname) ?? "Unknown File"
+    };
+    this.position = ((_c = (_b = endpoint.api).getPosition) == null ? void 0 : _c.call(_b, jsonPath)) ?? defaultPosition;
     const extensionsRaw = extractExtensions(operation);
     this.operationId = operation.operationId;
     this.operationSchemaBuilder = new OperationSchemaBuilder(
@@ -14192,10 +14246,14 @@ ${message}`);
       headers: {}
     };
     const parameters = this.operation.parameters || [];
-    for (const param of parameters) {
-      if (isReferenceObject(param)) continue;
+    for (let param of parameters) {
+      if (isReferenceObject(param)) {
+        param = this.endpoint.api.resolveRefTargetPath(
+          param.$ref
+        );
+      }
       const paramType = this.swaggerTypeFactory(
-        {},
+        this.endpoint.api,
         param.schema || { type: "string" },
         void 0,
         this.typeRegistry,
@@ -14224,12 +14282,17 @@ ${message}`);
       }
     }
     if (this.operation.requestBody) {
-      const requestBody = isReferenceObject(this.operation.requestBody) ? void 0 : this.operation.requestBody;
+      let requestBody = this.operation.requestBody;
+      if (isReferenceObject(requestBody)) {
+        requestBody = this.endpoint.api.resolveRefTargetPath(
+          requestBody.$ref
+        );
+      }
       if (requestBody == null ? void 0 : requestBody.content) {
         for (const [mediaType, content] of Object.entries(requestBody.content)) {
           if (content.schema) {
             const dataType = this.swaggerTypeFactory(
-              {},
+              this.endpoint.api,
               content.schema,
               void 0,
               this.typeRegistry,
@@ -14251,18 +14314,28 @@ ${message}`);
   buildResponses() {
     const responses = [];
     const opResponses = this.operation.responses || {};
-    for (const [statusCode, responseObj] of Object.entries(opResponses)) {
-      if (isReferenceObject(responseObj)) continue;
+    for (const [statusCode, opResponse] of Object.entries(opResponses)) {
+      let responseObj = opResponse;
+      if (isReferenceObject(responseObj)) {
+        responseObj = this.endpoint.api.resolveRefTargetPath(
+          responseObj.$ref
+        );
+      }
       const response = {
         statusCode,
         payloads: [],
         headers: {}
       };
       if (responseObj.headers) {
-        for (const [headerName, headerObj] of Object.entries(responseObj.headers)) {
-          if (isReferenceObject(headerObj)) continue;
+        for (const [headerName, headerValue] of Object.entries(responseObj.headers)) {
+          let headerObj = headerValue;
+          if (isReferenceObject(headerObj)) {
+            headerObj = this.endpoint.api.resolveRefTargetPath(
+              headerObj.$ref
+            );
+          }
           const headerType = this.swaggerTypeFactory(
-            {},
+            this.endpoint.api,
             headerObj.schema || { type: "string" },
             void 0,
             this.typeRegistry,
@@ -14280,7 +14353,7 @@ ${message}`);
         for (const [mediaType, content] of Object.entries(responseObj.content)) {
           if (content.schema) {
             const dataType = this.swaggerTypeFactory(
-              {},
+              this.endpoint.api,
               content.schema,
               void 0,
               this.typeRegistry,
@@ -14611,8 +14684,10 @@ class SwaggerBaseEndpoint {
     this.path = pathStr;
     this.uriParameters = {};
     const parameters = pathItem.parameters || [];
-    for (const param of parameters) {
-      if (isReferenceObject(param)) continue;
+    for (let param of parameters) {
+      if (isReferenceObject(param)) {
+        param = api.resolveRefTargetPath(param.$ref);
+      }
       if (param.in !== "path") continue;
       const paramType = swaggerTypeFactory2(
         api,
@@ -14687,46 +14762,42 @@ ${validationMessage}`);
 }
 function getSchemaPosition(subject, validationType) {
   if (validationType === ValidationType.Operation) {
-    return subject.position || { line: 0, column: 0 };
+    return subject.position || { line: 0, column: 0, filePath: "" };
   }
-  return subject.schemaPosition || { line: 0, column: 0 };
+  return subject.schemaPosition || { line: 0, column: 0, filePath: "" };
 }
-function formatMessage(messages, lineFormatter2, level = 0) {
-  const padding = Array(4 * level).fill(" ").join("");
+function formatMessage(messages, level = 0) {
+  const padding = "    ".repeat(level);
   return messages.reduce((result, message) => {
     const position = getSchemaPosition(message.subject, message.validationType);
-    return `${result}${padding}- ${lineFormatter2(position, message.message)}
-${formatMessage(message.subValidationMessages ?? [], lineFormatter2, level + 1)}`;
+    const formatted = lineFormatter(position, message.message, position.filePath);
+    const subMessages = formatMessage(message.subValidationMessages ?? [], level + 1);
+    return `${result}${padding}- ${formatted}
+${subMessages}`;
   }, "");
 }
 function isValidSwaggerAPI(api, fileParserLogger) {
-  const formatter = (pos, msg) => {
-    return lineFormatter(pos, msg, fileParserLogger.filePath);
-  };
+  const defaultFilePath = fileParserLogger.filePath;
   const apiValidator = buildApiValidatorFor(api);
   const result = apiValidator.validate(api);
   const isValid2 = result.isOk();
   const messages = isValid2 ? result.value : result.error;
-  for (const {
-    message,
-    subject,
-    severity,
-    validationType,
-    subValidationMessages: extraValidation
-  } of messages) {
-    let lineMessage = message;
-    if (extraValidation !== void 0) {
-      const formattedValidation = `${formatMessage(extraValidation, formatter, 1)}`;
-      lineMessage = `${lineMessage}
-${formattedValidation}`;
-    }
+  for (const { message, subject, severity, validationType, subValidationMessages } of messages) {
     const position = getSchemaPosition(subject, validationType);
+    let finalMessage = message;
+    if (subValidationMessages !== void 0 && subValidationMessages.length > 0) {
+      finalMessage += `
+${formatMessage(subValidationMessages, 1)}`;
+    }
+    if (position.filePath !== defaultFilePath) {
+      finalMessage = `[${position.filePath}:${position.line}:${position.column}] ${finalMessage}`;
+    }
     if (severity === ValidationSeverity.Error) {
-      fileParserLogger.error(position, lineMessage);
+      fileParserLogger.error(position, finalMessage);
     } else if (severity === ValidationSeverity.Warning) {
-      fileParserLogger.warn(position, lineMessage);
+      fileParserLogger.warn(position, finalMessage);
     } else if (severity === ValidationSeverity.Info) {
-      fileParserLogger.info(position, lineMessage);
+      fileParserLogger.info(position, finalMessage);
     }
   }
   return isValid2;
@@ -14753,12 +14824,13 @@ const oneStoreExtensionsSchema = z.object({
   }).strict()
 });
 class SwaggerAPI {
-  constructor(document, sourceUrl, services, fileParserLogger, positionMap) {
+  constructor(document, sourceUrl, services, fileParserLogger, positionMap, $refs) {
     this.document = document;
     this.sourceUrl = sourceUrl;
     this.services = services;
     this.fileParserLogger = fileParserLogger;
     this.positionMap = positionMap;
+    this.$refs = $refs;
     this.built = false;
     const urlPath = sourceUrl.pathname;
     this.defaultedNamespace = path.parse(urlPath).name;
@@ -14774,6 +14846,41 @@ class SwaggerAPI {
   getPosition(jsonPath) {
     return this.positionMap.get(jsonPath);
   }
+  /**
+   * Find the position of a $ref declaration by its target value.
+   * @param refValue - The $ref target string (e.g., "./schemas/User.yaml#/TypeThatDoesNotExist")
+   * @returns The position where the $ref is declared, if found
+   */
+  getRefPosition(refValue) {
+    const result = this.positionMap.findRefPosition(refValue);
+    return result == null ? void 0 : result.position;
+  }
+  /**
+   * Resolve a $ref target path with respect to the directory of the source.
+   * This is particularly necessary for relative paths since this.$refs.get() resolves
+   * paths relative to the root file and not the ref source file.
+   * @param refPath - The $ref target path (e.g., "./schemas/User.yaml#/User")
+   * @returns The path from where the $ref is declared (e.g, "file:///path/to/source/./schemas/User.yaml#/User")
+   */
+  resolveRefTargetPath(refTarget) {
+    var _a;
+    const hashIndex = refTarget.indexOf("#");
+    const refTargetFilePath = hashIndex === -1 ? refTarget : refTarget.substring(0, hashIndex);
+    let resolvedPath;
+    if (!refTargetFilePath) {
+      resolvedPath = refTarget;
+    } else if (/^(https?|file):\/\//.test(refTargetFilePath)) {
+      resolvedPath = refTargetFilePath;
+    } else {
+      const refSourceFilePath = (_a = this.positionMap.getRef(refTarget)) == null ? void 0 : _a.filePath;
+      if (!refSourceFilePath) {
+        throw new Error(`Failed to resolve $ref: ${refTarget}`);
+      }
+      const refSourceBasePath = path.dirname(refSourceFilePath);
+      resolvedPath = path.join(refSourceBasePath, refTarget);
+    }
+    return this.$refs.get(resolvedPath);
+  }
   build() {
     if (!this.built) {
       this.built = true;
@@ -14784,9 +14891,14 @@ class SwaggerAPI {
     }
   }
   buildEndpoints() {
-    const paths = this.document.paths || {};
-    this._endpoints = Object.entries(paths).map(([pathStr, pathItem]) => {
+    var _a;
+    const paths = ((_a = this.$refs.values()[this.sourceUrl.toString()]) == null ? void 0 : _a.paths) || {};
+    this._endpoints = Object.entries(paths).map(([pathStr, pathValue]) => {
+      let pathItem = pathValue;
       if (!pathItem) return void 0;
+      if (isReferenceObject(pathItem)) {
+        pathItem = this.resolveRefTargetPath(pathItem.$ref);
+      }
       return swaggerEndpointFactory(
         pathStr,
         pathItem,
@@ -14831,10 +14943,17 @@ servers:
     });
   }
   buildTypes() {
-    var _a;
     this.services.logger.debug("SwaggerAPI - Building the type registry");
     const typeRegistry = this.typeRegistry = new BaseTypeRegistry();
-    const schemas2 = ((_a = this.document.components) == null ? void 0 : _a.schemas) || {};
+    const schemas2 = Object.values(this.$refs.values()).reduce(
+      (acc, file) => {
+        var _a;
+        const componentSchemas = ((_a = file.components) == null ? void 0 : _a.schemas) ?? {};
+        const rootSchemas = extractRootLevelSchemas(file);
+        return { ...acc, ...componentSchemas, ...rootSchemas };
+      },
+      {}
+    );
     for (const [name, schema2] of Object.entries(schemas2)) {
       this.services.logger.debug(`SwaggerAPI - Building Swagger Type for ${name}`);
       const swaggerType = swaggerTypeFactory(
@@ -14924,6 +15043,8 @@ servers:
 class SourcePositionMap {
   constructor() {
     this.positions = /* @__PURE__ */ new Map();
+    this.fileUrls = /* @__PURE__ */ new Set();
+    this.refTargets = /* @__PURE__ */ new Map();
   }
   /**
    * Get the position for a given JSON path
@@ -14932,6 +15053,13 @@ class SourcePositionMap {
   get(jsonPath) {
     return this.positions.get(jsonPath);
   }
+  /**
+   * Get the position for a given $ref path
+   * @param refPath - The $ref path (e.g., "./schemas/User.yaml#/User")
+   */
+  getRef(refPath) {
+    return this.refTargets.get(refPath);
+  }
   /**
    * Set the position for a given JSON path
    */
@@ -14950,10 +15078,71 @@ class SourcePositionMap {
   keys() {
     return this.positions.keys();
   }
+  /**
+   * Get all entries as [jsonPath, position] pairs
+   */
+  entries() {
+    return this.positions.entries();
+  }
+  /**
+   * Get the number of files tracked in this map
+   */
+  get fileCount() {
+    return this.fileUrls.size;
+  }
+  /**
+   * Track a $ref target value and its position
+   */
+  setRefTarget(refValue, position) {
+    this.refTargets.set(refValue, position);
+  }
+  /**
+   * Find the position of a $ref that targets a file containing the given path,
+   * or an internal ref containing the given token.
+   */
+  findRefPosition(targetPath, token) {
+    const targetFileName = targetPath.split("/").pop() || targetPath;
+    for (const [refValue, position] of this.refTargets) {
+      if (refValue.includes(targetFileName)) {
+        return { position, refValue };
+      }
+      if (token && refValue.startsWith("#/") && refValue.includes(token)) {
+        return { position, refValue };
+      }
+    }
+  }
+  /**
+   * Merge positions from another map, setting filePath on each position.
+   * Used to aggregate positions from multiple files (e.g., external $refs).
+   * @param other - The source position map to merge from
+   * @param fileUrl - The file URL to associate with these positions
+   */
+  merge(other, fileUrl) {
+    const filePath = extractFilePath(fileUrl);
+    this.fileUrls.add(fileUrl);
+    for (const [jsonPath, position] of other.entries()) {
+      this.positions.set(jsonPath, {
+        ...position,
+        filePath
+      });
+    }
+    for (const [refValue, position] of other.refTargets) {
+      this.refTargets.set(refValue, { ...position, filePath });
+    }
+  }
+}
+function extractFilePath(fileUrl) {
+  try {
+    const url2 = new URL(fileUrl);
+    return url2.pathname;
+  } catch {
+    return fileUrl;
+  }
 }
-function buildSourcePositionMap(yamlContent) {
+function buildSourcePositionMap(yamlContent, fileUrl) {
   const positionMap = new SourcePositionMap();
   const lineCounter = new LineCounter();
+  const filePath = extractFilePath(fileUrl);
   const doc = parseDocument(yamlContent, { lineCounter });
   if (!doc.contents || !isMap(doc.contents)) {
     return positionMap;
@@ -14965,7 +15154,15 @@ function buildSourcePositionMap(yamlContent) {
         const range = pair.key.range;
         if (range) {
           const pos = lineCounter.linePos(range[0]);
-          positionMap.set(jsonPath, { line: pos.line, column: pos.col - 1 });
+          positionMap.set(jsonPath, { line: pos.line, column: pos.col - 1, filePath });
+          if (pair.key.value === "$ref" && pair.value && isScalar(pair.value)) {
+            const refValue = String(pair.value.value);
+            positionMap.setRefTarget(refValue, {
+              line: pos.line,
+              column: pos.col - 1,
+              filePath
+            });
+          }
         }
       }
     }
@@ -14988,6 +15185,9 @@ function buildJsonPath(pair, path2) {
   if (segments.length >= 3 && segments[0] === "components" && segments[1] === "schemas") {
     return segments.join("/");
   }
+  if (segments.length >= 1 && !["openapi", "info", "servers", "paths", "components", "x-onestore"].includes(segments[0])) {
+    return segments.join("/");
+  }
   return void 0;
 }
 const positionMapCache = /* @__PURE__ */ new Map();
@@ -14996,7 +15196,7 @@ const positionTrackingParser = {
   canParse: [".yaml", ".yml"],
   async parse(file) {
     const content = Buffer.isBuffer(file.data) ? file.data.toString() : file.data;
-    const positionMap = buildSourcePositionMap(content);
+    const positionMap = buildSourcePositionMap(content, file.url);
     positionMapCache.set(file.url, positionMap);
     return parse(content);
   }
@@ -15012,12 +15212,25 @@ const PARSER_OPTIONS = {
     // Still validate $ref resolution
   }
 };
+function findRefPositionInCache(targetPath, token) {
+  for (const positionMap of positionMapCache.values()) {
+    const result = positionMap.findRefPosition(targetPath, token);
+    if (result) {
+      return result;
+    }
+  }
+}
 async function parseSwaggerDocument(source, logger) {
   const sourceUrl = source.toString();
   try {
-    const api = await SwaggerParser.bundle(sourceUrl, PARSER_OPTIONS);
-    const positionMap = positionMapCache.get(sourceUrl) ?? new SourcePositionMap();
-    positionMapCache.delete(sourceUrl);
+    const parser = new SwaggerParser();
+    const api = await parser.parse(sourceUrl, PARSER_OPTIONS);
+    const $refs = await parser.resolve(sourceUrl, PARSER_OPTIONS);
+    const positionMap = new SourcePositionMap();
+    for (const [fileUrl, filePositionMap] of positionMapCache) {
+      positionMap.merge(filePositionMap, fileUrl);
+    }
+    positionMapCache.clear();
     if (!("openapi" in api) || !api.openapi.startsWith("3.")) {
       throw new Error(
         `Only OpenAPI 3.x documents are supported. Found version: ${api.openapi || api.swagger || "unknown"}`
@@ -15025,10 +15238,50 @@ async function parseSwaggerDocument(source, logger) {
     }
     return {
       document: api,
-      positionMap
+      positionMap,
+      $refs
     };
   } catch (error) {
-    positionMapCache.delete(sourceUrl);
+    if (error instanceof MissingPointerError) {
+      const missingFile = error.source;
+      const tokenMatch = error.message.match(/Token "([^"]+)"/);
+      const token = (tokenMatch == null ? void 0 : tokenMatch[1]) ?? "unknown";
+      const refInfo = findRefPositionInCache(missingFile, token);
+      const filename = missingFile.split("/").pop() ?? missingFile;
+      if (refInfo) {
+        const { position, refValue } = refInfo;
+        logger.error(
+          position,
+          `Cannot resolve reference '${refValue}': token '${token}' does not exist in '${filename}'`
+        );
+      } else {
+        logger.error(
+          { line: 0, column: 0 },
+          `Cannot resolve reference: token '${token}' does not exist in '${filename}'`
+        );
+      }
+      positionMapCache.clear();
+      throw error;
+    }
+    if (error instanceof ResolverError) {
+      const missingFile = error.source;
+      const refInfo = findRefPositionInCache(missingFile);
+      if (refInfo) {
+        const { position, refValue } = refInfo;
+        logger.error(
+          position,
+          `Cannot resolve external reference '${refValue}': file not found '${missingFile}'`
+        );
+      } else {
+        logger.error(
+          { line: 0, column: 0 },
+          `Cannot resolve reference '${missingFile}': file not found`
+        );
+      }
+      positionMapCache.clear();
+      throw error;
+    }
+    positionMapCache.clear();
     const message = error instanceof Error ? error.message : String(error);
     logger.error(
       { line: 0, column: 0 },
@@ -15038,8 +15291,8 @@ async function parseSwaggerDocument(source, logger) {
   }
 }
 async function parseUrl(source, services, fileParserLogger) {
-  const { document, positionMap } = await parseSwaggerDocument(source, fileParserLogger);
-  const api = new SwaggerAPI(document, source, services, fileParserLogger, positionMap);
+  const { document, positionMap, $refs } = await parseSwaggerDocument(source, fileParserLogger);
+  const api = new SwaggerAPI(document, source, services, fileParserLogger, positionMap, $refs);
   api.validate();
   return api;
 }