@nu-art/http-client 0.401.9 → 0.500.0

package/core/HttpClient.d.ts

@@ -1,8 +1,8 @@
 import { Logger } from '@nu-art/ts-common';
 import { HttpRequest } from './HttpRequest.js';
-import { AxiosRequestConfig as Axios_RequestConfig } from 'axios';
+import { AxiosRequestConfig as Axios_RequestConfig, AxiosResponse as Axios_Response } from 'axios';
 import { HttpException } from '../exceptions/HttpException.js';
-import { ApiDef, TypedApi } from '../types/api-types.js';
+import { ApiDef, GeneralApi } from '../types/api-types.js';
 /**
  * HTTP client configuration.
  */
@@ -20,7 +20,7 @@ export type HttpConfig = {
  *
  * Extends Logger for built-in logging capabilities.
  */
-export declare class HttpClient_Class extends Logger {
+export declare class HttpClient extends Logger {
     protected origin?: string;
     protected timeout: number;
     protected compress: boolean;
@@ -28,6 +28,8 @@ export declare class HttpClient_Class extends Logger {
     protected defaultOnComplete?: (response: unknown, input: unknown, request: HttpRequest<any>) => Promise<any>;
     protected defaultOnError?: (errorResponse: HttpException) => Promise<any>;
     private requestOption;
+    static default: HttpClient;
+    static setDefault(config: HttpConfig): void;
     /**
      * Creates a new HTTP client instance.
      *
@@ -45,7 +47,14 @@ export declare class HttpClient_Class extends Logger {
      */
     setConfig(config: HttpConfig): void;
     getOrigin(): string | undefined;
+    getTimeout(): number;
+    getRequestOption(): Axios_RequestConfig;
     shouldCompress(): boolean;
+    /**
+     * Sends the request (single boundary to the real world).
+     * Override in tests to assert on options and return a mock response.
+     */
+    sendRequest(options: Axios_RequestConfig): Promise<Axios_Response>;
     setDefaultOnComplete: (defaultOnComplete: (response: unknown, input: unknown, request: HttpRequest<any>) => Promise<any>) => void;
     setDefaultOnError: (defaultOnError: (errorResponse: HttpException) => Promise<any>) => void;
     /**
@@ -74,19 +83,13 @@ export declare class HttpClient_Class extends Logger {
     };
     setRequestOption(requestOption: Axios_RequestConfig): this;
     /**
-     * Creates a new typed HTTP request with default configuration applied.
-     *
-     * The request is pre-configured with:
-     * - Method, timeout, and request options from client defaults
-     * - Default headers (evaluated at creation time)
-     * - Default error and completion callbacks (if set)
-     * - URL (either fullUrl or composed from baseUrl/origin + path)
+     * Creates a new typed HTTP request bound to this client.
+     * The request reads config (origin, timeout, headers) from this client and calls sendRequest on it when executing.
      *
      * @template API - Typed API definition
-     * @param apiDef - API definition with method, path, and optional URL configuration
+     * @param apiDef - API definition with method, path, and optional timeout
      * @param data - Optional request data (used as request key identifier)
-     * @returns Configured HttpRequest instance ready for further customization
+     * @returns HttpRequest instance ready for setUrlParams/setBodyAsJson and execute()
      */
-    createRequest<API extends TypedApi<any, any, any, any>>(apiDef: ApiDef<API>, data?: string): HttpRequest<API>;
+    createRequest<API extends GeneralApi>(apiDef: ApiDef<API>, data?: string): HttpRequest<API>;
 }
-export declare const HttpClient: HttpClient_Class;

package/core/HttpClient.js

@@ -6,6 +6,8 @@
 // noinspection TypeScriptPreferShortImport
 import { BadImplementationException, Logger } from '@nu-art/ts-common';
 import { HttpRequest } from './HttpRequest.js';
+// Axios v1+ import style
+import axios from 'axios';
 /**
  * HTTP client for creating and configuring typed HTTP requests.
  *
@@ -15,7 +17,7 @@ import { HttpRequest } from './HttpRequest.js';
  *
  * Extends Logger for built-in logging capabilities.
  */
-export class HttpClient_Class extends Logger {
+export class HttpClient extends Logger {
     origin;
     timeout = 10000;
     compress = true;
@@ -23,6 +25,10 @@ export class HttpClient_Class extends Logger {
     defaultOnComplete;
     defaultOnError;
     requestOption = {};
+    static default;
+    static setDefault(config) {
+        this.default = new HttpClient(config);
+    }
     /**
      * Creates a new HTTP client instance.
      *
@@ -58,9 +64,22 @@ export class HttpClient_Class extends Logger {
     getOrigin() {
         return this.origin;
     }
+    getTimeout() {
+        return this.timeout;
+    }
+    getRequestOption() {
+        return this.requestOption;
+    }
     shouldCompress() {
         return this.compress;
     }
+    /**
+     * Sends the request (single boundary to the real world).
+     * Override in tests to assert on options and return a mock response.
+     */
+    async sendRequest(options) {
+        return axios.request(options);
+    }
     setDefaultOnComplete = (defaultOnComplete) => {
         this.defaultOnComplete = defaultOnComplete;
     };
@@ -124,29 +143,16 @@ export class HttpClient_Class extends Logger {
         return this;
     }
     /**
-     * Creates a new typed HTTP request with default configuration applied.
-     *
-     * The request is pre-configured with:
-     * - Method, timeout, and request options from client defaults
-     * - Default headers (evaluated at creation time)
-     * - Default error and completion callbacks (if set)
-     * - URL (either fullUrl or composed from baseUrl/origin + path)
+     * Creates a new typed HTTP request bound to this client.
+     * The request reads config (origin, timeout, headers) from this client and calls sendRequest on it when executing.
      *
      * @template API - Typed API definition
-     * @param apiDef - API definition with method, path, and optional URL configuration
+     * @param apiDef - API definition with method, path, and optional timeout
      * @param data - Optional request data (used as request key identifier)
-     * @returns Configured HttpRequest instance ready for further customization
+     * @returns HttpRequest instance ready for setUrlParams/setBodyAsJson and execute()
      */
     createRequest(apiDef, data) {
-        const request = new HttpRequest(apiDef.path, data, this.shouldCompress())
-            .setMethod(apiDef.method)
-            .setTimeout(this.timeout)
-            .setRequestOption(this.requestOption)
-            .addHeaders(this.getDefaultHeaders());
-        if (apiDef.fullUrl)
-            request.setUrl(apiDef.fullUrl);
-        else
-            request.setOrigin(apiDef.baseUrl ?? this.origin).setRelativeUrl(apiDef.path);
+        const request = new HttpRequest(apiDef, this, data);
         if (this.defaultOnError)
             request.setOnError(this.defaultOnError);
         if (this.defaultOnComplete)
@@ -154,4 +160,3 @@ export class HttpClient_Class extends Logger {
         return request;
     }
 }
-export const HttpClient = new HttpClient_Class();

package/core/HttpRequest.d.ts

@@ -3,7 +3,8 @@ import { ApiError_GeneralErrorMessage, ApiErrorResponse, ResponseError } from '@
 import { AxiosRequestConfig as Axios_RequestConfig, AxiosResponse as Axios_Response } from 'axios';
 import { HttpException } from '../exceptions/HttpException.js';
 import { TS_Progress } from '../types/error-types.js';
-import { HttpMethod, TypedApi } from '../types/api-types.js';
+import type { HttpClient } from './HttpClient.js';
+import { ApiDef, HttpMethod, GeneralApi } from '../types/api-types.js';
 /**
  * Typed HTTP request with fluent builder API and comprehensive logging.
  *
@@ -20,7 +21,7 @@ import { HttpMethod, TypedApi } from '../types/api-types.js';
  *
  * @template API - Typed API definition specifying method, response, body, params, and error types
  */
-export declare class HttpRequest<API extends TypedApi<any, any, any, any>> extends Logger {
+export declare class HttpRequest<API extends GeneralApi> extends Logger {
     key: string;
     requestData: any;
     protected origin?: string;
@@ -45,17 +46,16 @@ export declare class HttpRequest<API extends TypedApi<any, any, any, any>> exten
     private cancelController;
     protected status?: number;
     private requestOption;
+    private readonly client;
     /**
-     * Creates a new HTTP request instance.
+     * Creates a new HTTP request bound to a client.
+     * Config (origin, timeout, headers) is taken from the client; execute() calls client.sendRequest().
      *
-     * Automatically extends timeout to 5 minutes in debug mode for development.
-     * Initializes AbortController for request cancellation support.
-     *
-     * @param requestKey - Identifier for this request (used in logging)
-     * @param requestData - Optional data associated with the request
-     * @param shouldCompress - Whether to enable compression (default: false)
+     * @param apiDef - API definition (method, path, optional timeout)
+     * @param client - HttpClient that provides config and performs the send
+     * @param requestData - Optional data (used as request key identifier)
      */
-    constructor(requestKey: string, requestData?: any, shouldCompress?: boolean);
+    constructor(apiDef: ApiDef<API>, client: HttpClient, requestData?: any);
     resolveTypedException(exception: HttpException<any> | unknown): API['E'] | undefined;
     getRequestData(): any;
     setOrigin(origin?: string): this;

package/core/HttpRequest.js

@@ -7,7 +7,7 @@
 import { _keys, asArray, BadImplementationException, exists, isErrorOfType, Logger, MimeType_json } from '@nu-art/ts-common';
 import { composeUrl } from '../utils/utils.js';
 // Axios v1+ import style
-import axios, { CanceledError } from 'axios';
+import { CanceledError } from 'axios';
 import { HttpException } from '../exceptions/HttpException.js';
 import { HttpMethod } from '../types/api-types.js';
 /**
@@ -47,25 +47,30 @@ export class HttpRequest extends Logger {
     cancelController;
     status;
     requestOption = {};
+    client;
     /**
-     * Creates a new HTTP request instance.
+     * Creates a new HTTP request bound to a client.
+     * Config (origin, timeout, headers) is taken from the client; execute() calls client.sendRequest().
      *
-     * Automatically extends timeout to 5 minutes in debug mode for development.
-     * Initializes AbortController for request cancellation support.
-     *
-     * @param requestKey - Identifier for this request (used in logging)
-     * @param requestData - Optional data associated with the request
-     * @param shouldCompress - Whether to enable compression (default: false)
+     * @param apiDef - API definition (method, path, optional timeout)
+     * @param client - HttpClient that provides config and performs the send
+     * @param requestData - Optional data (used as request key identifier)
      */
-    constructor(requestKey, requestData, shouldCompress) {
-        const label = `http request: ${requestKey}${requestData ? ` ${requestData}` : ''}`;
+    constructor(apiDef, client, requestData) {
+        const label = `http request: ${apiDef.path}${requestData ? ` ${requestData}` : ''}`;
         super(label);
-        this.key = requestKey;
+        this.client = client;
+        this.key = apiDef.path;
         this.requestData = requestData;
         this.label = label;
-        this.compress = shouldCompress === undefined ? false : shouldCompress;
+        this.method = apiDef.method;
+        this.compress = client.shouldCompress();
+        this.timeout = apiDef.timeout ?? client.getTimeout();
+        this.setRequestOption(client.getRequestOption());
+        this.addHeaders(client.getDefaultHeaders());
+        this.setOrigin(client.getOrigin()).setRelativeUrl(apiDef.path);
         this.cancelController = new AbortController();
-        this.logVerbose('HttpRequest created', { key: requestKey, requestData, compress: this.compress, timeout: this.timeout });
+        this.logVerbose('HttpRequest created', { key: this.key, requestData, compress: this.compress, timeout: this.timeout });
     }
     resolveTypedException(exception) {
         if (isErrorOfType(exception, HttpException))
@@ -310,7 +315,7 @@ export class HttpRequest extends Logger {
         this.logDebug('Request options', options);
         this.logInfo(`Calling: ${this.method} - ${fullUrl}`);
         try {
-            this.response = await axios.request(options);
+            this.response = await this.client.sendRequest(options);
             this.status = this.response?.status ?? 200;
             this.logVerbose('Response received', { status: this.status, headers: this.response.headers });
         }

package/decorator/ApiCaller.d.ts

@@ -0,0 +1,25 @@
+import { ApiDef, GeneralApi } from '../types/api-types.js';
+import type { ApiCallback, ApiCallContext } from './types.js';
+import { ResolvableContent } from '@nu-art/ts-common';
+import { HttpClient } from '../core/HttpClient.js';
+/**
+ * Module callback factory - receives module instance and context.
+ */
+export type ModuleCallback<Module, API extends GeneralApi> = (module: Module, ctx: ApiCallContext<API>) => void | Promise<void>;
+/**
+ * Configuration options for ApiCaller decorator.
+ */
+export type ApiCallerOptions<Module, API extends GeneralApi> = {
+    onComplete?: ModuleCallback<Module, API>;
+    httpClient?: ResolvableContent<HttpClient, [Module]>;
+};
+/** True when ApiDef uses query params (GET/DELETE); false when it uses body (POST/PUT/PATCH). */
+export declare function isQueryMethod(method: string): boolean;
+/**
+ * TC39 Stage 3 decorator for API calls. Infers body vs query from apiDef.method:
+ * GET/DELETE → params, setUrlParams; POST/PUT/PATCH → body, setBodyAsJson.
+ *
+ * @param _apiDef - API definition or ResolvableContent (value or getter with instance as first arg)
+ * @param options - Optional: onComplete, httpClient (default shared HttpClient)
+ */
+export declare function ApiCaller<API extends GeneralApi, Module = any>(_apiDef: ResolvableContent<ApiDef<API>, [Module]>, options?: ApiCallerOptions<Module, API>): <This extends Module>(originalMethod: (this: This, payload: API["B"] | API["P"], userCallback?: ApiCallback<API>) => unknown, context: ClassMethodDecoratorContext<This>) => (this: This, payload: API["B"] | API["P"], userCallback?: ApiCallback<API>) => Promise<API["R"]>;

package/decorator/ApiCaller.js

@@ -0,0 +1,59 @@
+/*
+ * @nu-art/http-client - Type-safe HTTP client for Thunderstorm
+ * Copyright (C) 2024 Adam van der Kruk aka TacB0sS
+ * Licensed under the Apache License, Version 2.0
+ */
+import { HttpMethod } from '../types/api-types.js';
+import { resolveContent } from '@nu-art/ts-common';
+import { HttpClient } from '../core/HttpClient.js';
+/** True when ApiDef uses query params (GET/DELETE); false when it uses body (POST/PUT/PATCH). */
+export function isQueryMethod(method) {
+    return method === HttpMethod.GET || method === HttpMethod.DELETE;
+}
+/**
+ * TC39 Stage 3 decorator for API calls. Infers body vs query from apiDef.method:
+ * GET/DELETE → params, setUrlParams; POST/PUT/PATCH → body, setBodyAsJson.
+ *
+ * @param _apiDef - API definition or ResolvableContent (value or getter with instance as first arg)
+ * @param options - Optional: onComplete, httpClient (default shared HttpClient)
+ */
+export function ApiCaller(_apiDef, options) {
+    return function (originalMethod, context) {
+        return async function (payload, userCallback) {
+            await originalMethod.call(this, payload, userCallback);
+            const apiDef = resolveContent(_apiDef, this);
+            const method = apiDef.method;
+            const useQuery = isQueryMethod(method);
+            const startTime = Date.now();
+            const client = resolveContent(options?.httpClient, this) ?? HttpClient.default;
+            const request = client.createRequest(apiDef);
+            if (useQuery)
+                request.setUrlParams(payload);
+            else
+                request.setBodyAsJson(payload);
+            const response = await request.execute();
+            const axiosResponse = request.getRawResponse();
+            const rawResponse = {
+                data: axiosResponse.data,
+                status: axiosResponse.status,
+                statusText: axiosResponse.statusText,
+                headers: axiosResponse.headers,
+                config: axiosResponse.config,
+            };
+            const ctx = {
+                response,
+                statusCode: rawResponse.status,
+                headers: rawResponse.headers,
+                apiDef,
+                duration: Date.now() - startTime,
+                rawResponse,
+                ...(useQuery ? { params: payload } : { body: payload }),
+            };
+            if (options?.onComplete)
+                await options.onComplete(this, ctx);
+            if (userCallback)
+                await userCallback(ctx);
+            return response;
+        };
+    };
+}

package/decorator/types.d.ts

@@ -0,0 +1,29 @@
+import type { ApiDef, GeneralApi } from '../types/api-types.js';
+/**
+ * Raw HTTP response structure.
+ * Compatible with Axios response structure.
+ */
+export type RawHttpResponse<R> = {
+    data: R;
+    status: number;
+    statusText: string;
+    headers: Record<string, string | string[] | undefined>;
+    config: unknown;
+};
+/**
+ * Full context object passed to callbacks after API execution.
+ */
+export type ApiCallContext<API extends GeneralApi> = {
+    response: API['R'];
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    body?: API['B'];
+    params?: API['P'];
+    apiDef: ApiDef<API>;
+    duration: number;
+    rawResponse: RawHttpResponse<API['R']>;
+};
+/**
+ * User-provided callback after API response.
+ */
+export type ApiCallback<API extends GeneralApi> = (ctx: ApiCallContext<API>) => void | Promise<void>;

package/decorator/types.js

@@ -0,0 +1,6 @@
+/*
+ * @nu-art/http-client - Type-safe HTTP client for Thunderstorm
+ * Copyright (C) 2024 Adam van der Kruk aka TacB0sS
+ * Licensed under the Apache License, Version 2.0
+ */
+export {};

package/exceptions/HttpException.d.ts

@@ -1,79 +1,15 @@
 import { CustomException } from '@nu-art/ts-common';
 import type { HttpRequest } from '../core/HttpRequest.js';
-import type { ApiError_GeneralErrorMessage, ApiErrorResponse, ResponseError } from '../types/error-types.js';
+import type { ApiErrorResponse, ResponseError } from '../types/error-types.js';
 /**
  * HTTP exception containing error details and the original request.
  *
- * Provides complete context for error handling including the request that failed,
- * allowing error handlers to retry, inspect request details, or perform recovery operations.
- *
  * @template E - Response error type
  */
 export declare class HttpException<E extends ResponseError = ResponseError> extends CustomException {
-    /** HTTP status code */
     responseCode: number;
-    /** Error response from server (if available) */
     errorResponse?: ApiErrorResponse<E>;
-    /** The HTTP request that failed - provides access to method, headers, URL, body, params, etc. */
     request: HttpRequest<any>;
     constructor(responseCode: number, request: HttpRequest<any>, errorResponse?: ApiErrorResponse<E>);
 }
-/**
- * Exception class for API errors with HTTP response codes and structured error bodies.
- *
- * Used for errors that need to be returned to API clients with:
- * - HTTP status code
- * - Structured error response body
- * - Debug message for server-side logging
- *
- * The constructor accepts `causeOrMessage` as either a string (message) or Error (cause),
- * allowing flexible error construction. If both `causeOrMessage` (as Error) and `cause`
- * are provided, `causeOrMessage` takes precedence.
- *
- * @template Err - Type of the error body (must extend ResponseError)
- *
- * @category Exceptions
- *
- * @example
- * ```typescript
- * // With message string
- * throw new ApiException(404, 'Resource not found');
- *
- * // With cause Error
- * throw new ApiException(500, originalError);
- *
- * // With both message and cause
- * throw new ApiException(400, 'Invalid input', validationError);
- * ```
- */
-export declare class ApiException<Err extends ResponseError = ApiError_GeneralErrorMessage> extends CustomException {
-    /** Structured error response body for API clients */
-    readonly responseBody: ApiErrorResponse<Err>;
-    /** HTTP status code for the error response */
-    readonly responseCode: number;
-    /**
-     * Sets the error body and returns this instance for method chaining.
-     *
-     * @param errorBody - Error body object to include in the response
-     * @returns This instance for chaining
-     */
-    readonly setErrorBody: (errorBody: Err) => this;
-    /**
-     * Creates a new ApiException.
-     *
-     * @param responseCode - HTTP status code (e.g., 404, 500)
-     * @param causeOrMessage - Either a message string or an Error object (as cause)
-     * @param cause - Optional additional cause Error (only used if causeOrMessage is a string)
-     */
-    constructor(responseCode: number, causeOrMessage?: string | Error, cause?: Error);
-    /**
-     * Extracts message string from causeOrMessage if it's a string.
-     */
-    private static getMessage;
-    /**
-     * Extracts cause Error from parameters.
-     * If causeOrMessage is an Error, it's used as the cause.
-     * Otherwise, the cause parameter is used.
-     */
-    private static getCause;
-}
+export { ApiException } from '@nu-art/api-types';

package/exceptions/HttpException.js

@@ -3,21 +3,15 @@
  * Copyright (C) 2024 Adam van der Kruk aka TacB0sS
  * Licensed under the Apache License, Version 2.0
  */
-import { _logger_logException, CustomException } from '@nu-art/ts-common';
+import { CustomException } from '@nu-art/ts-common';
 /**
  * HTTP exception containing error details and the original request.
  *
- * Provides complete context for error handling including the request that failed,
- * allowing error handlers to retry, inspect request details, or perform recovery operations.
- *
  * @template E - Response error type
  */
 export class HttpException extends CustomException {
-    /** HTTP status code */
     responseCode;
-    /** Error response from server (if available) */
     errorResponse;
-    /** The HTTP request that failed - provides access to method, headers, URL, body, params, etc. */
     request;
     constructor(responseCode, request, errorResponse) {
         const url = request.getUrl();
@@ -27,73 +21,4 @@ export class HttpException extends CustomException {
         this.request = request;
     }
 }
-/**
- * Exception class for API errors with HTTP response codes and structured error bodies.
- *
- * Used for errors that need to be returned to API clients with:
- * - HTTP status code
- * - Structured error response body
- * - Debug message for server-side logging
- *
- * The constructor accepts `causeOrMessage` as either a string (message) or Error (cause),
- * allowing flexible error construction. If both `causeOrMessage` (as Error) and `cause`
- * are provided, `causeOrMessage` takes precedence.
- *
- * @template Err - Type of the error body (must extend ResponseError)
- *
- * @category Exceptions
- *
- * @example
- * ```typescript
- * // With message string
- * throw new ApiException(404, 'Resource not found');
- *
- * // With cause Error
- * throw new ApiException(500, originalError);
- *
- * // With both message and cause
- * throw new ApiException(400, 'Invalid input', validationError);
- * ```
- */
-export class ApiException extends CustomException {
-    /** Structured error response body for API clients */
-    responseBody = {};
-    /** HTTP status code for the error response */
-    responseCode;
-    /**
-     * Sets the error body and returns this instance for method chaining.
-     *
-     * @param errorBody - Error body object to include in the response
-     * @returns This instance for chaining
-     */
-    setErrorBody = (errorBody) => {
-        this.responseBody.error = errorBody;
-        return this;
-    };
-    /**
-     * Creates a new ApiException.
-     *
-     * @param responseCode - HTTP status code (e.g., 404, 500)
-     * @param causeOrMessage - Either a message string or an Error object (as cause)
-     * @param cause - Optional additional cause Error (only used if causeOrMessage is a string)
-     */
-    constructor(responseCode, causeOrMessage, cause) {
-        super(ApiException, `${responseCode}${ApiException.getMessage(causeOrMessage)}`, ApiException.getCause(causeOrMessage, cause));
-        this.responseCode = responseCode;
-        this.responseBody.debugMessage = _logger_logException(this);
-    }
-    /**
-     * Extracts message string from causeOrMessage if it's a string.
-     */
-    static getMessage(causeOrMessage) {
-        return typeof causeOrMessage === 'string' ? `-${JSON.stringify(causeOrMessage)}` : '';
-    }
-    /**
-     * Extracts cause Error from parameters.
-     * If causeOrMessage is an Error, it's used as the cause.
-     * Otherwise, the cause parameter is used.
-     */
-    static getCause(causeOrMessage, cause) {
-        return typeof causeOrMessage != 'string' ? causeOrMessage : cause;
-    }
-}
+export { ApiException } from '@nu-art/api-types';

package/index.d.ts

@@ -1,6 +1,8 @@
 export * from './core/HttpClient.js';
 export * from './core/HttpRequest.js';
+export * from './decorator/ApiCaller.js';
 export * from './types/api-types.js';
+export * from './decorator/types.js';
 export * from './types/error-types.js';
 export * from './types/types.js';
 export * from './exceptions/HttpException.js';

package/index.js

@@ -6,8 +6,10 @@
 // Core classes
 export * from './core/HttpClient.js';
 export * from './core/HttpRequest.js';
+export * from './decorator/ApiCaller.js';
 // Types
 export * from './types/api-types.js';
+export * from './decorator/types.js';
 export * from './types/error-types.js';
 export * from './types/types.js';
 // Exceptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/http-client",
-  "version": "0.401.9",
+  "version": "0.500.0",
   "description": "Type-safe HTTP client with fluent API, comprehensive logging, and request/response type safety",
   "keywords": [
     "TacB0sS",
@@ -40,14 +40,16 @@
     }
   ],
   "publishConfig": {
-    "directory": "dist"
+    "directory": "dist",
+    "linkDirectory": true
   },
   "dependencies": {
-    "@nu-art/ts-common": "0.401.9",
+    "@nu-art/api-types": "{{THUNDERSTORM_VERSION}}",
+    "@nu-art/ts-common": "0.500.0",
     "axios": "^1.13.1"
   },
   "devDependencies": {
-    "@nu-art/testalot": "0.401.9"
+    "@nu-art/testalot": "0.500.0"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/types/api-types.d.ts

@@ -1,142 +1 @@
-import type { HttpRequest } from '../core/HttpRequest.js';
-import type { ResponseError } from './error-types.js';
-import type { QueryParams } from './types.js';
-/**
- * HTTP method enumeration.
- *
- * Standard HTTP methods supported by the client.
- */
-export declare enum HttpMethod {
-    ALL = "all",
-    POST = "post",
-    GET = "get",
-    PATCH = "patch",
-    DELETE = "delete",
-    PUT = "put",
-    OPTIONS = "options",
-    HEAD = "head"
-}
-/** HTTP methods that use query parameters (no request body) */
-export type HttpMethod_Query = 'get' | 'delete';
-/** HTTP methods that use request body */
-export type HttpMethod_Body = 'post' | 'put' | 'patch';
-/** HTTP methods with no parameters or body */
-export type HttpMethod_Empty = 'options' | 'head';
-/**
- * Type-safe API definition with full type information for requests and responses.
- *
- * Provides compile-time type safety for HTTP API calls, ensuring request bodies,
- * query parameters, and responses match their declared types.
- *
- * @template M - HTTP method (string literal)
- * @template R - Response type
- * @template B - Body type (internal representation)
- * @template P - Query parameters type
- * @template IB - Input body type (what callers provide, defaults to B)
- * @template IP - Input params type (what callers provide, defaults to P)
- * @template E - Error response type
- *
- * @example
- * ```typescript
- * type MyApi = TypedApi<'post', {id: string}, {name: string}, {filter: string}, {name: string}, {filter: string}>;
- * // Method: POST
- * // Response: {id: string}
- * // Body: {name: string}
- * // Params: {filter: string}
- * ```
- */
-export type TypedApi<M extends string, R, B, P extends QueryParams | undefined, IB = B, IP = P, E extends ResponseError = ResponseError> = {
-    Method: M;
-    Response: R;
-    Body: B;
-    Params: P;
-    InternalParams: IP;
-    InternalBody: IB;
-    Error: E;
-    M: M;
-    R: R;
-    B: B;
-    P: P;
-    IP: IP;
-    IB: IB;
-    E: E;
-};
-/**
- * Convenience type for APIs that use request bodies (POST, PUT, PATCH).
- *
- * @template R - Response type
- * @template B - Body type
- * @template IB - Input body type (defaults to B)
- * @template E - Error type
- * @template M - HTTP method (defaults to POST)
- * @template P - Query params type (defaults to never)
- */
-export type BodyApi<R, B, IB = B, E extends ResponseError = ResponseError, M extends HttpMethod_Body = HttpMethod.POST, P extends QueryParams = never> = TypedApi<M, R, B, P, IB, P, E>;
-/**
- * Convenience type for APIs that use query parameters (GET, DELETE).
- *
- * @template R - Response type
- * @template P - Query params type
- * @template E - Error type
- * @template IP - Input params type (defaults to P)
- * @template M - HTTP method (defaults to GET)
- * @template B - Body type (defaults to never)
- */
-export type QueryApi<R, P extends QueryParams | undefined = QueryParams, E extends ResponseError = ResponseError, IP = P, M extends HttpMethod_Query = HttpMethod.GET, B = never> = TypedApi<M, R, B, P, B, IP, E>;
-/**
- * Convenience type for APIs with no parameters or body (OPTIONS, HEAD).
- *
- * @template R - Response type
- * @template M - HTTP method (must be OPTIONS or HEAD)
- * @template E - Error type
- * @template P - Query params type (defaults to never)
- * @template B - Body type (defaults to never)
- */
-export type EmptyApi<R, M extends HttpMethod_Empty, E extends ResponseError = ResponseError, P extends QueryParams = never, B = never> = TypedApi<M, R, B, P, B, P, E>;
-/**
- * API definition for creating requests.
- *
- * Specifies the HTTP method, URL configuration, and optional timeout.
- * Either `fullUrl` (absolute) or `baseUrl` + `path` (relative) must be provided.
- *
- * @template API - Typed API definition
- */
-export type ApiDef<API extends TypedApi<any, any, any, any, any>> = {
-    method: API['Method'];
-    fullUrl?: string;
-    baseUrl?: string;
-    path: string;
-    timeout?: number;
-    errors?: API['Error']['type'];
-};
-/**
- * Recursive API structure type for organizing APIs into namespaces.
- *
- * Allows nesting APIs in a hierarchical structure, where each level can contain
- * either a TypedApi or another ApiStruct (sub-namespace).
- */
-export type ApiStruct = {
-    [k: string]: (TypedApi<any, any, any, any, any> | ApiStruct);
-};
-export type ApiDefResolver<API_Struct extends ApiStruct> = API_Struct extends TypedApi<any, any, any, any, any> ? ApiDef<API_Struct> : API_Struct extends ApiStruct ? ApiDefRouter<API_Struct> : never;
-export type ApiDefRouter<API_Struct extends ApiStruct> = {
-    [P in keyof API_Struct]: ApiDefResolver<API_Struct[P]>;
-};
-export type ApiDefCaller<API_Struct extends ApiStruct> = API_Struct extends TypedApi<any, any, any, any, any> ? ApiCaller<API_Struct> : API_Struct extends ApiStruct ? ApiCallerRouter<API_Struct> : never;
-export type ApiCallerRouter<API_Struct extends ApiStruct> = {
-    [P in keyof API_Struct]: ApiDefCaller<API_Struct[P]>;
-};
-export type ApiCaller_Query<API extends QueryApi<any, any, any, any, HttpMethod_Query>> = API['IP'] extends undefined ? () => HttpRequest<API> : (query: API['IP']) => HttpRequest<API>;
-export type ApiCaller_Body<API extends BodyApi<any, any, any, any, HttpMethod_Body>> = API['IB'] extends undefined ? () => HttpRequest<API> : (query: API['IB']) => HttpRequest<API>;
-export type ApiCaller_Any<API extends TypedApi<any, any, any, any, any>> = (body: API['IB'], query: API['IP']) => HttpRequest<API>;
-/**
- * Resolves the appropriate caller function type based on API method.
- *
- * Automatically selects the correct function signature:
- * - QueryApi → function(query?) → HttpRequest
- * - BodyApi → function(body?) → HttpRequest
- * - Other → function(body, query) → HttpRequest
- *
- * @template API - Typed API definition
- */
-export type ApiCaller<API> = API extends QueryApi<any, any, any, any, HttpMethod_Query> ? ApiCaller_Query<API> : API extends BodyApi<any, any, any, any, HttpMethod_Body> ? ApiCaller_Body<API> : API extends TypedApi<any, any, any, any, any> ? ApiCaller_Any<API> : never;
+export { GeneralApi, HttpMethod, HttpMethod_Query, HttpMethod_Body, HttpMethod_Empty, TypedApi, BodyApi, QueryApi, EmptyApi, ApiDef, ApiDefCaller, ApiStruct, ApiDefResolver } from '@nu-art/api-types';

package/types/api-types.js

@@ -3,19 +3,4 @@
  * Copyright (C) 2024 Adam van der Kruk aka TacB0sS
  * Licensed under the Apache License, Version 2.0
  */
-/**
- * HTTP method enumeration.
- *
- * Standard HTTP methods supported by the client.
- */
-export var HttpMethod;
-(function (HttpMethod) {
-    HttpMethod["ALL"] = "all";
-    HttpMethod["POST"] = "post";
-    HttpMethod["GET"] = "get";
-    HttpMethod["PATCH"] = "patch";
-    HttpMethod["DELETE"] = "delete";
-    HttpMethod["PUT"] = "put";
-    HttpMethod["OPTIONS"] = "options";
-    HttpMethod["HEAD"] = "head";
-})(HttpMethod || (HttpMethod = {}));
+export { HttpMethod } from '@nu-art/api-types';

package/types/error-types.d.ts

@@ -1,42 +1,6 @@
-/**
- * Generic response error type for API error handling.
- *
- * @template K - Error type identifier (string literal)
- * @template Data - Error data payload
- */
-export type ResponseError<K extends string = string, Data = any> = {
-    /** Error type identifier */
-    type: K;
-    /** Error data payload */
-    data: Data;
-};
-/**
- * Standard error message response type.
- *
- * Used for general error messages in API responses.
- */
-export type ApiError_GeneralErrorMessage = ResponseError<'error-message', {
-    message: string;
-}>;
-/**
- * API error response structure.
- *
- * Contains an optional debug message (for developers) and an optional
- * structured error object (for clients).
- *
- * @template E - Response error type
- */
-export type ApiErrorResponse<E extends ResponseError> = {
-    /** Optional debug message (typically includes stack traces, internal details) */
-    debugMessage?: string;
-    /** Optional structured error object */
-    error?: E;
-};
+export type { ResponseError, ApiError_GeneralErrorMessage, ApiErrorResponse } from '@nu-art/api-types';
 /**
  * Progress event type for upload/download tracking.
- *
- * Mirrors the ProgressEvent interface for compatibility with XMLHttpRequest
- * and fetch progress events.
  */
 export type TS_Progress = {
     readonly lengthComputable: boolean;

package/types/types.d.ts

@@ -1,26 +1,7 @@
+export type { QueryParams, UrlQueryParams } from '@nu-art/api-types';
 /**
  * Type for route/query parameters with dynamic value support.
- *
- * Supports static values (string, number, boolean) or functions that return values.
- * Functions are evaluated when composing the query string, allowing dynamic
- * parameter generation (e.g., timestamps, IDs).
  */
 export type RouteParams = {
     [key: string]: string | number | boolean | undefined | (() => string | number);
 };
-/**
- * Static query parameters type (no functions).
- *
- * Used for API type definitions where parameters are known at compile time.
- */
-export type QueryParams = {
-    [key: string]: string | number | boolean | undefined;
-};
-/**
- * URL query parameters with string values only.
- *
- * Used for URL composition where all values must be strings.
- */
-export type UrlQueryParams = {
-    [key: string]: string | undefined;
-};