@nest-yalc-2/api-strategy 1.3.3

package/src/strategies/http-abstract-call.strategy.ts

@@ -0,0 +1,238 @@
+import { HTTPMethods } from '@nest-yalc-2/types/globals.d.js';
+import { OutgoingHttpHeaders, IncomingHttpHeaders } from 'node:http2';
+import { IApiCallStrategy } from '../context-call.interface.js';
+
+/**
+ * Configuration options for HTTP call strategies
+ */
+export interface IHttpCallStrategyOptions {
+  /**
+   * List of header names that should be forwarded from the original request context.
+   * Only headers matching these names will be included in outgoing requests.
+   * @example ['authorization', 'x-tenant-id', 'content-type']
+   */
+  headersWhitelist?: string[];
+  /**
+   * Optional function to determine if JSON parsing should be skipped for a response body.
+   * Useful for handling non-JSON responses or streaming data.
+   * @param body - The raw response body as a string
+   * @returns `true` to skip parsing and return the raw body, `false` to parse as JSON
+   * @example (body) => body.startsWith('<html>')
+   */
+  shouldSkipJsonParse?: (body: string) => boolean;
+}
+
+/**
+ * HTTP request options compliant with all HTTP-based call strategies.
+ * This interface provides a unified way to configure HTTP requests across different transport mechanisms.
+ * @template TData - The type of data being sent in the request body (e.g., object, string, Buffer, stream)
+ * @template TParams - The shape of URL query parameters as a key-value record
+ * @example
+ * ```typescript
+ * // For a POST request with JSON body
+ * const options: HttpOptions<{ userId: number }, { includeDetails: string }> = {
+ *   method: 'POST',
+ *   data: { userId: 123 },
+ *   parameters: { includeDetails: 'true' }
+ * };
+ * ```
+ */
+export interface HttpOptions<
+  TData = string | object | Buffer | NodeJS.ReadableStream,
+  TParams extends Record<string, any> = Record<string, any>,
+> {
+  /** HTTP headers to include in the request */
+  headers?: IncomingHttpHeaders | Record<string, string>;
+  /** HTTP method (GET, POST, PUT, DELETE, etc.) */
+  method?: HTTPMethods;
+  /** AbortSignal for cancelling the request */
+  signal?: AbortSignal;
+  /** Additional request configuration (implementation-specific) */
+  Request?: object;
+  /** Request payload/body data */
+  data?: TData;
+  /** URL query parameters as key-value pairs */
+  parameters?: TParams;
+}
+
+/**
+ * Standard HTTP response structure returned by all HTTP call strategies.
+ * @template T - The type of the parsed response data
+ * @example
+ * ```typescript
+ * // For an API returning user data
+ * const response: IHttpCallStrategyResponse<{ id: number; name: string }> = await strategy.get('/users/1');
+ * console.log(response.data.name); // TypeScript knows data has 'name' property
+ * ```
+ */
+export interface IHttpCallStrategyResponse<T = any> {
+  /** The parsed response body */
+  data: T;
+  /** HTTP status code (e.g., 200, 404, 500) */
+  status: number;
+  /** HTTP status text (e.g., "OK", "Not Found") */
+  statusText: string;
+  /** Response headers from the server */
+  headers: OutgoingHttpHeaders;
+  /** Raw request object (implementation-specific) */
+  request?: any;
+}
+
+/**
+ * Interface defining the contract for HTTP-based API call strategies.
+ * Implementations must provide methods for making HTTP requests with type-safe request/response handling.
+ */
+export interface IHttpCallStrategy extends IApiCallStrategy {
+  /**
+   * Execute an HTTP request with full control over method, data, and parameters.
+   * @template TOptData - The type of request body data (default: string | object | Buffer | stream)
+   * @template TParams - The shape of URL query parameters (default: Record<string, any>)
+   * @template TResData - The expected type of the response body after parsing
+   * @param path - The URL path or full URL to request
+   * @param options - HTTP request configuration including method, headers, data, and parameters
+   * @returns Promise resolving to the HTTP response with typed data
+   * @example
+   * ```typescript
+   * // POST request with typed request/response
+   * interface CreateUserDto { name: string; email: string; }
+   * interface UserResponse { id: number; name: string; email: string; }
+   *
+   * const response = await strategy.call<CreateUserDto, {}, UserResponse>('/users', {
+   *   method: 'POST',
+   *   data: { name: 'John', email: 'john@example.com' }
+   * });
+   * console.log(response.data.id); // TypeScript knows this is a number
+   * ```
+   */
+  call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams> | { method?: string },
+  ): Promise<IHttpCallStrategyResponse<TResData>>;
+  /**
+   * Execute an HTTP GET request.
+   * @template TOptData - The type of request body data (typically unused for GET)
+   * @template TParams - The shape of URL query parameters
+   * @template TResData - The expected type of the response body
+   * @param path - The URL path or full URL to request
+   * @param options - HTTP request configuration (excluding method, which is fixed to GET)
+   * @returns Promise resolving to the HTTP response with typed data
+   * @example
+   * ```typescript
+   * // GET request with query parameters
+   * interface UserListResponse { users: Array<{ id: number; name: string }>; total: number; }
+   *
+   * const response = await strategy.get<never, { page: string; limit: string }, UserListResponse>(
+   *   '/users',
+   *   { parameters: { page: '1', limit: '10' } }
+   * );
+   * console.log(response.data.total);
+   * ```
+   */
+  get<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams> | { method?: string },
+  ): Promise<IHttpCallStrategyResponse<TResData>>;
+  /**
+   * Execute an HTTP POST request.
+   * @template TOptData - The type of request body data to send
+   * @template TParams - The shape of URL query parameters
+   * @template TResData - The expected type of the response body
+   * @param path - The URL path or full URL to request
+   * @param options - HTTP request configuration (excluding method, which is fixed to POST)
+   * @returns Promise resolving to the HTTP response with typed data
+   * @example
+   * ```typescript
+   * // POST request with body and query parameters
+   * interface CreateOrderDto { productId: number; quantity: number; }
+   * interface OrderResponse { orderId: string; total: number; }
+   *
+   * const response = await strategy.post<CreateOrderDto, { notify: string }, OrderResponse>(
+   *   '/orders',
+   *   {
+   *     data: { productId: 42, quantity: 2 },
+   *     parameters: { notify: 'true' }
+   *   }
+   * );
+   * console.log(response.data.orderId);
+   * ```
+   */
+  post<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams> | { method?: string },
+  ): Promise<IHttpCallStrategyResponse<TResData>>;
+}
+
+/**
+ * Abstract base class for HTTP-based API call strategies.
+ * Provides convenience methods (get, post) that delegate to the abstract `call` method.
+ * Concrete implementations must implement the `call` method for their specific transport mechanism
+ * (e.g., Axios, Fastify inject, native fetch).
+ * @example
+ * ```typescript
+ * class MyHttpStrategy extends HttpAbstractStrategy {
+ *   async call<TOptData, TParams extends Record<string, any>, TResData>(
+ *     path: string,
+ *     options?: HttpOptions<TOptData, TParams>
+ *   ): Promise<IHttpCallStrategyResponse<TResData>> {
+ *     // Implementation using your HTTP client
+ *     const response = await myHttpClient.request({ url: path, ...options });
+ *     return { data: response.body, status: response.statusCode, ... };
+ *   }
+ * }
+ * ```
+ */
+export abstract class HttpAbstractStrategy implements IHttpCallStrategy {
+  /**
+   * Abstract method to execute an HTTP request. Must be implemented by concrete strategy classes.
+   * @template TOptData - The type of request body data being sent
+   * @template TParams - The shape of URL query parameters
+   * @template TResData - The expected type of the response body
+   * @param path - The URL path or full URL to request
+   * @param options - HTTP request configuration including method, headers, data, and parameters
+   * @returns Promise resolving to the HTTP response with typed data
+   */
+  abstract call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams> | { method?: string },
+  ): Promise<IHttpCallStrategyResponse<TResData>>;
+
+  /**
+   * Convenience method to execute an HTTP GET request.
+   * Delegates to `call()` with method set to 'GET'.
+   * @template TOptData - The type of request body data (typically unused for GET)
+   * @template TParams - The shape of URL query parameters
+   * @template TResData - The expected type of the response body
+   * @param path - The URL path or full URL to request
+   * @param options - HTTP request configuration (method will be overridden to GET)
+   * @returns Promise resolving to the HTTP response with typed data
+   */
+  get<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams> | { method?: string },
+  ): Promise<IHttpCallStrategyResponse<TResData>> {
+    return this.call<TOptData, TParams, TResData>(path, {
+      ...options,
+      method: 'GET',
+    });
+  }
+
+  /**
+   * Convenience method to execute an HTTP POST request.
+   * Delegates to `call()` with method set to 'POST'.
+   * @template TOptData - The type of request body data to send
+   * @template TParams - The shape of URL query parameters
+   * @template TResData - The expected type of the response body
+   * @param path - The URL path or full URL to request
+   * @param options - HTTP request configuration (method will be overridden to POST)
+   * @returns Promise resolving to the HTTP response with typed data
+   */
+  post<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams> | { method?: string },
+  ): Promise<IHttpCallStrategyResponse<TResData>> {
+    return this.call<TOptData, TParams, TResData>(path, {
+      ...options,
+      method: 'POST',
+    });
+  }
+}

