@nest-yalc-2/api-strategy 1.3.3

package/src/strategies/composite-event.strategy.ts

@@ -0,0 +1,76 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import type { IEventStrategy } from '../context-event.interface.js';
+
+export type CompositeEventStrategyErrorMode = 'throw' | 'ignore';
+
+export interface CompositeEventStrategyOptions {
+  errorMode?: CompositeEventStrategyErrorMode;
+}
+
+export class CompositeEventStrategy<P = any, R = any, O = any>
+  implements IEventStrategy<P, R[], O>, OnModuleDestroy
+{
+  private readonly errorMode: CompositeEventStrategyErrorMode;
+
+  constructor(
+    private readonly strategies: IEventStrategy<P, R, O>[],
+    options: CompositeEventStrategyOptions = {},
+  ) {
+    if (strategies.length === 0) {
+      throw new Error('CompositeEventStrategy requires at least one strategy.');
+    }
+
+    this.errorMode = options.errorMode ?? 'throw';
+  }
+
+  emit(path: string, payload: P, options?: O): R[] {
+    const results: R[] = [];
+
+    for (const strategy of this.strategies) {
+      try {
+        results.push(strategy.emit(path, payload, options));
+      } catch (error) {
+        if (this.errorMode === 'throw') {
+          throw error;
+        }
+      }
+    }
+
+    return results;
+  }
+
+  async emitAsync(path: string, payload: P, options?: O): Promise<R[]> {
+    const settled = await Promise.allSettled(
+      this.strategies.map((strategy) =>
+        strategy.emitAsync(path, payload, options),
+      ),
+    );
+    const results: R[] = [];
+
+    for (const result of settled) {
+      if (result.status === 'fulfilled') {
+        results.push(result.value);
+      } else if (this.errorMode === 'throw') {
+        throw result.reason;
+      }
+    }
+
+    return results;
+  }
+
+  async onModuleDestroy() {
+    await Promise.all(
+      this.strategies.map(async (strategy) => {
+        await maybeDestroyStrategy(strategy);
+      }),
+    );
+  }
+}
+
+async function maybeDestroyStrategy(strategy: unknown) {
+  const destroyable = strategy as Partial<OnModuleDestroy>;
+
+  if (typeof destroyable.onModuleDestroy === 'function') {
+    await destroyable.onModuleDestroy();
+  }
+}

package/src/strategies/conditional-call.strategy.d.ts

@@ -0,0 +1,17 @@
+import { IApiCallStrategy, ICallOptions, IObjectWithData } from '../context-call.interface.js';
+export interface ConditionalCallStrategyOptions {
+    enabled?: boolean | (() => boolean);
+    disabledResponse?: IObjectWithData<any>;
+    disabledError?: Error | (() => Error);
+}
+export declare class ConditionalCallStrategy implements IApiCallStrategy {
+    private readonly strategy;
+    private readonly options;
+    constructor(strategy: IApiCallStrategy, options?: ConditionalCallStrategyOptions);
+    call<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    get<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    post<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    private whenEnabled;
+    private isEnabled;
+    private resolveDisabledError;
+}

package/src/strategies/conditional-call.strategy.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalCallStrategy = void 0;
+class ConditionalCallStrategy {
+    constructor(strategy, options = {}) {
+        this.strategy = strategy;
+        this.options = options;
+    }
+    call(path, options) {
+        return this.whenEnabled(() => this.strategy.call(path, options));
+    }
+    get(path, options) {
+        return this.whenEnabled(() => this.strategy.get(path, options));
+    }
+    post(path, options) {
+        return this.whenEnabled(() => this.strategy.post(path, options));
+    }
+    async whenEnabled(execute) {
+        if (this.isEnabled()) {
+            return execute();
+        }
+        if (this.options.disabledResponse) {
+            return this.options.disabledResponse;
+        }
+        throw this.resolveDisabledError();
+    }
+    isEnabled() {
+        return typeof this.options.enabled === 'function'
+            ? this.options.enabled()
+            : this.options.enabled !== false;
+    }
+    resolveDisabledError() {
+        if (typeof this.options.disabledError === 'function') {
+            return this.options.disabledError();
+        }
+        return (this.options.disabledError ??
+            new Error('ConditionalCallStrategy is disabled.'));
+    }
+}
+exports.ConditionalCallStrategy = ConditionalCallStrategy;
+//# sourceMappingURL=conditional-call.strategy.js.map

