@nest-yalc-2/api-strategy 2.2.1 → 2.2.3

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

@@ -1,76 +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();
-  }
-}
+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.ts

@@ -1,70 +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.')
-    );
-  }
-}
+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.ts

@@ -1,54 +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;
-  }
-}
+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.ts

@@ -1,67 +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;
-  }
-}
+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;
+  }
+}