package/src/strategies/nest-http-call.strategy.d.ts

@@ -0,0 +1,30 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { HttpService } from '@nestjs/axios';
+import { HttpAbstractStrategy, IHttpCallStrategyResponse, HttpOptions, IHttpCallStrategyOptions } from './http-abstract-call.strategy.js';
+import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
+export type NestHttpCallStrategyOptions = IHttpCallStrategyOptions & {
+    internalRequestHeader?: string;
+    internalRequestToken?: string;
+};
+export declare class NestHttpCallStrategy extends HttpAbstractStrategy {
+    protected readonly httpService: HttpService;
+    protected readonly clsService: YalcGlobalClsService;
+    private baseUrl;
+    protected readonly options: NestHttpCallStrategyOptions;
+    private readonly internalHeader;
+    private readonly internalToken?;
+    constructor(httpService: HttpService, clsService: YalcGlobalClsService, baseUrl?: string, options?: NestHttpCallStrategyOptions);
+    call<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams>): Promise<IHttpCallStrategyResponse<TResData>>;
+}
+export interface NestHttpCallStrategyProviderOptions {
+    baseUrl?: string;
+    NestHttpStrategy?: ClassType<NestHttpCallStrategy>;
+    headersWhitelist?: string[];
+    internalRequestHeader?: string;
+    internalRequestToken?: string;
+}
+export declare const NestHttpCallStrategyProvider: (provide: string, options?: NestHttpCallStrategyProviderOptions) => {
+    provide: string;
+    useFactory: (httpAdapter: HttpService, clsService: YalcGlobalClsService) => NestHttpCallStrategy;
+    inject: (typeof YalcGlobalClsService | typeof HttpService)[];
+};

