@adatechnology/http-client 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/http-client",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -8,12 +8,16 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "peerDependencies": {
-    "@nestjs/common": "^11",
+    "@nestjs/common": "^11.0.16",
     "@nestjs/core": "^11"
   },
+  "devDependencies": {
+    "@esbuild-plugins/tsconfig-paths": "^0.1.2",
+    "tsup": "^8.5.1"
+  },
   "scripts": {
     "prebuild": "rm -rf dist",
-    "build": "tsc -p tsconfig.json",
+    "build": "tsup",
     "check": "tsc -p tsconfig.json --noEmit"
   }
 }

package/src/errors/base-app-error.ts

@@ -0,0 +1,25 @@
+export interface ErrorContext {
+  service?: string;
+  url?: string;
+  method?: string;
+  origin?: { file?: string; fn?: string; line?: number; column?: number };
+  stack?: Array<{ fn?: string; file?: string; line?: number; column?: number }>;
+  [key: string]: any;
+}
+
+export class BaseAppError extends Error {
+  public readonly code?: string;
+  public readonly status?: number;
+  public readonly context?: ErrorContext;
+
+  constructor(message: string, status?: number, code?: string, context?: ErrorContext) {
+    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);
+    }
+  }
+}

package/src/errors/error-mapper.service.ts

@@ -0,0 +1,60 @@
+export class ErrorMapperService {
+  mapUpstreamError(err: unknown) {
+    if (err && (err as any).status && (err as any).message) return err;
+
+    try {
+      const anyErr: any = err as any;
+      const context: any = {};
+
+      if (anyErr?.config) {
+        context.url = anyErr.config.url || anyErr.config.baseURL;
+        context.method = anyErr.config.method;
+      }
+
+      if (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?.response) {
+        const status = anyErr.response.status || 502;
+        const message = anyErr.response.data?.message || anyErr.message || 'Upstream error';
+        return { message, status, code: anyErr.code, context };
+      }
+
+      if (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?.code, context };
+    } catch (e) {
+      return { message: 'Error mapping failure', status: 500, code: undefined, context: { original: String(err) } };
+    }
+  }
+
+  private parseStack(stack: string) {
+    const lines = stack.split('\n').map((l) => l.trim()).filter(Boolean);
+    const frames: Array<any> = [];
+    const re = /^at\s+(?:(.*?)\s+\()?(.*?):(\d+):(\d+)\)?$/;
+    for (const line of lines) {
+      const m = re.exec(line);
+      if (m) {
+        const fn = m[1] || undefined;
+        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;
+  }
+
+  private isInternalFrame(file?: string) {
+    if (!file) return false;
+    return /node_modules|internal|axios/.test(file);
+  }
+}

package/src/errors/http-client-error.ts

@@ -0,0 +1,7 @@
+import { BaseAppError } from "./base-app-error";
+
+export class HttpClientError extends BaseAppError {
+  constructor(message: string, status?: number, code?: string, context?: Record<string, any>) {
+    super(message, status ?? 502, code, { service: '@adatechnology/http-client', ...(context || {}) });
+  }
+}

package/src/implementations/axios/axios.http.provider.ts

@@ -584,7 +584,25 @@ export class AxiosHttpProvider implements AxiosHttpProviderInterface {
       return await method();
     } catch (error) {
       const processedError = await this.processErrorInterceptors(error);
-      throw processedError;
+      // Map to a normalized application error with context
+      try {
+        // lazy import to avoid circular deps at runtime - use local mapper
+        const { ErrorMapperService } = require("../../errors/error-mapper.service");
+        const { HttpClientError } = require("../../errors/http-client-error");
+        const mapper = new ErrorMapperService();
+        const mapped = mapper.mapUpstreamError(processedError);
+        throw new HttpClientError(mapped.message, mapped.status, mapped.code, mapped.context);
+      } catch (mapErr) {
+        // If mapping fails, rethrow a generic HttpClientError with minimal context
+        const { HttpClientError } = require("../../errors/http-client-error");
+        const fallback = new HttpClientError(
+          (processedError && (processedError as any).message) || 'HTTP client error',
+          (processedError && (processedError as any).status) || 502,
+          (processedError && (processedError as any).code) || undefined,
+          { original: String(processedError) },
+        );
+        throw fallback;
+      }
     }
   }
 

package/tsconfig.json

@@ -12,5 +12,8 @@
   "include": [
     "./src/**/*.ts"
   ],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist"],
+  "references": [
+    { "path": "../shared" }
+  ]
 }