@igniter-js/caller 0.1.4 → 0.1.51

package/dist/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var core = require('@igniter-js/core');
+var common = require('@igniter-js/common');
 var zod = require('zod');
 
 // src/errors/caller.error.ts
-var IgniterCallerError = class _IgniterCallerError extends core.IgniterError {
+var IgniterCallerError = class _IgniterCallerError extends common.IgniterError {
   /**
    * Creates a new typed caller error.
    *
@@ -505,6 +505,7 @@ var IgniterCallerRequestBuilder = class {
     this.eventEmitter = params.eventEmitter;
     this.schemas = params.schemas;
     this.schemaValidation = params.schemaValidation;
+    this.mock = params.mock;
   }
   /**
    * Sets the HTTP method for this request.
@@ -529,7 +530,7 @@ var IgniterCallerRequestBuilder = class {
   /**
    * Overrides the logger for this request chain.
    *
-   * @param logger - Logger implementation from `@igniter-js/core`.
+   * @param logger - Logger implementation from `@igniter-js/common`.
    */
   withLogger(logger) {
     this.logger = logger;
@@ -1026,6 +1027,11 @@ var IgniterCallerRequestBuilder = class {
         }
       }
     }
+    const mockResult = await this.executeMockRequest(url, safeUrl);
+    if (mockResult) {
+      clearTimeout(timeoutId);
+      return mockResult;
+    }
     try {
       const httpResponse = await fetch(url, {
         ...requestInit,
@@ -1346,6 +1352,297 @@ var IgniterCallerRequestBuilder = class {
       timeoutId
     };
   }
+  /**
+   * Normalizes a URL into a path for mock matching.
+   */
+  normalizeMockPath(url, baseURL) {
+    if (/^https?:\/\//i.test(url)) {
+      try {
+        return new URL(url).pathname;
+      } catch {
+        return url;
+      }
+    }
+    if (baseURL && /^https?:\/\//i.test(baseURL)) {
+      try {
+        const resolved = IgniterCallerUrlUtils.buildUrl({ url, baseURL });
+        return new URL(resolved).pathname;
+      } catch {
+        return url;
+      }
+    }
+    return url.startsWith("/") ? url : `/${url}`;
+  }
+  /**
+   * Resolves the final query object (merges GET/HEAD body into params).
+   */
+  getFinalQuery() {
+    const { method, body, params } = this.options;
+    if ((method === "GET" || method === "HEAD") && body && typeof body === "object") {
+      const bodyParams = {};
+      for (const [key, value] of Object.entries(body)) {
+        if (value !== void 0 && value !== null) {
+          bodyParams[key] = String(value);
+        }
+      }
+      return { ...bodyParams, ...params || {} };
+    }
+    return params || {};
+  }
+  /**
+   * Executes a mock handler when enabled and matched.
+   */
+  async executeMockRequest(url, safeUrl) {
+    if (!this.mock?.enabled) return null;
+    const path = this.normalizeMockPath(this.options.url, this.options.baseURL);
+    const method = this.options.method;
+    const resolved = this.mock.mock.resolve(path, method);
+    if (!resolved) return null;
+    const query = this.getFinalQuery();
+    const mockRequest = {
+      method,
+      path: resolved.path,
+      url,
+      safeUrl,
+      baseURL: this.options.baseURL,
+      headers: this.options.headers || {},
+      query,
+      params: resolved.params || {},
+      body: this.options.body,
+      timeoutMs: this.options.timeout,
+      cache: this.options.cache,
+      cacheKey: this.cacheKey,
+      staleTime: this.staleTime,
+      responseTypeSchema: this.responseTypeSchema
+    };
+    const response = await this.resolveMockResponse(
+      resolved.handler,
+      mockRequest
+    );
+    const delayMs = response.delayMs ?? this.mock?.delay;
+    if (delayMs && delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    const status = response.status;
+    const headers = new Headers(response.headers);
+    if (status >= 400) {
+      return {
+        data: void 0,
+        error: new IgniterCallerError({
+          code: "IGNITER_CALLER_MOCK_HTTP_ERROR",
+          operation: "execute",
+          message: response.errorMessage || `Mocked request failed with status ${status}`,
+          statusCode: status,
+          logger: this.logger,
+          metadata: {
+            method,
+            url
+          }
+        }),
+        status,
+        headers
+      };
+    }
+    let data = response.response;
+    if (this.schemas) {
+      const { schema: endpointSchema } = IgniterCallerSchemaUtils.findSchema(
+        this.schemas,
+        path,
+        method
+      );
+      const responseSchema = endpointSchema?.responses?.[status];
+      if (responseSchema) {
+        try {
+          data = await IgniterCallerSchemaUtils.validateResponse(
+            data,
+            responseSchema,
+            status,
+            this.schemaValidation,
+            { url: safeUrl, method },
+            this.logger
+          );
+        } catch (error) {
+          const err = error;
+          this.telemetry?.emit(
+            "igniter.caller.validation.response.error",
+            {
+              level: "error",
+              attributes: {
+                "ctx.request.method": method,
+                "ctx.request.url": safeUrl,
+                "ctx.validation.type": "response",
+                "ctx.validation.error": err.message,
+                "ctx.response.status": status
+              }
+            }
+          );
+          this.logger?.error("IgniterCaller.response.validation failed", {
+            method,
+            url: safeUrl,
+            status,
+            error: err
+          });
+          return {
+            data: void 0,
+            error: err,
+            status,
+            headers
+          };
+        }
+      }
+    }
+    if (this.responseTypeSchema) {
+      if ("safeParse" in this.responseTypeSchema) {
+        const zodSchema = this.responseTypeSchema;
+        const result = zodSchema.safeParse(data);
+        if (!result.success) {
+          const err = new IgniterCallerError({
+            code: "IGNITER_CALLER_RESPONSE_VALIDATION_FAILED",
+            operation: "parseResponse",
+            message: `Response validation failed: ${result.error.message}`,
+            logger: this.logger,
+            statusCode: status,
+            metadata: {
+              method,
+              url
+            },
+            cause: result.error
+          });
+          this.telemetry?.emit(
+            "igniter.caller.validation.response.error",
+            {
+              level: "error",
+              attributes: {
+                "ctx.request.method": method,
+                "ctx.request.url": safeUrl,
+                "ctx.validation.type": "response",
+                "ctx.validation.error": err.message,
+                "ctx.response.status": status
+              }
+            }
+          );
+          this.logger?.error("IgniterCaller.response.validation failed", {
+            method,
+            url: safeUrl,
+            status,
+            error: err
+          });
+          return {
+            data: void 0,
+            error: err,
+            status,
+            headers
+          };
+        }
+        data = result.data;
+      } else if ("~standard" in this.responseTypeSchema) {
+        try {
+          const standardSchema = this.responseTypeSchema;
+          const result = await standardSchema["~standard"].validate(data);
+          if (result.issues) {
+            const err = new IgniterCallerError({
+              code: "IGNITER_CALLER_RESPONSE_VALIDATION_FAILED",
+              operation: "parseResponse",
+              message: `Response validation failed`,
+              logger: this.logger,
+              statusCode: status,
+              metadata: {
+                method,
+                url,
+                issues: result.issues
+              }
+            });
+            this.telemetry?.emit(
+              "igniter.caller.validation.response.error",
+              {
+                level: "error",
+                attributes: {
+                  "ctx.request.method": method,
+                  "ctx.request.url": safeUrl,
+                  "ctx.validation.type": "response",
+                  "ctx.validation.error": err.message,
+                  "ctx.response.status": status
+                }
+              }
+            );
+            this.logger?.error("IgniterCaller.response.validation failed", {
+              method,
+              url: safeUrl,
+              status,
+              error: err
+            });
+            return {
+              data: void 0,
+              error: err,
+              status,
+              headers
+            };
+          }
+          data = result.value;
+        } catch (error) {
+          const err = error;
+          this.telemetry?.emit(
+            "igniter.caller.validation.response.error",
+            {
+              level: "error",
+              attributes: {
+                "ctx.request.method": method,
+                "ctx.request.url": safeUrl,
+                "ctx.validation.type": "response",
+                "ctx.validation.error": err.message,
+                "ctx.response.status": status
+              }
+            }
+          );
+          this.logger?.error("IgniterCaller.response.validation failed", {
+            method,
+            url: safeUrl,
+            status,
+            error: err
+          });
+          return {
+            data: void 0,
+            error: err,
+            status,
+            headers
+          };
+        }
+      }
+    }
+    let responseResult = {
+      data,
+      error: void 0,
+      status,
+      headers
+    };
+    if (this.responseInterceptors && this.responseInterceptors.length > 0) {
+      for (const interceptor of this.responseInterceptors) {
+        responseResult = await interceptor(responseResult);
+      }
+    }
+    return responseResult;
+  }
+  /**
+   * Normalizes a mock handler result into a response payload with status.
+   */
+  async resolveMockResponse(handler, request) {
+    const result = typeof handler === "function" ? await handler(request) : handler;
+    const hasStatus = typeof result.status === "number";
+    if (hasStatus) {
+      return result;
+    }
+    const schemas = this.schemas;
+    const schemaMatch = schemas ? IgniterCallerSchemaUtils.findSchema(
+      schemas,
+      request.path,
+      request.method
+    ).schema : void 0;
+    const fallbackStatus = schemaMatch?.responses?.[200] ? 200 : schemaMatch?.responses?.[201] ? 201 : 200;
+    return {
+      ...result,
+      status: fallbackStatus
+    };
+  }
   /**
    * Emits event for this response using injected emitter.
    */
@@ -1512,6 +1809,7 @@ var _IgniterCallerManager = class _IgniterCallerManager {
     this.responseInterceptors = opts?.responseInterceptors;
     this.schemas = opts?.schemas;
     this.schemaValidation = opts?.schemaValidation;
+    this.mock = opts?.mock;
   }
   /**
    * Creates common request builder params.
@@ -1529,7 +1827,8 @@ var _IgniterCallerManager = class _IgniterCallerManager {
         await _IgniterCallerManager.emitEvent(url, method, result);
       },
       schemas: this.schemas,
-      schemaValidation: this.schemaValidation
+      schemaValidation: this.schemaValidation,
+      mock: this.mock
     };
   }
   get(url) {
@@ -1735,6 +2034,45 @@ var _IgniterCallerManager = class _IgniterCallerManager {
 _IgniterCallerManager.events = new IgniterCallerEvents();
 var IgniterCallerManager = _IgniterCallerManager;
 
+// src/core/mock.ts
+var IgniterCallerMockManager = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Resolves a mock handler for a path+method pair.
+   *
+   * @param path - Request path (normalized).
+   * @param method - HTTP method.
+   * @returns Resolved handler info or null when no match is found.
+   */
+  resolve(path, method) {
+    const direct = this.registry[path]?.[method];
+    if (direct) {
+      return {
+        handler: direct,
+        params: {},
+        path,
+        method
+      };
+    }
+    for (const [registeredPath, methods] of Object.entries(this.registry)) {
+      if (!methods) continue;
+      const match = IgniterCallerSchemaUtils.matchPath(path, registeredPath);
+      if (!match.matched) continue;
+      const handler = methods[method];
+      if (!handler) continue;
+      return {
+        handler,
+        params: match.params || {},
+        path: registeredPath,
+        method
+      };
+    }
+    return null;
+  }
+};
+
 // src/builders/main.builder.ts
 var IgniterCallerBuilder = class _IgniterCallerBuilder {
   constructor(state) {
@@ -1775,7 +2113,7 @@ var IgniterCallerBuilder = class _IgniterCallerBuilder {
   /**
    * Attaches a logger instance.
    *
-   * @param logger - Logger implementation from `@igniter-js/core`.
+   * @param logger - Logger implementation from `@igniter-js/common`.
    */
   withLogger(logger) {
     return new _IgniterCallerBuilder({ ...this.state, logger });
@@ -1897,6 +2235,16 @@ var IgniterCallerBuilder = class _IgniterCallerBuilder {
   withTelemetry(telemetry) {
     return new _IgniterCallerBuilder({ ...this.state, telemetry });
   }
+  /**
+   * Enables request mocking using a mock registry.
+   *
+   * When enabled, matching requests are routed to the mock handlers instead of fetch.
+   *
+   * @param config - Mock configuration with registry and enable flag.
+   */
+  withMock(config) {
+    return new _IgniterCallerBuilder({ ...this.state, mock: config });
+  }
   /**
    * Builds the `IgniterCaller` instance.
    *
@@ -1914,7 +2262,8 @@ var IgniterCallerBuilder = class _IgniterCallerBuilder {
       requestInterceptors: this.state.requestInterceptors,
       responseInterceptors: this.state.responseInterceptors,
       schemas: this.state.schemas,
-      schemaValidation: this.state.schemaValidation
+      schemaValidation: this.state.schemaValidation,
+      mock: this.state.mock
     });
     this.state.logger?.info("IgniterCaller initialized", {
       baseURL: this.state.baseURL,
@@ -2154,6 +2503,54 @@ function ensureValidSchemaKey(key) {
   }
 }
 
+// src/builders/mock.builder.ts
+var IgniterCallerMockBuilder = class _IgniterCallerMockBuilder {
+  constructor(state) {
+    this.state = state;
+  }
+  /**
+   * Creates a new mock builder.
+   */
+  static create() {
+    return new _IgniterCallerMockBuilder({ registry: {} });
+  }
+  /**
+   * Sets schemas to enable typed mock definitions.
+   *
+   * @param _schemas - Schema map or build result.
+   */
+  withSchemas(_schemas) {
+    return new _IgniterCallerMockBuilder({
+      registry: this.state.registry
+    });
+  }
+  /**
+   * Registers mock handlers for a path.
+   *
+   * @param path - Schema path.
+   * @param handlers - Method handlers or static responses.
+   */
+  mock(path, handlers) {
+    const registry = {
+      ...this.state.registry,
+      [path]: {
+        ...this.state.registry[path] || {},
+        ...handlers
+      }
+    };
+    return new _IgniterCallerMockBuilder({ registry });
+  }
+  /**
+   * Builds a mock manager instance.
+   */
+  build() {
+    return new IgniterCallerMockManager(this.state.registry);
+  }
+};
+var IgniterCallerMock = {
+  create: IgniterCallerMockBuilder.create
+};
+
 // src/adapters/mock.adapter.ts
 var MockCallerStoreAdapter = class _MockCallerStoreAdapter {
   constructor() {
@@ -2241,7 +2638,7 @@ var MockCallerStoreAdapter = class _MockCallerStoreAdapter {
 };
 
 // src/utils/testing.ts
-var IgniterCallerMock = class {
+var IgniterCallerHttpMock = class {
   /**
    * Creates a successful mock response.
    *
@@ -2300,8 +2697,11 @@ exports.IgniterCallerBuilder = IgniterCallerBuilder;
 exports.IgniterCallerCacheUtils = IgniterCallerCacheUtils;
 exports.IgniterCallerError = IgniterCallerError;
 exports.IgniterCallerEvents = IgniterCallerEvents;
+exports.IgniterCallerHttpMock = IgniterCallerHttpMock;
 exports.IgniterCallerManager = IgniterCallerManager;
 exports.IgniterCallerMock = IgniterCallerMock;
+exports.IgniterCallerMockBuilder = IgniterCallerMockBuilder;
+exports.IgniterCallerMockManager = IgniterCallerMockManager;
 exports.IgniterCallerRequestBuilder = IgniterCallerRequestBuilder;
 exports.IgniterCallerSchema = IgniterCallerSchema;
 exports.IgniterCallerSchemaPathBuilder = IgniterCallerSchemaPathBuilder;