package/src/strategies/nest-http-call.strategy.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestHttpCallStrategyProvider = exports.NestHttpCallStrategy = void 0;
+const axios_1 = require("@nestjs/axios");
+const http_abstract_call_strategy_js_1 = require("./http-abstract-call.strategy.js");
+const cls_module_js_1 = require("@nest-yalc-2/app/cls.module.js");
+const header_whitelist_helper_js_1 = require("../header-whitelist.helper.js");
+class NestHttpCallStrategy extends http_abstract_call_strategy_js_1.HttpAbstractStrategy {
+    constructor(httpService, clsService, baseUrl = '', options = {}) {
+        super();
+        this.httpService = httpService;
+        this.clsService = clsService;
+        this.baseUrl = baseUrl;
+        this.options = options;
+        this.internalHeader =
+            options.internalRequestHeader ?? 'x-internal-request-token';
+        this.internalToken = options.internalRequestToken;
+    }
+    async call(path, options) {
+        const clsHeaders = (0, header_whitelist_helper_js_1.filterHeaders)(this.clsService.get('headers'), this.options.headersWhitelist);
+        const headers = {
+            ...clsHeaders,
+            ...(options?.headers ?? {}),
+        };
+        if (this.internalHeader &&
+            this.internalToken &&
+            !headers[this.internalHeader]) {
+            headers[this.internalHeader] = this.internalToken;
+        }
+        const _options = {
+            headers,
+            method: options?.method,
+            signal: options?.signal,
+            data: options?.data,
+        };
+        if (options?.parameters) {
+            _options.params = new URLSearchParams(options.parameters);
+        }
+        const { data, ...res } = await this.httpService.axiosRef.request({
+            headers: _options?.headers,
+            method: _options?.method,
+            signal: _options?.signal,
+            data: _options?.data,
+            params: _options?.params,
+            url: `${this.baseUrl}${path}`,
+        });
+        return {
+            ...res,
+            headers: res.headers,
+            data,
+        };
+    }
+}
+exports.NestHttpCallStrategy = NestHttpCallStrategy;
+const NestHttpCallStrategyProvider = (provide, options = {}) => ({
+    provide,
+    useFactory: (httpAdapter, clsService) => {
+        const _options = {
+            baseUrl: '',
+            NestHttpStrategy: NestHttpCallStrategy,
+            ...options,
+        };
+        return new _options.NestHttpStrategy(httpAdapter, clsService, _options.baseUrl, _options);
+    },
+    inject: [axios_1.HttpService, cls_module_js_1.YalcGlobalClsService],
+});
+exports.NestHttpCallStrategyProvider = NestHttpCallStrategyProvider;
+//# sourceMappingURL=nest-http-call.strategy.js.map