package/src/strategies/conditional-call.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-call.strategy.js","sourceRoot":"","sources":["conditional-call.strategy.ts"],"names":[],"mappings":";;;AAYA,MAAa,uBAAuB;IAClC,YACmB,QAA0B,EAC1B,UAA0C,EAAE;QAD5C,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,YAAO,GAAP,OAAO,CAAqC;IAC5D,CAAC;IAEJ,IAAI,CACF,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,GAAG,CACD,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,IAAI,CACF,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IACnE,CAAC;IAEO,KAAK,CAAC,WAAW,CACvB,OAAiD;QAEjD,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACrB,OAAO,OAAO,EAAE,CAAC;QACnB,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC,OAAO,CAAC,gBAA6C,CAAC;QACpE,CAAC;QAED,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;IACpC,CAAC;IAEO,SAAS;QACf,OAAO,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,UAAU;YAC/C,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YACxB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,KAAK,CAAC;IACrC,CAAC;IAEO,oBAAoB;QAC1B,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;YACrD,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QACtC,CAAC;QAED,OAAO,CACL,IAAI,CAAC,OAAO,CAAC,aAAa;YAC1B,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAClD,CAAC;IACJ,CAAC;CACF;AAzDD,0DAyDC"}

package/src/strategies/conditional-call.strategy.ts

@@ -0,0 +1,70 @@
+import {
+  IApiCallStrategy,
+  ICallOptions,
+  IObjectWithData,
+} from '../context-call.interface.js';
+
+export interface ConditionalCallStrategyOptions {
+  enabled?: boolean | (() => boolean);
+  disabledResponse?: IObjectWithData<any>;
+  disabledError?: Error | (() => Error);
+}
+
+export class ConditionalCallStrategy implements IApiCallStrategy {
+  constructor(
+    private readonly strategy: IApiCallStrategy,
+    private readonly options: ConditionalCallStrategyOptions = {},
+  ) {}
+
+  call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>> {
+    return this.whenEnabled(() => this.strategy.call(path, options));
+  }
+
+  get<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>> {
+    return this.whenEnabled(() => this.strategy.get(path, options));
+  }
+
+  post<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>> {
+    return this.whenEnabled(() => this.strategy.post(path, options));
+  }
+
+  private async whenEnabled<TResData>(
+    execute: () => Promise<IObjectWithData<TResData>>,
+  ) {
+    if (this.isEnabled()) {
+      return execute();
+    }
+
+    if (this.options.disabledResponse) {
+      return this.options.disabledResponse as IObjectWithData<TResData>;
+    }
+
+    throw this.resolveDisabledError();
+  }
+
+  private isEnabled() {
+    return typeof this.options.enabled === 'function'
+      ? this.options.enabled()
+      : this.options.enabled !== false;
+  }
+
+  private resolveDisabledError() {
+    if (typeof this.options.disabledError === 'function') {
+      return this.options.disabledError();
+    }
+
+    return (
+      this.options.disabledError ??
+      new Error('ConditionalCallStrategy is disabled.')
+    );
+  }
+}

package/src/strategies/conditional-event.strategy.d.ts

@@ -0,0 +1,16 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import type { IEventStrategy } from '../context-event.interface.js';
+export interface ConditionalEventStrategyOptions<P = any, R = any, O = any> {
+    enabled?: boolean | (() => boolean);
+    shouldEmit?: (path: string, payload: P, options?: O) => boolean;
+    disabledResult?: R;
+}
+export declare class ConditionalEventStrategy<P = any, R = any, O = any> implements IEventStrategy<P, R, O>, OnModuleDestroy {
+    private readonly strategy;
+    private readonly options;
+    constructor(strategy: IEventStrategy<P, R, O>, options?: ConditionalEventStrategyOptions<P, R, O>);
+    emit(path: string, payload: P, options?: O): R;
+    emitAsync(path: string, payload: P, options?: O): Promise<R>;
+    onModuleDestroy(): Promise<void>;
+    private shouldRun;
+}

