@nest-yalc-2/api-strategy 1.3.3

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

@@ -0,0 +1,87 @@
+import {
+  IApiCallStrategy,
+  ICallOptions,
+  IObjectWithData,
+} from '../context-call.interface.js';
+
+export type ShadowCallStrategyErrorMode = 'throw' | 'ignore';
+
+export interface ShadowCallStrategyOptions {
+  awaitShadows?: boolean;
+  shadowErrorMode?: ShadowCallStrategyErrorMode;
+}
+
+export class ShadowCallStrategy implements IApiCallStrategy {
+  private readonly awaitShadows: boolean;
+  private readonly shadowErrorMode: ShadowCallStrategyErrorMode;
+
+  constructor(
+    private readonly primary: IApiCallStrategy,
+    private readonly shadows: IApiCallStrategy[],
+    options: ShadowCallStrategyOptions = {},
+  ) {
+    if (shadows.length === 0) {
+      throw new Error(
+        'ShadowCallStrategy requires at least one shadow strategy.',
+      );
+    }
+
+    this.shadowErrorMode = options.shadowErrorMode ?? 'ignore';
+    this.awaitShadows =
+      options.awaitShadows ?? this.shadowErrorMode === 'throw';
+  }
+
+  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),
+      (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),
+      (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),
+      (strategy) => strategy.post(path, options),
+    );
+  }
+
+  private async execute<TResData>(
+    primaryCall: (
+      strategy: IApiCallStrategy,
+    ) => Promise<IObjectWithData<TResData>>,
+    shadowCall: (strategy: IApiCallStrategy) => Promise<IObjectWithData<any>>,
+  ) {
+    const primaryResult = await primaryCall(this.primary);
+    const shadowExecution = Promise.all(
+      this.shadows.map((strategy) => shadowCall(strategy)),
+    );
+
+    if (this.awaitShadows) {
+      if (this.shadowErrorMode === 'throw') {
+        await shadowExecution;
+      } else {
+        await shadowExecution.catch(() => undefined);
+      }
+    } else {
+      void shadowExecution.catch(() => undefined);
+    }
+
+    return primaryResult;
+  }
+}

package/src/strategy-selector.provider.d.ts

@@ -0,0 +1,19 @@
+import type { Provider } from '@nestjs/common';
+import type { IApiCallStrategy } from './context-call.interface.js';
+import type { IEventStrategy } from './context-event.interface.js';
+export type StrategySelectorToken<TStrategy = unknown> = string | symbol | (abstract new (...args: any[]) => TStrategy) | (new (...args: any[]) => TStrategy);
+export type StrategySelectorBehavior = 'throw' | 'fallback';
+export interface StrategySelectorFactoryOptions {
+    inject?: any[];
+    useFactory?: (...args: any[]) => string | null | undefined | Promise<string | null | undefined>;
+}
+export interface StrategySelectorProviderOptions<TStrategy> {
+    provide: StrategySelectorToken<TStrategy>;
+    defaultStrategy: string;
+    strategies: Record<string, StrategySelectorToken<TStrategy>>;
+    selector?: StrategySelectorFactoryOptions;
+    unknownStrategyBehavior?: StrategySelectorBehavior;
+}
+export declare function StrategySelectorProvider<TStrategy>(options: StrategySelectorProviderOptions<TStrategy>): Provider<TStrategy>;
+export declare function ApiCallStrategySelectorProvider(options: StrategySelectorProviderOptions<IApiCallStrategy>): Provider<IApiCallStrategy>;
+export declare function EventStrategySelectorProvider(options: StrategySelectorProviderOptions<IEventStrategy>): Provider<IEventStrategy>;