package/src/strategies/nest-http-call.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nest-http-call.strategy.js","sourceRoot":"","sources":["nest-http-call.strategy.ts"],"names":[],"mappings":";;;AACA,yCAA4C;AAC5C,qFAK0C;AAE1C,kEAAsE;AACtE,8EAA8D;AAQ9D,MAAa,oBAAqB,SAAQ,qDAAoB;IAI5D,YACqB,WAAwB,EACxB,UAAgC,EAC3C,UAAU,EAAE,EACD,UAAuC,EAAE;QAE5D,KAAK,EAAE,CAAC;QALW,gBAAW,GAAX,WAAW,CAAa;QACxB,eAAU,GAAV,UAAU,CAAsB;QAC3C,YAAO,GAAP,OAAO,CAAK;QACD,YAAO,GAAP,OAAO,CAAkC;QAG5D,IAAI,CAAC,cAAc;YACjB,OAAO,CAAC,qBAAqB,IAAI,0BAA0B,CAAC;QAC9D,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,oBAAoB,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,IAAI,CACR,IAAY,EACZ,OAAwC;QAExC,MAAM,UAAU,GAAG,IAAA,0CAAa,EAC9B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAC9B,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAC9B,CAAC;QACF,MAAM,OAAO,GAAwB;YACnC,GAAG,UAAU;YACb,GAAG,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC;SAC5B,CAAC;QACF,IACE,IAAI,CAAC,cAAc;YACnB,IAAI,CAAC,aAAa;YAClB,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,EAC7B,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC;QACpD,CAAC;QAKD,MAAM,QAAQ,GAIW;YACvB,OAAO;YACP,MAAM,EAAE,OAAO,EAAE,MAAM;YACvB,MAAM,EAAE,OAAO,EAAE,MAAM;YACvB,IAAI,EAAE,OAAO,EAAE,IAAI;SACpB,CAAC;QAEF,IAAI,OAAO,EAAE,UAAU,EAAE,CAAC;YACxB,QAAQ,CAAC,MAAM,GAAG,IAAI,eAAe,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC5D,CAAC;QAED,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC;YAC/D,OAAO,EAAE,QAAQ,EAAE,OAAc;YACjC,MAAM,EAAE,QAAQ,EAAE,MAAM;YACxB,MAAM,EAAE,QAAQ,EAAE,MAAM;YACxB,IAAI,EAAE,QAAQ,EAAE,IAAI;YACpB,MAAM,EAAE,QAAQ,EAAE,MAAM;YACxB,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE;SAC9B,CAAC,CAAC;QAEH,OAAO;YACL,GAAG,GAAG;YACN,OAAO,EAAE,GAAG,CAAC,OAA8B;YAC3C,IAAI;SACL,CAAC;IACJ,CAAC;CACF;AArED,oDAqEC;AAaM,MAAM,4BAA4B,GAAG,CAC1C,OAAe,EACf,UAA+C,EAAE,EACjD,EAAE,CAAC,CAAC;IACJ,OAAO;IACP,UAAU,EAAE,CAAC,WAAwB,EAAE,UAAgC,EAAE,EAAE;QACzE,MAAM,QAAQ,GAAG;YACf,OAAO,EAAE,EAAE;YACX,gBAAgB,EAAE,oBAAoB;YACtC,GAAG,OAAO;SACX,CAAC;QAEF,OAAO,IAAI,QAAQ,CAAC,gBAAgB,CAClC,WAAW,EACX,UAAU,EACV,QAAQ,CAAC,OAAO,EAChB,QAAQ,CACT,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,CAAC,mBAAW,EAAE,oCAAoB,CAAC;CAC5C,CAAC,CAAC;AApBU,QAAA,4BAA4B,gCAoBtC"}

package/src/strategies/nest-http-call.strategy.ts