package/src/strategies/conditional-event.strategy.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalEventStrategy = void 0;
+class ConditionalEventStrategy {
+    constructor(strategy, options = {}) {
+        this.strategy = strategy;
+        this.options = options;
+    }
+    emit(path, payload, options) {
+        if (!this.shouldRun(path, payload, options)) {
+            return this.options.disabledResult;
+        }
+        return this.strategy.emit(path, payload, options);
+    }
+    async emitAsync(path, payload, options) {
+        if (!this.shouldRun(path, payload, options)) {
+            return this.options.disabledResult;
+        }
+        return this.strategy.emitAsync(path, payload, options);
+    }
+    async onModuleDestroy() {
+        const destroyable = this.strategy;
+        if (typeof destroyable.onModuleDestroy === 'function') {
+            await destroyable.onModuleDestroy();
+        }
+    }
+    shouldRun(path, payload, options) {
+        const enabled = typeof this.options.enabled === 'function'
+            ? this.options.enabled()
+            : this.options.enabled;
+        if (enabled === false) {
+            return false;
+        }
+        return this.options.shouldEmit?.(path, payload, options) ?? true;
+    }
+}
+exports.ConditionalEventStrategy = ConditionalEventStrategy;
+//# sourceMappingURL=conditional-event.strategy.js.map

package/src/strategies/conditional-event.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-event.strategy.js","sourceRoot":"","sources":["conditional-event.strategy.ts"],"names":[],"mappings":";;;AASA,MAAa,wBAAwB;IAGnC,YACmB,QAAiC,EACjC,UAAoD,EAAE;QADtD,aAAQ,GAAR,QAAQ,CAAyB;QACjC,YAAO,GAAP,OAAO,CAA+C;IACtE,CAAC;IAEJ,IAAI,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QACxC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;YAC5C,OAAO,IAAI,CAAC,OAAO,CAAC,cAAmB,CAAC;QAC1C,CAAC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QACnD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;YAC5C,OAAO,IAAI,CAAC,OAAO,CAAC,cAAmB,CAAC;QAC1C,CAAC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,eAAe;QACnB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAoC,CAAC;QAE9D,IAAI,OAAO,WAAW,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;YACtD,MAAM,WAAW,CAAC,eAAe,EAAE,CAAC;QACtC,CAAC;IACH,CAAC;IAEO,SAAS,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QACrD,MAAM,OAAO,GACX,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,UAAU;YACxC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YACxB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;QAE3B,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;YACtB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC;IACnE,CAAC;CACF;AA5CD,4DA4CC"}

package/src/strategies/conditional-event.strategy.ts

@@ -0,0 +1,54 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import type { IEventStrategy } from '../context-event.interface.js';
+
+export interface ConditionalEventStrategyOptions<P = any, R = any, O = any> {
+  enabled?: boolean | (() => boolean);
+  shouldEmit?: (path: string, payload: P, options?: O) => boolean;
+  disabledResult?: R;
+}
+
+export class ConditionalEventStrategy<P = any, R = any, O = any>
+  implements IEventStrategy<P, R, O>, OnModuleDestroy
+{
+  constructor(
+    private readonly strategy: IEventStrategy<P, R, O>,
+    private readonly options: ConditionalEventStrategyOptions<P, R, O> = {},
+  ) {}
+
+  emit(path: string, payload: P, options?: O): R {
+    if (!this.shouldRun(path, payload, options)) {
+      return this.options.disabledResult as R;
+    }
+
+    return this.strategy.emit(path, payload, options);
+  }
+
+  async emitAsync(path: string, payload: P, options?: O): Promise<R> {
+    if (!this.shouldRun(path, payload, options)) {
+      return this.options.disabledResult as R;
+    }
+
+    return this.strategy.emitAsync(path, payload, options);
+  }
+
+  async onModuleDestroy() {
+    const destroyable = this.strategy as Partial<OnModuleDestroy>;
+
+    if (typeof destroyable.onModuleDestroy === 'function') {
+      await destroyable.onModuleDestroy();
+    }
+  }
+
+  private shouldRun(path: string, payload: P, options?: O) {
+    const enabled =
+      typeof this.options.enabled === 'function'
+        ? this.options.enabled()
+        : this.options.enabled;
+
+    if (enabled === false) {
+      return false;
+    }
+
+    return this.options.shouldEmit?.(path, payload, options) ?? true;
+  }
+}

