@nest-omni/core 3.1.2-6 → 3.1.2-8

package/http-client/entities/http-log.entity.js

@@ -0,0 +1,143 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLogEntity = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("../../common");
+let HttpLogEntity = class HttpLogEntity extends common_1.AbstractUuidPrimaryEntity {
+};
+exports.HttpLogEntity = HttpLogEntity;
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 36, nullable: true }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "requestId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 36, nullable: true }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "userId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 10 }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "method", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text' }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "url", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Object)
+], HttpLogEntity.prototype, "headers", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "body", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Object)
+], HttpLogEntity.prototype, "params", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", Number)
+], HttpLogEntity.prototype, "statusCode", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int' }),
+    __metadata("design:type", Number)
+], HttpLogEntity.prototype, "responseTime", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], HttpLogEntity.prototype, "attemptCount", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'boolean', default: false }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", Boolean)
+], HttpLogEntity.prototype, "success", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "errorMessage", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "errorStack", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 50, nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "errorCode", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Object)
+], HttpLogEntity.prototype, "responseHeaders", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "responseBody", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], HttpLogEntity.prototype, "responseSize", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], HttpLogEntity.prototype, "requestSize", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 100, nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "serviceName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 200, nullable: true }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "operationName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 45, nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "clientIp", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 50, nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "source", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Array)
+], HttpLogEntity.prototype, "tags", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Object)
+], HttpLogEntity.prototype, "metadata", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Array)
+], HttpLogEntity.prototype, "retryRecords", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'boolean', nullable: true }),
+    __metadata("design:type", Boolean)
+], HttpLogEntity.prototype, "cacheHit", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 20, nullable: true }),
+    __metadata("design:type", String)
+], HttpLogEntity.prototype, "circuitBreakerState", void 0);
+exports.HttpLogEntity = HttpLogEntity = __decorate([
+    (0, typeorm_1.Entity)('http_logs'),
+    (0, typeorm_1.Index)(['requestId']),
+    (0, typeorm_1.Index)(['userId']),
+    (0, typeorm_1.Index)(['method']),
+    (0, typeorm_1.Index)(['url']),
+    (0, typeorm_1.Index)(['statusCode']),
+    (0, typeorm_1.Index)(['success']),
+    (0, typeorm_1.Index)(['createdAt']),
+    (0, typeorm_1.Index)(['method', 'url', 'createdAt'])
+], HttpLogEntity);

package/http-client/entities/index.d.ts

@@ -0,0 +1 @@
+export * from './http-log.entity';

package/http-client/entities/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-log.entity"), exports);

package/http-client/errors/http-client.errors.d.ts

@@ -0,0 +1,56 @@
+export declare class HttpClientError extends Error {
+    readonly code: string;
+    readonly statusCode?: number;
+    readonly response?: any;
+    readonly config?: any;
+    constructor(message: string, code?: string, statusCode?: number, response?: any, config?: any);
+}
+export declare class NetworkError extends HttpClientError {
+    constructor(message: string, config?: any);
+}
+export declare class TimeoutError extends HttpClientError {
+    constructor(message: string, config?: any);
+}
+export declare class RetryExhaustedError extends HttpClientError {
+    readonly attempts: number;
+    readonly lastError: any;
+    constructor(message: string, attempts: number, lastError: any, config?: any);
+}
+export declare class CircuitBreakerOpenError extends HttpClientError {
+    readonly circuitName: string;
+    readonly failureCount: number;
+    constructor(message: string, circuitName: string, failureCount: number, config?: any);
+}
+export declare class AuthenticationError extends HttpClientError {
+    constructor(message: string, statusCode?: number, response?: any, config?: any);
+}
+export declare class AuthorizationError extends HttpClientError {
+    constructor(message: string, statusCode?: number, response?: any, config?: any);
+}
+export declare class RateLimitError extends HttpClientError {
+    readonly retryAfter?: number;
+    readonly limit?: number;
+    readonly remaining?: number;
+    constructor(message: string, statusCode?: number, response?: any, config?: any, retryAfter?: number, limit?: number, remaining?: number);
+}
+export declare class ServerError extends HttpClientError {
+    constructor(message: string, statusCode?: number, response?: any, config?: any);
+}
+export declare class ResponseFormatError extends HttpClientError {
+    readonly responseData: any;
+    constructor(message: string, responseData: any, config?: any);
+}
+export declare class ApiClientConfigError extends HttpClientError {
+    constructor(message: string, config?: any);
+}
+export declare class CacheError extends HttpClientError {
+    constructor(message: string, config?: any);
+}
+export declare class ErrorFactory {
+    static fromAxiosError(error: any): HttpClientError;
+    static createRetryExhaustedError(attempts: number, lastError: any, config?: any): RetryExhaustedError;
+    static createCircuitBreakerOpenError(circuitName: string, failureCount: number, config?: any): CircuitBreakerOpenError;
+    static createResponseFormatError(message: string, responseData: any, config?: any): ResponseFormatError;
+    static createApiClientConfigError(message: string, config?: any): ApiClientConfigError;
+    static createCacheError(message: string, config?: any): CacheError;
+}

