@conduit-client/model 3.9.0 → 3.10.0

package/dist/types/v1/parser/swagger/__tests__/source-position-map.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/parser/swagger/endpoints/swagger-operation.d.ts

@@ -1,4 +1,5 @@
 import { type LoggerService, type FileParserLogger } from '@conduit-client/utils';
+import type { Position } from '../source-position-map';
 import type { OpenAPIV3 } from 'openapi-types';
 import type { BaseAuraOperation, AuraOperationWithRequestBody, BaseOperation, HttpMethod, Request, Response, CacheStrategy, ConfigSchemaType, OperationType, ErrorStrategy, Binding, BaseHttpOperation, HttpOperationWithRequestBody, BaseGraphQLOperation } from '../../../api/endpoint';
 import type { SwaggerType, SwaggerTypeFactory } from '../types';
@@ -29,10 +30,7 @@ export declare abstract class SwaggerBaseOperation implements BaseOperation {
     protected operationSchemaBuilder: OperationSchemaBuilder;
     defaults: API['defaults'];
     serviceOverrides: ResolvedOperationServices;
-    position: {
-        line: number;
-        column: number;
-    };
+    position: Position;
     basePath: string;
     abstract readonly type: 'aura' | 'http';
     constructor(operation: OpenAPIV3.OperationObject, methodStr: string, swaggerTypeFactory: SwaggerTypeFactory, typeRegistry: TypeRegistry<SwaggerType>, logger: LoggerService, fileParserLogger: FileParserLogger, endpoint: SwaggerEndPoint, server: Server);

package/dist/types/v1/parser/swagger/source-position-map.d.ts

@@ -4,13 +4,17 @@
 export interface Position {
     line: number;
     column: number;
+    filePath: string;
 }
 /**
- * Maps JSON paths to their source positions in the YAML file.
+ * Maps JSON paths to their source positions in YAML files.
  * Used to provide accurate line/column information for validation errors.
+ * Supports both single-file and multi-file scenarios.
  */
 export declare class SourcePositionMap {
     private positions;
+    private fileUrls;
+    private refTargets;
     /**
      * Get the position for a given JSON path
      * @param jsonPath - The JSON path (e.g., "paths//users/get" or "components/schemas/User")
@@ -28,12 +32,40 @@ export declare class SourcePositionMap {
      * Get all stored paths
      */
     keys(): IterableIterator<string>;
+    /**
+     * Get all entries as [jsonPath, position] pairs
+     */
+    entries(): IterableIterator<[string, Position]>;
+    /**
+     * Get the number of files tracked in this map
+     */
+    get fileCount(): number;
+    /**
+     * Track a $ref target value and its position
+     */
+    setRefTarget(refValue: string, position: Position): void;
+    /**
+     * Find the position of a $ref that targets a file containing the given path,
+     * or an internal ref containing the given token.
+     */
+    findRefPosition(targetPath: string, token?: string): {
+        position: Position;
+        refValue: string;
+    } | undefined;
+    /**
+     * 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: SourcePositionMap, fileUrl: string): void;
 }
 /**
  * Builds a SourcePositionMap from YAML content by parsing it with the yaml package
  * which preserves source position information.
  *
  * @param yamlContent - The raw YAML content as a string
+ * @param fileUrl - The URL of the file being parsed
  * @returns A SourcePositionMap containing positions for operations and schemas
  */
-export declare function buildSourcePositionMap(yamlContent: string): SourcePositionMap;
+export declare function buildSourcePositionMap(yamlContent: string, fileUrl: string): SourcePositionMap;

package/dist/types/v1/parser/swagger/types/SwaggerBaseType.d.ts

@@ -1,3 +1,4 @@
+import type { Position } from '../source-position-map';
 import type { SwaggerTypeFactory } from './factory';
 import type { OpenAPIV3 } from 'openapi-types';
 import type { BaseType, Type, TypeExtensions, TypeRegistry } from '../../../types';
@@ -15,10 +16,7 @@ export declare abstract class SwaggerBaseType<T extends Type['type'], S extends
     resolved: boolean;
     abstract type: T;
     parsedExtensions: TypeExtensions;
-    schemaPosition: {
-        line: number;
-        column: number;
-    };
+    schemaPosition: Position;
     constructor(api: SwaggerAPI, schema: S, schemaName: string | undefined, typeRegistry: TypeRegistry<SwaggerType>, factory: SwaggerTypeFactory, logger: LoggerService, fileParserLogger: FileParserLogger, jsonPath?: string);
     resolve(): void;
     typeResolve(): void;

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() {
@@ -14133,7 +14140,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 +14152,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(
@@ -14687,46 +14699,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;
@@ -14924,6 +14932,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
@@ -14950,10 +14960,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 +15036,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 +15067,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 +15078,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 +15094,23 @@ 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 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"}`
@@ -15028,7 +15121,46 @@ async function parseSwaggerDocument(source, logger) {
       positionMap
     };
   } 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 },