package/src/strategies/fallback-call.strategy.d.ts

@@ -0,0 +1,14 @@
+import { IApiCallStrategy, ICallOptions, IObjectWithData } from '../context-call.interface.js';
+export interface FallbackCallStrategyOptions {
+    shouldFallback?: (error: unknown, strategyIndex: number) => boolean;
+}
+export declare class FallbackCallStrategy implements IApiCallStrategy {
+    private readonly strategies;
+    private readonly options;
+    constructor(strategies: IApiCallStrategy[], options?: FallbackCallStrategyOptions);
+    call<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    get<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    post<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: ICallOptions<TOptData, TParams>): Promise<IObjectWithData<TResData>>;
+    private execute;
+    private shouldFallback;
+}

package/src/strategies/fallback-call.strategy.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackCallStrategy = void 0;
+class FallbackCallStrategy {
+    constructor(strategies, options = {}) {
+        this.strategies = strategies;
+        this.options = options;
+        if (strategies.length === 0) {
+            throw new Error('FallbackCallStrategy requires at least one strategy.');
+        }
+    }
+    call(path, options) {
+        return this.execute((strategy) => strategy.call(path, options));
+    }
+    get(path, options) {
+        return this.execute((strategy) => strategy.get(path, options));
+    }
+    post(path, options) {
+        return this.execute((strategy) => strategy.post(path, options));
+    }
+    async execute(callStrategy) {
+        let lastError;
+        for (const [index, strategy] of this.strategies.entries()) {
+            try {
+                return await callStrategy(strategy);
+            }
+            catch (error) {
+                lastError = error;
+                if (!this.shouldFallback(error, index)) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError;
+    }
+    shouldFallback(error, strategyIndex) {
+        return this.options.shouldFallback?.(error, strategyIndex) ?? true;
+    }
+}
+exports.FallbackCallStrategy = FallbackCallStrategy;
+//# sourceMappingURL=fallback-call.strategy.js.map

package/src/strategies/fallback-call.strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-call.strategy.js","sourceRoot":"","sources":["fallback-call.strategy.ts"],"names":[],"mappings":";;;AAUA,MAAa,oBAAoB;IAC/B,YACmB,UAA8B,EAC9B,UAAuC,EAAE;QADzC,eAAU,GAAV,UAAU,CAAoB;QAC9B,YAAO,GAAP,OAAO,CAAkC;QAE1D,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAED,IAAI,CACF,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,GAAG,CACD,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IACjE,CAAC;IAED,IAAI,CACF,IAAY,EACZ,OAAyC;QAEzC,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,YAEuC;QAEvC,IAAI,SAAkB,CAAC;QAEvB,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;YAC1D,IAAI,CAAC;gBACH,OAAO,MAAM,YAAY,CAAC,QAAQ,CAAC,CAAC;YACtC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAK,CAAC;gBAElB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;oBACvC,MAAM,KAAK,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,SAAS,CAAC;IAClB,CAAC;IAEO,cAAc,CAAC,KAAc,EAAE,aAAqB;QAC1D,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,IAAI,CAAC;IACrE,CAAC;CACF;AAxDD,oDAwDC"}

package/src/strategies/fallback-call.strategy.ts

@@ -0,0 +1,67 @@
+import {
+  IApiCallStrategy,
+  ICallOptions,
+  IObjectWithData,
+} from '../context-call.interface.js';
+
+export interface FallbackCallStrategyOptions {
+  shouldFallback?: (error: unknown, strategyIndex: number) => boolean;
+}
+
+export class FallbackCallStrategy implements IApiCallStrategy {
+  constructor(
+    private readonly strategies: IApiCallStrategy[],
+    private readonly options: FallbackCallStrategyOptions = {},
+  ) {
+    if (strategies.length === 0) {
+      throw new Error('FallbackCallStrategy requires at least one strategy.');
+    }
+  }
+
+  call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>> {
+    return this.execute((strategy) => strategy.call(path, options));
+  }
+
+  get<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>> {
+    return this.execute((strategy) => strategy.get(path, options));
+  }
+
+  post<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>> {
+    return this.execute((strategy) => strategy.post(path, options));
+  }
+
+  private async execute<TResData>(
+    callStrategy: (
+      strategy: IApiCallStrategy,
+    ) => Promise<IObjectWithData<TResData>>,
+  ) {
+    let lastError: unknown;
+
+    for (const [index, strategy] of this.strategies.entries()) {
+      try {
+        return await callStrategy(strategy);
+      } catch (error) {
+        lastError = error;
+
+        if (!this.shouldFallback(error, index)) {
+          throw error;
+        }
+      }
+    }
+
+    throw lastError;
+  }
+
+  private shouldFallback(error: unknown, strategyIndex: number) {
+    return this.options.shouldFallback?.(error, strategyIndex) ?? true;
+  }
+}

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

@@ -0,0 +1,44 @@
+import { HTTPMethods } from '@nest-yalc-2/types/globals.d.js';
+import { OutgoingHttpHeaders, IncomingHttpHeaders } from 'node:http2';
+import { IApiCallStrategy } from '../context-call.interface.js';
+export interface IHttpCallStrategyOptions {
+    headersWhitelist?: string[];
+    shouldSkipJsonParse?: (body: string) => boolean;
+}
+export interface HttpOptions<TData = string | object | Buffer | NodeJS.ReadableStream, TParams extends Record<string, any> = Record<string, any>> {
+    headers?: IncomingHttpHeaders | Record<string, string>;
+    method?: HTTPMethods;
+    signal?: AbortSignal;
+    Request?: object;
+    data?: TData;
+    parameters?: TParams;
+}
+export interface IHttpCallStrategyResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: OutgoingHttpHeaders;
+    request?: any;
+}
+export interface IHttpCallStrategy extends IApiCallStrategy {
+    call<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams> | {
+        method?: string;
+    }): Promise<IHttpCallStrategyResponse<TResData>>;
+    get<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams> | {
+        method?: string;
+    }): Promise<IHttpCallStrategyResponse<TResData>>;
+    post<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams> | {
+        method?: string;
+    }): Promise<IHttpCallStrategyResponse<TResData>>;
+}
+export declare abstract class HttpAbstractStrategy implements IHttpCallStrategy {
+    abstract call<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams> | {
+        method?: string;
+    }): Promise<IHttpCallStrategyResponse<TResData>>;
+    get<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams> | {
+        method?: string;
+    }): Promise<IHttpCallStrategyResponse<TResData>>;
+    post<TOptData, TParams extends Record<string, any>, TResData>(path: string, options?: HttpOptions<TOptData, TParams> | {
+        method?: string;
+    }): Promise<IHttpCallStrategyResponse<TResData>>;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAbstractStrategy = void 0;
+class HttpAbstractStrategy {
+    get(path, options) {
+        return this.call(path, {
+            ...options,
+            method: 'GET',
+        });
+    }
+    post(path, options) {
+        return this.call(path, {
+            ...options,
+            method: 'POST',
+        });
+    }
+}
+exports.HttpAbstractStrategy = HttpAbstractStrategy;
+//# sourceMappingURL=http-abstract-call.strategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-abstract-call.strategy.js","sourceRoot":"","sources":["http-abstract-call.strategy.ts"],"names":[],"mappings":";;;AAuLA,MAAsB,oBAAoB;IAyBxC,GAAG,CACD,IAAY,EACZ,OAA8D;QAE9D,OAAO,IAAI,CAAC,IAAI,CAA8B,IAAI,EAAE;YAClD,GAAG,OAAO;YACV,MAAM,EAAE,KAAK;SACd,CAAC,CAAC;IACL,CAAC;IAYD,IAAI,CACF,IAAY,EACZ,OAA8D;QAE9D,OAAO,IAAI,CAAC,IAAI,CAA8B,IAAI,EAAE;YAClD,GAAG,OAAO;YACV,MAAM,EAAE,MAAM;SACf,CAAC,CAAC;IACL,CAAC;CACF;AAtDD,oDAsDC"}