package/http-client/errors/http-client.errors.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorFactory = exports.CacheError = exports.ApiClientConfigError = exports.ResponseFormatError = exports.ServerError = exports.RateLimitError = exports.AuthorizationError = exports.AuthenticationError = exports.CircuitBreakerOpenError = exports.RetryExhaustedError = exports.TimeoutError = exports.NetworkError = exports.HttpClientError = void 0;
+class HttpClientError extends Error {
+    constructor(message, code = 'HTTP_CLIENT_ERROR', statusCode, response, config) {
+        super(message);
+        this.name = 'HttpClientError';
+        this.code = code;
+        this.statusCode = statusCode;
+        this.response = response;
+        this.config = config;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.HttpClientError = HttpClientError;
+class NetworkError extends HttpClientError {
+    constructor(message, config) {
+        super(message, 'NETWORK_ERROR', undefined, undefined, config);
+        this.name = 'NetworkError';
+    }
+}
+exports.NetworkError = NetworkError;
+class TimeoutError extends HttpClientError {
+    constructor(message, config) {
+        super(message, 'TIMEOUT_ERROR', undefined, undefined, config);
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+class RetryExhaustedError extends HttpClientError {
+    constructor(message, attempts, lastError, config) {
+        super(message, 'RETRY_EXHAUSTED', undefined, undefined, config);
+        this.name = 'RetryExhaustedError';
+        this.attempts = attempts;
+        this.lastError = lastError;
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;
+class CircuitBreakerOpenError extends HttpClientError {
+    constructor(message, circuitName, failureCount, config) {
+        super(message, 'CIRCUIT_BREAKER_OPEN', 503, undefined, config);
+        this.name = 'CircuitBreakerOpenError';
+        this.circuitName = circuitName;
+        this.failureCount = failureCount;
+    }
+}
+exports.CircuitBreakerOpenError = CircuitBreakerOpenError;
+class AuthenticationError extends HttpClientError {
+    constructor(message, statusCode = 401, response, config) {
+        super(message, 'AUTHENTICATION_ERROR', statusCode, response, config);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class AuthorizationError extends HttpClientError {
+    constructor(message, statusCode = 403, response, config) {
+        super(message, 'AUTHORIZATION_ERROR', statusCode, response, config);
+        this.name = 'AuthorizationError';
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+class RateLimitError extends HttpClientError {
+    constructor(message, statusCode = 429, response, config, retryAfter, limit, remaining) {
+        super(message, 'RATE_LIMIT_ERROR', statusCode, response, config);
+        this.name = 'RateLimitError';
+        this.retryAfter = retryAfter;
+        this.limit = limit;
+        this.remaining = remaining;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ServerError extends HttpClientError {
+    constructor(message, statusCode = 500, response, config) {
+        super(message, 'SERVER_ERROR', statusCode, response, config);
+        this.name = 'ServerError';
+    }
+}
+exports.ServerError = ServerError;
+class ResponseFormatError extends HttpClientError {
+    constructor(message, responseData, config) {
+        super(message, 'RESPONSE_FORMAT_ERROR', undefined, undefined, config);
+        this.name = 'ResponseFormatError';
+        this.responseData = responseData;
+    }
+}
+exports.ResponseFormatError = ResponseFormatError;
+class ApiClientConfigError extends HttpClientError {
+    constructor(message, config) {
+        super(message, 'API_CLIENT_CONFIG_ERROR', 500, undefined, config);
+        this.name = 'ApiClientConfigError';
+    }
+}
+exports.ApiClientConfigError = ApiClientConfigError;
+class CacheError extends HttpClientError {
+    constructor(message, config) {
+        super(message, 'CACHE_ERROR', undefined, undefined, config);
+        this.name = 'CacheError';
+    }
+}
+exports.CacheError = CacheError;
+class ErrorFactory {
+    static fromAxiosError(error) {
+        const config = error.config;
+        const response = error.response;
+        const message = error.message || 'Unknown error';
+        if (!error.response) {
+            if (error.code === 'ECONNABORTED') {
+                return new TimeoutError(`Request timeout: ${message}`, config);
+            }
+            return new NetworkError(`Network error: ${message}`, config);
+        }
+        const statusCode = error.response.status;
+        const responseData = error.response.data;
+        switch (statusCode) {
+            case 401:
+                return new AuthenticationError((responseData === null || responseData === void 0 ? void 0 : responseData.message) || 'Authentication failed', statusCode, response, config);
+            case 403:
+                return new AuthorizationError((responseData === null || responseData === void 0 ? void 0 : responseData.message) || 'Access forbidden', statusCode, response, config);
+            case 429:
+                const retryAfter = error.response.headers['retry-after'];
+                const limit = error.response.headers['x-ratelimit-limit'];
+                const remaining = error.response.headers['x-ratelimit-remaining'];
+                return new RateLimitError((responseData === null || responseData === void 0 ? void 0 : responseData.message) || 'Rate limit exceeded', statusCode, response, config, retryAfter ? parseInt(retryAfter) : undefined, limit ? parseInt(limit) : undefined, remaining ? parseInt(remaining) : undefined);
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                return new ServerError((responseData === null || responseData === void 0 ? void 0 : responseData.message) || `Server error (${statusCode})`, statusCode, response, config);
+            default:
+                return new HttpClientError((responseData === null || responseData === void 0 ? void 0 : responseData.message) || `HTTP error (${statusCode})`, 'HTTP_ERROR', statusCode, response, config);
+        }
+    }
+    static createRetryExhaustedError(attempts, lastError, config) {
+        return new RetryExhaustedError(`Retry failed after ${attempts} attempts. Last error: ${lastError.message}`, attempts, lastError, config);
+    }
+    static createCircuitBreakerOpenError(circuitName, failureCount, config) {
+        return new CircuitBreakerOpenError(`Circuit breaker '${circuitName}' is open after ${failureCount} failures`, circuitName, failureCount, config);
+    }
+    static createResponseFormatError(message, responseData, config) {
+        return new ResponseFormatError(message, responseData, config);
+    }
+    static createApiClientConfigError(message, config) {
+        return new ApiClientConfigError(message, config);
+    }
+    static createCacheError(message, config) {
+        return new CacheError(message, config);
+    }
+}
+exports.ErrorFactory = ErrorFactory;

package/http-client/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './http-client.errors';

package/http-client/errors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-client.errors"), exports);

package/http-client/examples/advanced-usage.example.d.ts

@@ -0,0 +1,23 @@
+import { HttpClientService } from '../services/http-client.service';
+export declare class GitHubHttpService {
+    private httpClient;
+    constructor(httpClient: HttpClientService);
+    getUser(username: string): Promise<any>;
+    searchRepositories(query: string, sort?: string, order?: string): Promise<any>;
+    getUserRepositories(username: string): Promise<any>;
+    createRepository(repoData: any, token: string): Promise<any>;
+    getRepositoryContributors(owner: string, repo: string): Promise<any>;
+    getMultipleUsers(usernames: string[]): Promise<any[]>;
+    getRepositoryDetails(owner: string, repo: string, options?: {
+        public?: boolean;
+    }): Promise<any>;
+}
+export declare class PaymentHttpService {
+    private httpClient;
+    constructor(httpClient: HttpClientService);
+    createPayment(paymentData: any, apiKey: string): Promise<any>;
+    getPaymentStatus(paymentId: string, apiKey: string): Promise<any>;
+    refundPayment(paymentId: string, refundData: any, apiKey: string): Promise<any>;
+    callExternalApi(url: string, method?: string, data?: any): Promise<any>;
+    private generateIdempotencyKey;
+}