@adatechnology/http-client 0.0.1

package/dist/http.provider.js

@@ -0,0 +1,137 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpProvider = void 0;
+const common_1 = require("@nestjs/common");
+const http_token_1 = require("./http.token");
+let HttpProvider = class HttpProvider {
+    axiosHttpProvider;
+    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 {
+            // Some implementations expose `axiosInstance` or `instance`.
+            // Use brute-force access guarded in try/catch to avoid runtime errors.
+            const provider = this.axiosHttpProvider;
+            return provider?.axiosInstance ?? provider?.instance ?? undefined;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    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);
+    }
+};
+exports.HttpProvider = HttpProvider;
+exports.HttpProvider = HttpProvider = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(http_token_1.HTTP_AXIOS_PROVIDER)),
+    __metadata("design:paramtypes", [Object])
+], HttpProvider);

package/dist/http.token.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_PROVIDER = exports.HTTP_AXIOS_PROVIDER = exports.HTTP_AXIOS_CONNECTION = void 0;
+exports.HTTP_AXIOS_CONNECTION = 'HTTP_AXIOS_CONNECTION';
+exports.HTTP_AXIOS_PROVIDER = 'HTTP_AXIOS_PROVIDER';
+exports.HTTP_PROVIDER = 'HTTP_PROVIDER';

package/dist/implementations/axios/axios.http.module.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var HttpImplementationAxiosModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpImplementationAxiosModule = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = require("axios");
+const http_token_1 = require("../../http.token");
+const axios_http_provider_1 = require("./axios.http.provider");
+let HttpImplementationAxiosModule = HttpImplementationAxiosModule_1 = class HttpImplementationAxiosModule {
+    static forRoot(config) {
+        const axiosInstance = config && config.request
+            ? config
+            : axios_1.default.create(config);
+        const providers = [
+            {
+                provide: http_token_1.HTTP_AXIOS_CONNECTION,
+                useValue: axiosInstance,
+            },
+            {
+                provide: http_token_1.HTTP_AXIOS_PROVIDER,
+                useFactory: (conn) => new axios_http_provider_1.AxiosHttpProvider(conn),
+                inject: [http_token_1.HTTP_AXIOS_CONNECTION],
+            },
+        ];
+        return {
+            module: HttpImplementationAxiosModule_1,
+            providers,
+            exports: [http_token_1.HTTP_AXIOS_CONNECTION, http_token_1.HTTP_AXIOS_PROVIDER],
+        };
+    }
+};
+exports.HttpImplementationAxiosModule = HttpImplementationAxiosModule;
+exports.HttpImplementationAxiosModule = HttpImplementationAxiosModule = HttpImplementationAxiosModule_1 = __decorate([
+    (0, common_1.Module)({})
+], HttpImplementationAxiosModule);

package/dist/implementations/axios/axios.http.provider.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosHttpProvider = void 0;
+const axios_1 = require("axios");
+const rxjs_1 = require("rxjs");
+/**
+ * Axios-based implementation of the HTTP provider interface.
+ * Provides HTTP client functionality with both Promise and Observable APIs,
+ * plus basic caching capabilities.
+ */
+class AxiosHttpProvider {
+    axiosInstance;
+    errorInterceptors = new Map();
+    nextErrorInterceptorId = 0;
+    requestInterceptorIds = new Set();
+    responseInterceptorIds = new Set();
+    cache = new Map();
+    cacheCleanupInterval;
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance || axios_1.default.create();
+        this.startCacheCleanup();
+    }
+    /**
+     * Starts automatic cache cleanup
+     */
+    startCacheCleanup() {
+        // Clean expired cache entries every 5 minutes
+        this.cacheCleanupInterval = setInterval(() => {
+            this.cleanupExpiredCache();
+        }, 300000);
+    }
+    /**
+     * Stops automatic cache cleanup
+     */
+    stopCacheCleanup() {
+        if (this.cacheCleanupInterval) {
+            clearInterval(this.cacheCleanupInterval);
+            this.cacheCleanupInterval = undefined;
+        }
+    }
+    /**
+     * 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?.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 = 300000) {
+        // 5 minutes default
+        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?.cache !== false) {
+            this.setCache(cacheKey, transformed.data, config?.cacheTtl);
+        }
+        return transformed;
+    }
+    /**
+     * Performs a GET request and returns an Observable.
+     */
+    get$(url, config) {
+        return (0, rxjs_1.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, rxjs_1.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, rxjs_1.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, rxjs_1.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, rxjs_1.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, rxjs_1.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, rxjs_1.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, rxjs_1.from)(this.request(config));
+    }
+    /**
+     * Sets the authorization token for requests.
+     */
+    setAuthToken(token, type = "Bearer") {
+        this.axiosInstance.defaults.headers.common["Authorization"] =
+            `${type} ${token}`;
+        // Log only the initial part of the token to avoid exposing the full secret in logs
+        try {
+            const masked = AxiosHttpProvider.maskToken(token);
+            console.debug(`[AxiosHttpProvider] setAuthToken ${type} ${masked}`);
+        }
+        catch (err) {
+            // swallow logging errors
+        }
+    }
+    /**
+     * 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);
+            throw processedError;
+        }
+    }
+    /**
+     * 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,
+        };
+    }
+}
+exports.AxiosHttpProvider = AxiosHttpProvider;

package/dist/implementations/axios/axios.http.token.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXIOS_HTTP_PROVIDER = void 0;
+exports.AXIOS_HTTP_PROVIDER = 'AXIOS_HTTP_PROVIDER';

package/dist/implementations/http.implementation.module.js

@@ -0,0 +1,20 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpImplementationModule = void 0;
+const common_1 = require("@nestjs/common");
+const axios_http_module_1 = require("./axios/axios.http.module");
+let HttpImplementationModule = class HttpImplementationModule {
+};
+exports.HttpImplementationModule = HttpImplementationModule;
+exports.HttpImplementationModule = HttpImplementationModule = __decorate([
+    (0, common_1.Module)({
+        imports: [axios_http_module_1.HttpImplementationAxiosModule],
+        exports: [axios_http_module_1.HttpImplementationAxiosModule],
+    })
+], HttpImplementationModule);

package/dist/index.js

@@ -0,0 +1,11 @@
+"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; } });