@@ -0,0 +1,121 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { HttpService } from '@nestjs/axios';
+import {
+  HttpAbstractStrategy,
+  IHttpCallStrategyResponse,
+  HttpOptions,
+  IHttpCallStrategyOptions,
+} from './http-abstract-call.strategy.js';
+import { AxiosRequestConfig } from 'axios';
+import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
+import { filterHeaders } from '../header-whitelist.helper.js';
+import type { OutgoingHttpHeaders } from 'node:http2';
+
+export type NestHttpCallStrategyOptions = IHttpCallStrategyOptions & {
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+};
+
+export class NestHttpCallStrategy extends HttpAbstractStrategy {
+  private readonly internalHeader: string;
+  private readonly internalToken?: string;
+
+  constructor(
+    protected readonly httpService: HttpService,
+    protected readonly clsService: YalcGlobalClsService,
+    private baseUrl = '',
+    protected readonly options: NestHttpCallStrategyOptions = {},
+  ) {
+    super();
+    this.internalHeader =
+      options.internalRequestHeader ?? 'x-internal-request-token';
+    this.internalToken = options.internalRequestToken;
+  }
+
+  async call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams>,
+  ): Promise<IHttpCallStrategyResponse<TResData>> {
+    const clsHeaders = filterHeaders(
+      this.clsService.get('headers'),
+      this.options.headersWhitelist,
+    );
+    const headers: Record<string, any> = {
+      ...clsHeaders,
+      ...(options?.headers ?? {}),
+    };
+    if (
+      this.internalHeader &&
+      this.internalToken &&
+      !headers[this.internalHeader]
+    ) {
+      headers[this.internalHeader] = this.internalToken;
+    }
+    /**
+     * We need this to do a type check on the options and
+     * implement the mapping from HttpOptions to AxiosRequestConfig
+     */
+    const _options:
+      | {
+          [k: string | number | symbol]: never;
+        }
+      | AxiosRequestConfig = {
+      headers,
+      method: options?.method,
+      signal: options?.signal,
+      data: options?.data,
+    };
+
+    if (options?.parameters) {
+      _options.params = new URLSearchParams(options.parameters);
+    }
+
+    const { data, ...res } = await this.httpService.axiosRef.request({
+      headers: _options?.headers as any,
+      method: _options?.method,
+      signal: _options?.signal,
+      data: _options?.data,
+      params: _options?.params,
+      url: `${this.baseUrl}${path}`,
+    });
+
+    return {
+      ...res,
+      headers: res.headers as OutgoingHttpHeaders,
+      data,
+    };
+  }
+}
+
+export interface NestHttpCallStrategyProviderOptions {
+  baseUrl?: string;
+  NestHttpStrategy?: ClassType<NestHttpCallStrategy>;
+  headersWhitelist?: string[];
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+}
+
+/**
+ * Just a convenient provider to inject the NestLocalCallStrategy
+ */
+export const NestHttpCallStrategyProvider = (
+  provide: string,
+  options: NestHttpCallStrategyProviderOptions = {},
+) => ({
+  provide,
+  useFactory: (httpAdapter: HttpService, clsService: YalcGlobalClsService) => {
+    const _options = {
+      baseUrl: '',
+      NestHttpStrategy: NestHttpCallStrategy,
+      ...options,
+    };
+
+    return new _options.NestHttpStrategy(
+      httpAdapter,
+      clsService,
+      _options.baseUrl,
+      _options,
+    );
+  },
+  inject: [HttpService, YalcGlobalClsService],
+});

package/src/strategies/nest-local-call.strategy.d.ts

