@adatechnology/http-client 0.0.1

package/src/http.interface.ts

@@ -0,0 +1,259 @@
+import { Observable } from "rxjs";
+
+/**
+ * HTTP methods supported
+ */
+export enum HttpMethod {
+  GET = "GET",
+  POST = "POST",
+  PUT = "PUT",
+  PATCH = "PATCH",
+  DELETE = "DELETE",
+  HEAD = "HEAD",
+  OPTIONS = "OPTIONS",
+}
+
+/**
+ * Content types for HTTP requests
+ */
+export enum ContentType {
+  JSON = "application/json",
+  FORM_URLENCODED = "application/x-www-form-urlencoded",
+  FORM_DATA = "multipart/form-data",
+  TEXT = "text/plain",
+  XML = "application/xml",
+}
+
+/**
+ * HTTP request configuration
+ */
+export interface HttpRequestConfig {
+  url: string;
+  method?: HttpMethod;
+  headers?: Record<string, string>;
+  params?: Record<string, any>;
+  data?: any;
+  timeout?: number;
+  contentType?: ContentType;
+  responseType?: "json" | "text" | "blob" | "arraybuffer";
+  withCredentials?: boolean;
+  retryAttempts?: number;
+  retryDelay?: number;
+  cache?: boolean; // Enable/disable caching for this request
+  cacheTtl?: number; // Cache TTL in milliseconds
+}
+
+/**
+ * HTTP response structure
+ */
+export interface HttpResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  config: HttpRequestConfig;
+  request?: any;
+}
+
+/**
+ * HTTP error structure
+ */
+export interface HttpError extends Error {
+  config: HttpRequestConfig;
+  response?: HttpResponse;
+  status?: number;
+  statusText?: string;
+  isNetworkError?: boolean;
+  isTimeout?: boolean;
+}
+
+/**
+ * Error interceptor function
+ */
+export type ErrorInterceptor = (error: any) => any;
+
+/**
+ * HTTP provider interface
+ */
+export interface HttpProviderInterface {
+  /**
+   * Make a GET request
+   */
+  get<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make a POST request
+   */
+  post<T = any>(
+    url: string,
+    data?: any,
+    config?: Omit<HttpRequestConfig, "url" | "method" | "data">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make a PUT request
+   */
+  put<T = any>(
+    url: string,
+    data?: any,
+    config?: Omit<HttpRequestConfig, "url" | "method" | "data">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make a PATCH request
+   */
+  patch<T = any>(
+    url: string,
+    data?: any,
+    config?: Omit<HttpRequestConfig, "url" | "method" | "data">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make a DELETE request
+   */
+  delete<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make a HEAD request
+   */
+  head<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make an OPTIONS request
+   */
+  options<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Promise<HttpResponse<T>>;
+
+  /**
+   * Make a generic HTTP request
+   */
+  request<T = any>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+
+  /**
+   * Set global headers
+   */
+  setGlobalHeader(key: string, value: string): void;
+
+  /**
+   * Remove global header
+   */
+  removeGlobalHeader(key: string): void;
+
+  /**
+   * Get global headers
+   */
+  getGlobalHeaders(): Record<string, string>;
+
+  /**
+   * Set base URL for all requests
+   */
+  setBaseUrl(baseUrl: string): void;
+
+  /**
+   * Get current base URL
+   */
+  getBaseUrl(): string;
+
+  /**
+   * Set default timeout
+   */
+  setDefaultTimeout(timeout: number): void;
+
+  /**
+   * Add error interceptor
+   */
+  addErrorInterceptor(interceptor: ErrorInterceptor): number;
+
+  /**
+   * Remove error interceptor
+   */
+  removeErrorInterceptor(id: number): void;
+
+  /**
+   * Clear cache for a specific key or all cache
+   */
+  clearCache(key?: string): void;
+
+  /**
+   * Set authorization token
+   */
+  setAuthToken(token: string, type?: string): void;
+
+  /**
+   * Clear authorization token
+   */
+  clearAuthToken(): void;
+
+  /**
+   * Add request interceptor
+   */
+  addRequestInterceptor(
+    onFulfilled: (config: any) => any,
+    onRejected?: (error: any) => any,
+  ): number;
+
+  /**
+   * Remove request interceptor by id
+   */
+  removeRequestInterceptor(id: number): void;
+
+  /**
+   * Add response interceptor
+   */
+  addResponseInterceptor(
+    onFulfilled: (response: any) => any,
+    onRejected?: (error: any) => any,
+  ): number;
+
+  /**
+   * Remove response interceptor by id
+   */
+  removeResponseInterceptor(id: number): void;
+
+  /**
+   * Observable version for reactive programming
+   */
+  get$<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Observable<HttpResponse<T>>;
+  post$<T = any>(
+    url: string,
+    data?: any,
+    config?: Omit<HttpRequestConfig, "url" | "method" | "data">,
+  ): Observable<HttpResponse<T>>;
+  put$<T = any>(
+    url: string,
+    data?: any,
+    config?: Omit<HttpRequestConfig, "url" | "method" | "data">,
+  ): Observable<HttpResponse<T>>;
+  patch$<T = any>(
+    url: string,
+    data?: any,
+    config?: Omit<HttpRequestConfig, "url" | "method" | "data">,
+  ): Observable<HttpResponse<T>>;
+  delete$<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Observable<HttpResponse<T>>;
+  head$<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Observable<HttpResponse<T>>;
+  options$<T = any>(
+    url: string,
+    config?: Omit<HttpRequestConfig, "url" | "method">,
+  ): Observable<HttpResponse<T>>;
+  request$<T = any>(config: HttpRequestConfig): Observable<HttpResponse<T>>;
+}

package/src/http.module.ts

@@ -0,0 +1,27 @@
+import { DynamicModule, Module } from "@nestjs/common";
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+
+import { HttpProvider } from "./http.provider";
+import { HTTP_PROVIDER } from "./http.token";
+import { HttpImplementationAxiosModule } from "./implementations/axios/axios.http.module";
+
+@Module({})
+export class HttpModule {
+  /**
+   * Configure HttpModule with an Axios instance or AxiosRequestConfig.
+   * This will import the implementation-specific module (currently Axios).
+   */
+  static forRoot(config?: AxiosRequestConfig | AxiosInstance): DynamicModule {
+    return {
+      module: HttpModule,
+      imports: [HttpImplementationAxiosModule.forRoot(config)],
+      providers: [
+        {
+          provide: HTTP_PROVIDER,
+          useClass: HttpProvider,
+        },
+      ],
+      exports: [HTTP_PROVIDER],
+    };
+  }
+}

package/src/http.provider.ts

@@ -0,0 +1,219 @@
+import { Injectable, Inject } from "@nestjs/common";
+import { Observable } from "rxjs";
+
+import {
+  ErrorInterceptor,
+  HttpProviderInterface,
+  HttpRequestConfig,
+  HttpResponse,
+} from "./http.interface";
+import type { AxiosHttpProviderInterface } from "./implementations/axios/axios.http.provider";
+import { HTTP_AXIOS_PROVIDER } from "./http.token";
+
+@Injectable()
+export class HttpProvider implements HttpProviderInterface {
+  constructor(
+    @Inject(HTTP_AXIOS_PROVIDER)
+    private readonly axiosHttpProvider: AxiosHttpProviderInterface,
+  ) {}
+
+  /**
+   * Expose underlying axios instance when available from the axios provider implementation.
+   * This is intentionally typed as unknown/any to avoid leaking implementation details.
+   */
+  getAxiosInstance(): any | undefined {
+    try {
+      // Some implementations expose `axiosInstance` or `instance`.
+      // Use brute-force access guarded in try/catch to avoid runtime errors.
+
+      const provider: any = this.axiosHttpProvider as any;
+      return provider?.axiosInstance ?? provider?.instance ?? undefined;
+    } catch (e) {
+      return undefined;
+    }
+  }
+
+  async get<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.get<T>(url, config);
+  }
+
+  get$<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.get$<T>(url, config);
+  }
+
+  async post<T>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.post<T>(url, data, config);
+  }
+
+  post$<T>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.post$<T>(url, data, config);
+  }
+
+  async put<T>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.put<T>(url, data, config);
+  }
+
+  put$<T>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.put$<T>(url, data, config);
+  }
+
+  async patch<T>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.patch<T>(url, data, config);
+  }
+
+  patch$<T>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.patch$<T>(url, data, config);
+  }
+
+  async delete<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.delete<T>(url, config);
+  }
+
+  delete$<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.delete$<T>(url, config);
+  }
+
+  async head<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.head<T>(url, config);
+  }
+
+  head$<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.head$<T>(url, config);
+  }
+
+  async options<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.options<T>(url, config);
+  }
+
+  options$<T>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.options$<T>(url, config);
+  }
+
+  async request<T>(config: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.axiosHttpProvider.request<T>(config);
+  }
+
+  request$<T>(config: HttpRequestConfig): Observable<HttpResponse<T>> {
+    return this.axiosHttpProvider.request$<T>(config);
+  }
+
+  setGlobalHeader(key: string, value: string): void {
+    this.axiosHttpProvider.setGlobalHeader(key, value);
+  }
+
+  removeGlobalHeader(key: string): void {
+    this.axiosHttpProvider.removeGlobalHeader(key);
+  }
+
+  getGlobalHeaders(): Record<string, string> {
+    return this.axiosHttpProvider.getGlobalHeaders();
+  }
+
+  setBaseUrl(baseUrl: string): void {
+    this.axiosHttpProvider.setBaseUrl(baseUrl);
+  }
+
+  getBaseUrl(): string {
+    return this.axiosHttpProvider.getBaseUrl();
+  }
+
+  setDefaultTimeout(timeout: number): void {
+    this.axiosHttpProvider.setDefaultTimeout(timeout);
+  }
+
+  addErrorInterceptor(interceptor: ErrorInterceptor): number {
+    return this.axiosHttpProvider.addErrorInterceptor(interceptor);
+  }
+
+  removeErrorInterceptor(id: number): void {
+    this.axiosHttpProvider.removeErrorInterceptor(id);
+  }
+
+  clearCache(key?: string): void {
+    this.axiosHttpProvider.clearCache(key);
+  }
+
+  setAuthToken(token: string, type?: string): void {
+    this.axiosHttpProvider.setAuthToken(token, type);
+  }
+
+  clearAuthToken(): void {
+    this.axiosHttpProvider.clearAuthToken();
+  }
+
+  addRequestInterceptor(
+    onFulfilled: (config: any) => any,
+    onRejected?: (error: any) => any,
+  ): number {
+    return this.axiosHttpProvider.addRequestInterceptor(
+      onFulfilled,
+      onRejected,
+    );
+  }
+
+  removeRequestInterceptor(id: number): void {
+    this.axiosHttpProvider.removeRequestInterceptor(id);
+  }
+
+  addResponseInterceptor(
+    onFulfilled: (response: any) => any,
+    onRejected?: (error: any) => any,
+  ): number {
+    return this.axiosHttpProvider.addResponseInterceptor(
+      onFulfilled,
+      onRejected,
+    );
+  }
+
+  removeResponseInterceptor(id: number): void {
+    this.axiosHttpProvider.removeResponseInterceptor(id);
+  }
+}

