@adatechnology/http-client 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,11 +1,787 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTP_AXIOS_CONNECTION = exports.HTTP_AXIOS_PROVIDER = exports.HTTP_PROVIDER = exports.HttpImplementationAxiosModule = exports.HttpModule = void 0;
-var http_module_1 = require("./http.module");
-Object.defineProperty(exports, "HttpModule", { enumerable: true, get: function () { return http_module_1.HttpModule; } });
-var axios_http_module_1 = require("./implementations/axios/axios.http.module");
-Object.defineProperty(exports, "HttpImplementationAxiosModule", { enumerable: true, get: function () { return axios_http_module_1.HttpImplementationAxiosModule; } });
-var http_token_1 = require("./http.token");
-Object.defineProperty(exports, "HTTP_PROVIDER", { enumerable: true, get: function () { return http_token_1.HTTP_PROVIDER; } });
-Object.defineProperty(exports, "HTTP_AXIOS_PROVIDER", { enumerable: true, get: function () { return http_token_1.HTTP_AXIOS_PROVIDER; } });
-Object.defineProperty(exports, "HTTP_AXIOS_CONNECTION", { enumerable: true, get: function () { return http_token_1.HTTP_AXIOS_CONNECTION; } });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/errors/error-mapper.service.ts
+var error_mapper_service_exports = {};
+__export(error_mapper_service_exports, {
+  ErrorMapperService: () => ErrorMapperService
+});
+var ErrorMapperService;
+var init_error_mapper_service = __esm({
+  "src/errors/error-mapper.service.ts"() {
+    ErrorMapperService = class {
+      mapUpstreamError(err) {
+        var _a;
+        if (err && err.status && err.message) return err;
+        try {
+          const anyErr = err;
+          const context = {};
+          if (anyErr == null ? void 0 : anyErr.config) {
+            context.url = anyErr.config.url || anyErr.config.baseURL;
+            context.method = anyErr.config.method;
+          }
+          if (anyErr == null ? void 0 : anyErr.stack) {
+            const frames = this.parseStack(anyErr.stack);
+            if (frames.length) {
+              context.stack = frames;
+              const origin = frames.find((f) => !this.isInternalFrame(f.file));
+              if (origin) context.origin = origin;
+            }
+          }
+          if (anyErr == null ? void 0 : anyErr.response) {
+            const status = anyErr.response.status || 502;
+            const message = ((_a = anyErr.response.data) == null ? void 0 : _a.message) || anyErr.message || "Upstream error";
+            return { message, status, code: anyErr.code, context };
+          }
+          if (anyErr == null ? void 0 : anyErr.request) {
+            return { message: "No response from upstream service", status: 502, code: anyErr.code, context };
+          }
+          return { message: anyErr && anyErr.message || "Unexpected error", status: 500, code: anyErr == null ? void 0 : anyErr.code, context };
+        } catch (e) {
+          return { message: "Error mapping failure", status: 500, code: void 0, context: { original: String(err) } };
+        }
+      }
+      parseStack(stack) {
+        const lines = stack.split("\n").map((l) => l.trim()).filter(Boolean);
+        const frames = [];
+        const re = /^at\s+(?:(.*?)\s+\()?(.*?):(\d+):(\d+)\)?$/;
+        for (const line of lines) {
+          const m = re.exec(line);
+          if (m) {
+            const fn = m[1] || void 0;
+            const file = m[2];
+            const lineNum = parseInt(m[3], 10);
+            const colNum = parseInt(m[4], 10);
+            frames.push({ fn, file, line: lineNum, column: colNum });
+          }
+        }
+        return frames;
+      }
+      isInternalFrame(file) {
+        if (!file) return false;
+        return /node_modules|internal|axios/.test(file);
+      }
+    };
+  }
+});
+
+// src/errors/base-app-error.ts
+var BaseAppError;
+var init_base_app_error = __esm({
+  "src/errors/base-app-error.ts"() {
+    BaseAppError = class extends Error {
+      code;
+      status;
+      context;
+      constructor(message, status, code, context) {
+        super(message);
+        this.name = new.target.name;
+        this.status = status;
+        this.code = code;
+        this.context = context;
+        if (typeof Error.captureStackTrace === "function") {
+          Error.captureStackTrace(this, new.target);
+        }
+      }
+    };
+  }
+});
+
+// src/errors/http-client-error.ts
+var http_client_error_exports = {};
+__export(http_client_error_exports, {
+  HttpClientError: () => HttpClientError
+});
+var HttpClientError;
+var init_http_client_error = __esm({
+  "src/errors/http-client-error.ts"() {
+    init_base_app_error();
+    HttpClientError = class extends BaseAppError {
+      constructor(message, status, code, context) {
+        super(message, status ?? 502, code, { service: "@adatechnology/http-client", ...context || {} });
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HTTP_AXIOS_CONNECTION: () => HTTP_AXIOS_CONNECTION,
+  HTTP_AXIOS_PROVIDER: () => HTTP_AXIOS_PROVIDER,
+  HTTP_PROVIDER: () => HTTP_PROVIDER,
+  HttpImplementationAxiosModule: () => HttpImplementationAxiosModule,
+  HttpModule: () => HttpModule
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http.module.ts
+var import_common3 = require("@nestjs/common");
+
+// src/http.provider.ts
+var import_common = require("@nestjs/common");
+
+// src/http.token.ts
+var HTTP_AXIOS_CONNECTION = "HTTP_AXIOS_CONNECTION";
+var HTTP_AXIOS_PROVIDER = "HTTP_AXIOS_PROVIDER";
+var HTTP_PROVIDER = "HTTP_PROVIDER";
+
+// src/http.provider.ts
+var HttpProvider = class {
+  constructor(axiosHttpProvider) {
+    this.axiosHttpProvider = axiosHttpProvider;
+  }
+  /**
+   * Expose underlying axios instance when available from the axios provider implementation.
+   * This is intentionally typed as unknown/any to avoid leaking implementation details.
+   */
+  getAxiosInstance() {
+    try {
+      const provider = this.axiosHttpProvider;
+      return (provider == null ? void 0 : provider.axiosInstance) ?? (provider == null ? void 0 : provider.instance) ?? void 0;
+    } catch (e) {
+      return void 0;
+    }
+  }
+  async get(url, config) {
+    return this.axiosHttpProvider.get(url, config);
+  }
+  get$(url, config) {
+    return this.axiosHttpProvider.get$(url, config);
+  }
+  async post(url, data, config) {
+    return this.axiosHttpProvider.post(url, data, config);
+  }
+  post$(url, data, config) {
+    return this.axiosHttpProvider.post$(url, data, config);
+  }
+  async put(url, data, config) {
+    return this.axiosHttpProvider.put(url, data, config);
+  }
+  put$(url, data, config) {
+    return this.axiosHttpProvider.put$(url, data, config);
+  }
+  async patch(url, data, config) {
+    return this.axiosHttpProvider.patch(url, data, config);
+  }
+  patch$(url, data, config) {
+    return this.axiosHttpProvider.patch$(url, data, config);
+  }
+  async delete(url, config) {
+    return this.axiosHttpProvider.delete(url, config);
+  }
+  delete$(url, config) {
+    return this.axiosHttpProvider.delete$(url, config);
+  }
+  async head(url, config) {
+    return this.axiosHttpProvider.head(url, config);
+  }
+  head$(url, config) {
+    return this.axiosHttpProvider.head$(url, config);
+  }
+  async options(url, config) {
+    return this.axiosHttpProvider.options(url, config);
+  }
+  options$(url, config) {
+    return this.axiosHttpProvider.options$(url, config);
+  }
+  async request(config) {
+    return this.axiosHttpProvider.request(config);
+  }
+  request$(config) {
+    return this.axiosHttpProvider.request$(config);
+  }
+  setGlobalHeader(key, value) {
+    this.axiosHttpProvider.setGlobalHeader(key, value);
+  }
+  removeGlobalHeader(key) {
+    this.axiosHttpProvider.removeGlobalHeader(key);
+  }
+  getGlobalHeaders() {
+    return this.axiosHttpProvider.getGlobalHeaders();
+  }
+  setBaseUrl(baseUrl) {
+    this.axiosHttpProvider.setBaseUrl(baseUrl);
+  }
+  getBaseUrl() {
+    return this.axiosHttpProvider.getBaseUrl();
+  }
+  setDefaultTimeout(timeout) {
+    this.axiosHttpProvider.setDefaultTimeout(timeout);
+  }
+  addErrorInterceptor(interceptor) {
+    return this.axiosHttpProvider.addErrorInterceptor(interceptor);
+  }
+  removeErrorInterceptor(id) {
+    this.axiosHttpProvider.removeErrorInterceptor(id);
+  }
+  clearCache(key) {
+    this.axiosHttpProvider.clearCache(key);
+  }
+  setAuthToken(token, type) {
+    this.axiosHttpProvider.setAuthToken(token, type);
+  }
+  clearAuthToken() {
+    this.axiosHttpProvider.clearAuthToken();
+  }
+  addRequestInterceptor(onFulfilled, onRejected) {
+    return this.axiosHttpProvider.addRequestInterceptor(
+      onFulfilled,
+      onRejected
+    );
+  }
+  removeRequestInterceptor(id) {
+    this.axiosHttpProvider.removeRequestInterceptor(id);
+  }
+  addResponseInterceptor(onFulfilled, onRejected) {
+    return this.axiosHttpProvider.addResponseInterceptor(
+      onFulfilled,
+      onRejected
+    );
+  }
+  removeResponseInterceptor(id) {
+    this.axiosHttpProvider.removeResponseInterceptor(id);
+  }
+};
+HttpProvider = __decorateClass([
+  (0, import_common.Injectable)(),
+  __decorateParam(0, (0, import_common.Inject)(HTTP_AXIOS_PROVIDER))
+], HttpProvider);
+
+// src/implementations/axios/axios.http.module.ts
+var import_common2 = require("@nestjs/common");
+var import_axios2 = __toESM(require("axios"));
+
+// src/implementations/axios/axios.http.provider.ts
+var import_axios = __toESM(require("axios"));
+var import_rxjs = require("rxjs");
+var AxiosHttpProvider = class _AxiosHttpProvider {
+  axiosInstance;
+  errorInterceptors = /* @__PURE__ */ new Map();
+  nextErrorInterceptorId = 0;
+  requestInterceptorIds = /* @__PURE__ */ new Set();
+  responseInterceptorIds = /* @__PURE__ */ new Set();
+  cache = /* @__PURE__ */ new Map();
+  cacheCleanupInterval;
+  constructor(axiosInstance) {
+    this.axiosInstance = axiosInstance || import_axios.default.create();
+    this.startCacheCleanup();
+  }
+  /**
+   * Starts automatic cache cleanup
+   */
+  startCacheCleanup() {
+    this.cacheCleanupInterval = setInterval(() => {
+      this.cleanupExpiredCache();
+    }, 3e5);
+  }
+  /**
+   * Stops automatic cache cleanup
+   */
+  stopCacheCleanup() {
+    if (this.cacheCleanupInterval) {
+      clearInterval(this.cacheCleanupInterval);
+      this.cacheCleanupInterval = void 0;
+    }
+  }
+  /**
+   * Cleans up expired cache entries
+   */
+  cleanupExpiredCache() {
+    const now = Date.now();
+    const keysToDelete = [];
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.ttl) {
+        keysToDelete.push(key);
+      }
+    }
+    keysToDelete.forEach((key) => this.cache.delete(key));
+  }
+  /**
+   * Generates a cache key from URL and config
+   */
+  generateCacheKey(url, config) {
+    const params = (config == null ? void 0 : config.params) ? JSON.stringify(config.params) : "";
+    return `${url}${params}`;
+  }
+  /**
+   * Gets cached data if valid
+   */
+  getCached(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * Sets data in cache
+   */
+  setCache(key, data, ttl = 3e5) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+  /**
+   * Clears cache for a specific key or all cache
+   */
+  clearCache(key) {
+    if (key) {
+      this.cache.delete(key);
+    } else {
+      this.cache.clear();
+    }
+  }
+  /**
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+  /**
+   * Sets a global header that will be included in all requests.
+   */
+  setGlobalHeader(key, value) {
+    this.axiosInstance.defaults.headers.common[key] = value;
+  }
+  /**
+   * Removes a global header.
+   */
+  removeGlobalHeader(key) {
+    delete this.axiosInstance.defaults.headers.common[key];
+  }
+  /**
+   * Gets all global headers currently set.
+   */
+  getGlobalHeaders() {
+    return { ...this.axiosInstance.defaults.headers.common };
+  }
+  /**
+   * Sets the base URL for all requests.
+   */
+  setBaseUrl(baseUrl) {
+    this.axiosInstance.defaults.baseURL = baseUrl;
+  }
+  /**
+   * Gets the current base URL.
+   */
+  getBaseUrl() {
+    return this.axiosInstance.defaults.baseURL || "";
+  }
+  /**
+   * Sets the default timeout for all requests.
+   */
+  setDefaultTimeout(timeout) {
+    this.axiosInstance.defaults.timeout = timeout;
+  }
+  /**
+   * Adds an error interceptor for handling errors globally.
+   */
+  addErrorInterceptor(interceptor) {
+    const id = this.nextErrorInterceptorId++;
+    this.errorInterceptors.set(id, interceptor);
+    return id;
+  }
+  /**
+   * Adds a request interceptor to the underlying Axios instance.
+   */
+  addRequestInterceptor(onFulfilled, onRejected) {
+    const id = this.axiosInstance.interceptors.request.use(
+      onFulfilled,
+      onRejected
+    );
+    this.requestInterceptorIds.add(id);
+    return id;
+  }
+  /**
+   * Removes a request interceptor by id.
+   */
+  removeRequestInterceptor(id) {
+    this.axiosInstance.interceptors.request.eject(id);
+    this.requestInterceptorIds.delete(id);
+  }
+  /**
+   * Adds a response interceptor to the underlying Axios instance.
+   */
+  addResponseInterceptor(onFulfilled, onRejected) {
+    const id = this.axiosInstance.interceptors.response.use(
+      onFulfilled,
+      onRejected
+    );
+    this.responseInterceptorIds.add(id);
+    return id;
+  }
+  /**
+   * Removes a response interceptor by id.
+   */
+  removeResponseInterceptor(id) {
+    this.axiosInstance.interceptors.response.eject(id);
+    this.responseInterceptorIds.delete(id);
+  }
+  /**
+   * Removes an error interceptor by its ID.
+   */
+  removeErrorInterceptor(id) {
+    this.errorInterceptors.delete(id);
+  }
+  /**
+   * Performs a GET request to the specified URL.
+   */
+  async get(url, config) {
+    const cacheKey = this.generateCacheKey(url, config);
+    const cached = this.getCached(cacheKey);
+    if (cached) {
+      return {
+        data: cached,
+        status: 200,
+        statusText: "OK",
+        headers: {},
+        config: config || { url }
+      };
+    }
+    return this.wrapWithErrorInterceptors(
+      () => this.performGet(url, config, cacheKey)
+    );
+  }
+  /**
+   * Internal method to perform the actual GET request.
+   */
+  async performGet(url, config, cacheKey) {
+    const response = await this.axiosInstance.get(url, config);
+    const transformed = this.transformResponse(response);
+    if (cacheKey && (config == null ? void 0 : config.cache) !== false) {
+      this.setCache(cacheKey, transformed.data, config == null ? void 0 : config.cacheTtl);
+    }
+    return transformed;
+  }
+  /**
+   * Performs a GET request and returns an Observable.
+   */
+  get$(url, config) {
+    return (0, import_rxjs.from)(this.get(url, config));
+  }
+  /**
+   * Performs a POST request.
+   */
+  async post(url, data, config) {
+    return this.wrapWithErrorInterceptors(
+      () => this.performPost(url, data, config)
+    );
+  }
+  /**
+   * Internal method to perform the actual POST request.
+   */
+  async performPost(url, data, config) {
+    const response = await this.axiosInstance.post(url, data, config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs a POST request and returns an Observable.
+   */
+  post$(url, data, config) {
+    return (0, import_rxjs.from)(this.post(url, data, config));
+  }
+  /**
+   * Performs a PUT request.
+   */
+  async put(url, data, config) {
+    return this.wrapWithErrorInterceptors(
+      () => this.performPut(url, data, config)
+    );
+  }
+  /**
+   * Internal method to perform the actual PUT request.
+   */
+  async performPut(url, data, config) {
+    const response = await this.axiosInstance.put(url, data, config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs a PUT request and returns an Observable.
+   */
+  put$(url, data, config) {
+    return (0, import_rxjs.from)(this.put(url, data, config));
+  }
+  /**
+   * Performs a PATCH request.
+   */
+  async patch(url, data, config) {
+    return this.wrapWithErrorInterceptors(
+      () => this.performPatch(url, data, config)
+    );
+  }
+  /**
+   * Internal method to perform the actual PATCH request.
+   */
+  async performPatch(url, data, config) {
+    const response = await this.axiosInstance.patch(url, data, config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs a PATCH request and returns an Observable.
+   */
+  patch$(url, data, config) {
+    return (0, import_rxjs.from)(this.patch(url, data, config));
+  }
+  /**
+   * Performs a DELETE request.
+   */
+  async delete(url, config) {
+    return this.wrapWithErrorInterceptors(
+      () => this.performDelete(url, config)
+    );
+  }
+  /**
+   * Internal method to perform the actual DELETE request.
+   */
+  async performDelete(url, config) {
+    const response = await this.axiosInstance.delete(url, config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs a DELETE request and returns an Observable.
+   */
+  delete$(url, config) {
+    return (0, import_rxjs.from)(this.delete(url, config));
+  }
+  /**
+   * Performs a HEAD request.
+   */
+  async head(url, config) {
+    return this.wrapWithErrorInterceptors(
+      () => this.performHead(url, config)
+    );
+  }
+  /**
+   * Internal method to perform the actual HEAD request.
+   */
+  async performHead(url, config) {
+    const response = await this.axiosInstance.head(url, config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs a HEAD request and returns an Observable.
+   */
+  head$(url, config) {
+    return (0, import_rxjs.from)(this.head(url, config));
+  }
+  /**
+   * Performs an OPTIONS request.
+   */
+  async options(url, config) {
+    return this.wrapWithErrorInterceptors(
+      () => this.performOptions(url, config)
+    );
+  }
+  /**
+   * Internal method to perform the actual OPTIONS request.
+   */
+  async performOptions(url, config) {
+    const response = await this.axiosInstance.options(url, config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs an OPTIONS request and returns an Observable.
+   */
+  options$(url, config) {
+    return (0, import_rxjs.from)(this.options(url, config));
+  }
+  /**
+   * Performs a custom HTTP request.
+   */
+  async request(config) {
+    return this.wrapWithErrorInterceptors(() => this.performRequest(config));
+  }
+  /**
+   * Internal method to perform the actual custom request.
+   */
+  async performRequest(config) {
+    const response = await this.axiosInstance.request(config);
+    return this.transformResponse(response);
+  }
+  /**
+   * Performs a custom HTTP request and returns an Observable.
+   */
+  request$(config) {
+    return (0, import_rxjs.from)(this.request(config));
+  }
+  /**
+   * Sets the authorization token for requests.
+   */
+  setAuthToken(token, type = "Bearer") {
+    this.axiosInstance.defaults.headers.common["Authorization"] = `${type} ${token}`;
+    try {
+      const masked = _AxiosHttpProvider.maskToken(token);
+      console.debug(`[AxiosHttpProvider] setAuthToken ${type} ${masked}`);
+    } catch (err) {
+    }
+  }
+  /**
+   * Clears the authorization token.
+   */
+  clearAuthToken() {
+    delete this.axiosInstance.defaults.headers.common["Authorization"];
+  }
+  /**
+   * Processes an error through all registered error interceptors.
+   */
+  async processErrorInterceptors(error) {
+    let processedError = error;
+    for (const interceptor of this.errorInterceptors.values()) {
+      try {
+        processedError = await interceptor(processedError);
+      } catch (interceptorError) {
+        console.warn("Error interceptor failed:", interceptorError);
+      }
+    }
+    return processedError;
+  }
+  /**
+   * Returns a masked version of the token showing only the initial characters.
+   */
+  static maskToken(token, visibleChars = 8) {
+    if (!token || typeof token !== "string") return "";
+    return token.length <= visibleChars ? token : `${token.slice(0, visibleChars)}...`;
+  }
+  /**
+   * Wraps a promise-returning HTTP method with error interceptor processing.
+   */
+  async wrapWithErrorInterceptors(method) {
+    try {
+      return await method();
+    } catch (error) {
+      const processedError = await this.processErrorInterceptors(error);
+      try {
+        const { ErrorMapperService: ErrorMapperService2 } = (init_error_mapper_service(), __toCommonJS(error_mapper_service_exports));
+        const { HttpClientError: HttpClientError2 } = (init_http_client_error(), __toCommonJS(http_client_error_exports));
+        const mapper = new ErrorMapperService2();
+        const mapped = mapper.mapUpstreamError(processedError);
+        throw new HttpClientError2(mapped.message, mapped.status, mapped.code, mapped.context);
+      } catch (mapErr) {
+        const { HttpClientError: HttpClientError2 } = (init_http_client_error(), __toCommonJS(http_client_error_exports));
+        const fallback = new HttpClientError2(
+          processedError && processedError.message || "HTTP client error",
+          processedError && processedError.status || 502,
+          processedError && processedError.code || void 0,
+          { original: String(processedError) }
+        );
+        throw fallback;
+      }
+    }
+  }
+  /**
+   * Transforms an Axios response to the standardized HTTP response format.
+   */
+  transformResponse(response) {
+    return {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      config: response.config
+    };
+  }
+};
+
+// src/implementations/axios/axios.http.module.ts
+var HttpImplementationAxiosModule = class {
+  static forRoot(config) {
+    const axiosInstance = config && config.request ? config : import_axios2.default.create(config);
+    const providers = [
+      {
+        provide: HTTP_AXIOS_CONNECTION,
+        useValue: axiosInstance
+      },
+      {
+        provide: HTTP_AXIOS_PROVIDER,
+        useFactory: (conn) => new AxiosHttpProvider(conn),
+        inject: [HTTP_AXIOS_CONNECTION]
+      }
+    ];
+    return {
+      module: HttpImplementationAxiosModule,
+      providers,
+      exports: [HTTP_AXIOS_CONNECTION, HTTP_AXIOS_PROVIDER]
+    };
+  }
+};
+HttpImplementationAxiosModule = __decorateClass([
+  (0, import_common2.Module)({})
+], HttpImplementationAxiosModule);
+
+// src/http.module.ts
+var HttpModule = class {
+  /**
+   * Configure HttpModule with an Axios instance or AxiosRequestConfig.
+   * This will import the implementation-specific module (currently Axios).
+   */
+  static forRoot(config) {
+    return {
+      module: HttpModule,
+      imports: [HttpImplementationAxiosModule.forRoot(config)],
+      providers: [
+        {
+          provide: HTTP_PROVIDER,
+          useClass: HttpProvider
+        }
+      ],
+      exports: [HTTP_PROVIDER]
+    };
+  }
+};
+HttpModule = __decorateClass([
+  (0, import_common3.Module)({})
+], HttpModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTP_AXIOS_CONNECTION,
+  HTTP_AXIOS_PROVIDER,
+  HTTP_PROVIDER,
+  HttpImplementationAxiosModule,
+  HttpModule
+});