@@ -0,0 +1,32 @@
+import { HttpAdapterHost } from '@nestjs/core';
+import { HttpAbstractStrategy, HttpOptions, IHttpCallStrategyOptions, IHttpCallStrategyResponse } from './http-abstract-call.strategy.js';
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
+import { AppConfigService } from '@nest-yalc-2/app/app-config.service.js';
+export type NestLocalCallStrategyOptions = IHttpCallStrategyOptions & {
+    internalRequestHeader?: string;
+    internalRequestToken?: string;
+};
+export declare class NestLocalCallStrategy extends HttpAbstractStrategy {
+    protected readonly adapterHost: HttpAdapterHost;
+    protected readonly clsService: YalcGlobalClsService;
+    protected readonly configService: AppConfigService;
+    private baseUrl;
+    protected readonly options: NestLocalCallStrategyOptions;
+    private readonly internalHeader;
+    private readonly internalToken?;
+    constructor(adapterHost: HttpAdapterHost, clsService: YalcGlobalClsService, configService: AppConfigService, baseUrl?: string, options?: NestLocalCallStrategyOptions);
+    call<TOptData extends string | object | Buffer | NodeJS.ReadableStream, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams>): Promise<IHttpCallStrategyResponse<TResData>>;
+}
+export interface NestLocalCallStrategyProviderOptions {
+    baseUrl?: string;
+    NestLocalStrategy?: ClassType<NestLocalCallStrategy>;
+    headersWhitelist?: string[];
+    internalRequestHeader?: string;
+    internalRequestToken?: string;
+}
+export declare const NestLocalCallStrategyProvider: (provide: string, options?: NestLocalCallStrategyProviderOptions) => {
+    provide: string;
+    useFactory: (httpAdapter: HttpAdapterHost, clsService: YalcGlobalClsService, configService: AppConfigService) => NestLocalCallStrategy;
+    inject: (string | typeof YalcGlobalClsService | typeof HttpAdapterHost)[];
+};

package/src/strategies/nest-local-call.strategy.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestLocalCallStrategyProvider = exports.NestLocalCallStrategy = void 0;
+const core_1 = require("@nestjs/core");
+const http_abstract_call_strategy_js_1 = require("./http-abstract-call.strategy.js");
+const cls_module_js_1 = require("@nest-yalc-2/app/cls.module.js");
+const header_whitelist_helper_js_1 = require("../header-whitelist.helper.js");
+const def_const_js_1 = require("@nest-yalc-2/app/def.const.js");
+class NestLocalCallStrategy extends http_abstract_call_strategy_js_1.HttpAbstractStrategy {
+    constructor(adapterHost, clsService, configService, baseUrl = '', options = {}) {
+        super();
+        this.adapterHost = adapterHost;
+        this.clsService = clsService;
+        this.configService = configService;
+        this.baseUrl = baseUrl;
+        this.options = options;
+        this.internalHeader =
+            options.internalRequestHeader ?? 'x-internal-request-token';
+        this.internalToken =
+            options.internalRequestToken ??
+                configService?.values?.internalRequestToken;
+    }
+    async call(path, options) {
+        const instance = this.adapterHost.httpAdapter.getInstance();
+        const clsHeaders = (0, header_whitelist_helper_js_1.filterHeaders)(this.clsService.get('headers'), this.options.headersWhitelist);
+        const headers = {
+            ...clsHeaders,
+            ...(options?.headers ?? {}),
+        };
+        if (this.internalHeader &&
+            this.internalToken &&
+            !headers[this.internalHeader]) {
+            headers[this.internalHeader] = this.internalToken;
+        }
+        const _options = {
+            headers,
+            method: options?.method,
+            payload: options?.data,
+        };
+        const args = {
+            ..._options,
+            url: `${this.baseUrl}${path}`,
+        };
+        if (options?.parameters) {
+            args.query = Object.fromEntries(new URLSearchParams(options.parameters));
+        }
+        const result = await instance.inject(args);
+        let data;
+        try {
+            if (this.options.shouldSkipJsonParse &&
+                this.options.shouldSkipJsonParse(result.body)) {
+                data = result.body;
+            }
+            else {
+                data = result.json();
+            }
+        }
+        catch (_e) {
+            data = result.body;
+        }
+        return {
+            data,
+            headers: result.headers,
+            status: result.statusCode,
+            statusText: result.statusMessage,
+            request: result.payload,
+        };
+    }
+}
+exports.NestLocalCallStrategy = NestLocalCallStrategy;
+const NestLocalCallStrategyProvider = (provide, options = {}) => ({
+    provide,
+    useFactory: (httpAdapter, clsService, configService) => {
+        const _options = {
+            baseUrl: '',
+            NestLocalStrategy: NestLocalCallStrategy,
+            ...options,
+        };
+        return new _options.NestLocalStrategy(httpAdapter, clsService, configService, _options.baseUrl, _options);
+    },
+    inject: [core_1.HttpAdapterHost, cls_module_js_1.YalcGlobalClsService, def_const_js_1.MAIN_APP_CONFIG_SERVICE],
+});
+exports.NestLocalCallStrategyProvider = NestLocalCallStrategyProvider;
+//# sourceMappingURL=nest-local-call.strategy.js.map

package/src/strategies/nest-local-call.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nest-local-call.strategy.js","sourceRoot":"","sources":["nest-local-call.strategy.ts"],"names":[],"mappings":"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"}