package/src/http.token.ts

@@ -0,0 +1,3 @@
+export const HTTP_AXIOS_CONNECTION = 'HTTP_AXIOS_CONNECTION';
+export const HTTP_AXIOS_PROVIDER = 'HTTP_AXIOS_PROVIDER';
+export const HTTP_PROVIDER = 'HTTP_PROVIDER';

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

@@ -0,0 +1,33 @@
+import { DynamicModule, Module, Provider } from "@nestjs/common";
+import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
+
+import { HTTP_AXIOS_CONNECTION, HTTP_AXIOS_PROVIDER } from "../../http.token";
+import { AxiosHttpProvider } from "./axios.http.provider";
+
+@Module({})
+export class HttpImplementationAxiosModule {
+  static forRoot(config?: AxiosRequestConfig | AxiosInstance): DynamicModule {
+    const axiosInstance: AxiosInstance =
+      config && (config as AxiosInstance).request
+        ? (config as AxiosInstance)
+        : axios.create(config as AxiosRequestConfig);
+
+    const providers: Provider[] = [
+      {
+        provide: HTTP_AXIOS_CONNECTION,
+        useValue: axiosInstance,
+      },
+      {
+        provide: HTTP_AXIOS_PROVIDER,
+        useFactory: (conn: AxiosInstance) => new AxiosHttpProvider(conn),
+        inject: [HTTP_AXIOS_CONNECTION],
+      },
+    ];
+
+    return {
+      module: HttpImplementationAxiosModule,
+      providers,
+      exports: [HTTP_AXIOS_CONNECTION, HTTP_AXIOS_PROVIDER],
+    };
+  }
+}