package/src/strategy-selector.provider.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategySelectorProvider = StrategySelectorProvider;
+exports.ApiCallStrategySelectorProvider = ApiCallStrategySelectorProvider;
+exports.EventStrategySelectorProvider = EventStrategySelectorProvider;
+function normalizeStrategyKey(strategy) {
+    const value = strategy?.trim();
+    return value ? value : undefined;
+}
+function StrategySelectorProvider(options) {
+    const strategyEntries = Object.entries(options.strategies);
+    if (strategyEntries.length === 0) {
+        throw new Error('Strategy selector requires at least one strategy.');
+    }
+    const defaultStrategyIndex = strategyEntries.findIndex(([key]) => key === options.defaultStrategy);
+    if (defaultStrategyIndex < 0) {
+        throw new Error(`Default strategy "${options.defaultStrategy}" is not registered.`);
+    }
+    const behavior = options.unknownStrategyBehavior ?? 'throw';
+    const selectorInject = options.selector?.inject ?? [];
+    return {
+        provide: options.provide,
+        useFactory: async (...args) => {
+            const strategyInstances = args.slice(0, strategyEntries.length);
+            const selectorArgs = args.slice(strategyEntries.length);
+            const configuredStrategy = normalizeStrategyKey(await options.selector?.useFactory?.(...selectorArgs));
+            const selectedStrategy = configuredStrategy ?? options.defaultStrategy;
+            const selectedStrategyIndex = strategyEntries.findIndex(([key]) => key === selectedStrategy);
+            if (selectedStrategyIndex >= 0) {
+                return strategyInstances[selectedStrategyIndex];
+            }
+            if (behavior === 'fallback') {
+                return strategyInstances[defaultStrategyIndex];
+            }
+            const availableStrategies = strategyEntries
+                .map(([key]) => key)
+                .join(', ');
+            throw new Error(`Unknown strategy "${selectedStrategy}". Available strategies: ${availableStrategies}.`);
+        },
+        inject: [
+            ...strategyEntries.map(([, strategyToken]) => strategyToken),
+            ...selectorInject,
+        ],
+    };
+}
+function ApiCallStrategySelectorProvider(options) {
+    return StrategySelectorProvider(options);
+}
+function EventStrategySelectorProvider(options) {
+    return StrategySelectorProvider(options);
+}
+//# sourceMappingURL=strategy-selector.provider.js.map

package/src/strategy-selector.provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-selector.provider.js","sourceRoot":"","sources":["strategy-selector.provider.ts"],"names":[],"mappings":";;AAgCA,4DA0DC;AAED,0EAIC;AAED,sEAIC;AA3ED,SAAS,oBAAoB,CAAC,QAAmC;IAC/D,MAAM,KAAK,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC/B,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AACnC,CAAC;AAED,SAAgB,wBAAwB,CACtC,OAAmD;IAEnD,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAE3D,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,oBAAoB,GAAG,eAAe,CAAC,SAAS,CACpD,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,OAAO,CAAC,eAAe,CAC3C,CAAC;IAEF,IAAI,oBAAoB,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,qBAAqB,OAAO,CAAC,eAAe,sBAAsB,CACnE,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,OAAO,CAAC,uBAAuB,IAAI,OAAO,CAAC;IAC5D,MAAM,cAAc,GAAG,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,CAAC;IAEtD,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,UAAU,EAAE,KAAK,EAAE,GAAG,IAAW,EAAE,EAAE;YACnC,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAClC,CAAC,EACD,eAAe,CAAC,MAAM,CACR,CAAC;YACjB,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YACxD,MAAM,kBAAkB,GAAG,oBAAoB,CAC7C,MAAM,OAAO,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC,GAAG,YAAY,CAAC,CACtD,CAAC;YACF,MAAM,gBAAgB,GAAG,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;YACvE,MAAM,qBAAqB,GAAG,eAAe,CAAC,SAAS,CACrD,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,gBAAgB,CACpC,CAAC;YAEF,IAAI,qBAAqB,IAAI,CAAC,EAAE,CAAC;gBAC/B,OAAO,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;YAClD,CAAC;YAED,IAAI,QAAQ,KAAK,UAAU,EAAE,CAAC;gBAC5B,OAAO,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;YACjD,CAAC;YAED,MAAM,mBAAmB,GAAG,eAAe;iBACxC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;iBACnB,IAAI,CAAC,IAAI,CAAC,CAAC;YACd,MAAM,IAAI,KAAK,CACb,qBAAqB,gBAAgB,4BAA4B,mBAAmB,GAAG,CACxF,CAAC;QACJ,CAAC;QACD,MAAM,EAAE;YACN,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC;YAC5D,GAAG,cAAc;SAClB;KACF,CAAC;AACJ,CAAC;AAED,SAAgB,+BAA+B,CAC7C,OAA0D;IAE1D,OAAO,wBAAwB,CAAC,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED,SAAgB,6BAA6B,CAC3C,OAAwD;IAExD,OAAO,wBAAwB,CAAC,OAAO,CAAC,CAAC;AAC3C,CAAC"}

package/src/strategy-selector.provider.ts

@@ -0,0 +1,103 @@
+import type { Provider } from '@nestjs/common';
+import type { IApiCallStrategy } from './context-call.interface.js';
+import type { IEventStrategy } from './context-event.interface.js';
+
+export type StrategySelectorToken<TStrategy = unknown> =
+  | string
+  | symbol
+  | (abstract new (...args: any[]) => TStrategy)
+  | (new (...args: any[]) => TStrategy);
+
+export type StrategySelectorBehavior = 'throw' | 'fallback';
+
+export interface StrategySelectorFactoryOptions {
+  inject?: any[];
+  useFactory?: (
+    ...args: any[]
+  ) => string | null | undefined | Promise<string | null | undefined>;
+}
+
+export interface StrategySelectorProviderOptions<TStrategy> {
+  provide: StrategySelectorToken<TStrategy>;
+  defaultStrategy: string;
+  strategies: Record<string, StrategySelectorToken<TStrategy>>;
+  selector?: StrategySelectorFactoryOptions;
+  unknownStrategyBehavior?: StrategySelectorBehavior;
+}
+
+function normalizeStrategyKey(strategy: string | null | undefined) {
+  const value = strategy?.trim();
+  return value ? value : undefined;
+}
+
+export function StrategySelectorProvider<TStrategy>(
+  options: StrategySelectorProviderOptions<TStrategy>,
+): Provider<TStrategy> {
+  const strategyEntries = Object.entries(options.strategies);
+
+  if (strategyEntries.length === 0) {
+    throw new Error('Strategy selector requires at least one strategy.');
+  }
+
+  const defaultStrategyIndex = strategyEntries.findIndex(
+    ([key]) => key === options.defaultStrategy,
+  );
+
+  if (defaultStrategyIndex < 0) {
+    throw new Error(
+      `Default strategy "${options.defaultStrategy}" is not registered.`,
+    );
+  }
+
+  const behavior = options.unknownStrategyBehavior ?? 'throw';
+  const selectorInject = options.selector?.inject ?? [];
+
+  return {
+    provide: options.provide,
+    useFactory: async (...args: any[]) => {
+      const strategyInstances = args.slice(
+        0,
+        strategyEntries.length,
+      ) as TStrategy[];
+      const selectorArgs = args.slice(strategyEntries.length);
+      const configuredStrategy = normalizeStrategyKey(
+        await options.selector?.useFactory?.(...selectorArgs),
+      );
+      const selectedStrategy = configuredStrategy ?? options.defaultStrategy;
+      const selectedStrategyIndex = strategyEntries.findIndex(
+        ([key]) => key === selectedStrategy,
+      );
+
+      if (selectedStrategyIndex >= 0) {
+        return strategyInstances[selectedStrategyIndex];
+      }
+
+      if (behavior === 'fallback') {
+        return strategyInstances[defaultStrategyIndex];
+      }
+
+      const availableStrategies = strategyEntries
+        .map(([key]) => key)
+        .join(', ');
+      throw new Error(
+        `Unknown strategy "${selectedStrategy}". Available strategies: ${availableStrategies}.`,
+      );
+    },
+    inject: [
+      ...strategyEntries.map(([, strategyToken]) => strategyToken),
+      ...selectorInject,
+    ],
+  };
+}
+
+export function ApiCallStrategySelectorProvider(
+  options: StrategySelectorProviderOptions<IApiCallStrategy>,
+): Provider<IApiCallStrategy> {
+  return StrategySelectorProvider(options);
+}
+
+export function EventStrategySelectorProvider(
+  options: StrategySelectorProviderOptions<IEventStrategy>,
+): Provider<IEventStrategy> {
+  return StrategySelectorProvider(options);
+}