@nest-yalc-2/api-strategy 1.3.3

package/src/__tests__/strategy-selector.provider.spec.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it } from '@jest/globals';
+import type { IApiCallStrategy } from '../context-call.interface.js';
+import type { IEventStrategy } from '../context-event.interface.js';
+import {
+  ApiCallStrategySelectorProvider,
+  EventStrategySelectorProvider,
+  StrategySelectorProvider,
+} from '../strategy-selector.provider.js';
+
+describe('StrategySelectorProvider', () => {
+  const localStrategy = { name: 'local' };
+  const remoteStrategy = { name: 'remote' };
+
+  it('should create a provider with strategy tokens before selector tokens', () => {
+    const provider = StrategySelectorProvider({
+      provide: 'SELECTED_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_STRATEGY',
+        remote: 'REMOTE_STRATEGY',
+      },
+      selector: {
+        inject: ['CONFIG'],
+        useFactory: () => 'remote',
+      },
+    });
+
+    expect(provider).toMatchObject({
+      provide: 'SELECTED_STRATEGY',
+      inject: ['LOCAL_STRATEGY', 'REMOTE_STRATEGY', 'CONFIG'],
+    });
+  });
+
+  it('should resolve the default strategy when selector is not configured', async () => {
+    const provider = StrategySelectorProvider({
+      provide: 'SELECTED_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_STRATEGY',
+        remote: 'REMOTE_STRATEGY',
+      },
+    });
+
+    await expect(
+      (provider as any).useFactory(localStrategy, remoteStrategy),
+    ).resolves.toBe(localStrategy);
+  });
+
+  it('should resolve the configured strategy from selector args', async () => {
+    const provider = StrategySelectorProvider({
+      provide: 'SELECTED_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_STRATEGY',
+        remote: 'REMOTE_STRATEGY',
+      },
+      selector: {
+        inject: ['CONFIG'],
+        useFactory: (config: { strategy: string }) => config.strategy,
+      },
+    });
+
+    await expect(
+      (provider as any).useFactory(localStrategy, remoteStrategy, {
+        strategy: 'remote',
+      }),
+    ).resolves.toBe(remoteStrategy);
+  });
+
+  it('should trim empty selector results and use the default strategy', async () => {
+    const provider = StrategySelectorProvider({
+      provide: 'SELECTED_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_STRATEGY',
+        remote: 'REMOTE_STRATEGY',
+      },
+      selector: {
+        useFactory: () => '   ',
+      },
+    });
+
+    await expect(
+      (provider as any).useFactory(localStrategy, remoteStrategy),
+    ).resolves.toBe(localStrategy);
+  });
+
+  it('should throw when selected strategy is unknown by default', async () => {
+    const provider = StrategySelectorProvider({
+      provide: 'SELECTED_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_STRATEGY',
+      },
+      selector: {
+        useFactory: () => 'missing',
+      },
+    });
+
+    await expect((provider as any).useFactory(localStrategy)).rejects.toThrow(
+      'Unknown strategy "missing"',
+    );
+  });
+
+  it('should fall back to default when configured to fallback on unknown strategies', async () => {
+    const provider = StrategySelectorProvider({
+      provide: 'SELECTED_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_STRATEGY',
+        remote: 'REMOTE_STRATEGY',
+      },
+      selector: {
+        useFactory: () => 'missing',
+      },
+      unknownStrategyBehavior: 'fallback',
+    });
+
+    await expect(
+      (provider as any).useFactory(localStrategy, remoteStrategy),
+    ).resolves.toBe(localStrategy);
+  });
+
+  it('should throw when no strategies are registered', () => {
+    expect(() =>
+      StrategySelectorProvider({
+        provide: 'SELECTED_STRATEGY',
+        defaultStrategy: 'local',
+        strategies: {},
+      }),
+    ).toThrow('at least one strategy');
+  });
+
+  it('should throw when default strategy is not registered', () => {
+    expect(() =>
+      StrategySelectorProvider({
+        provide: 'SELECTED_STRATEGY',
+        defaultStrategy: 'local',
+        strategies: {
+          remote: 'REMOTE_STRATEGY',
+        },
+      }),
+    ).toThrow('Default strategy "local" is not registered');
+  });
+
+  it('should expose a typed api call strategy selector provider', async () => {
+    const apiStrategy = {
+      call: async () => ({}),
+      get: async () => ({}),
+      post: async () => ({}),
+    } satisfies IApiCallStrategy;
+    const provider = ApiCallStrategySelectorProvider({
+      provide: 'API_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_API_STRATEGY',
+      },
+    });
+
+    await expect((provider as any).useFactory(apiStrategy)).resolves.toBe(
+      apiStrategy,
+    );
+  });
+
+  it('should expose a typed event strategy selector provider', async () => {
+    const eventStrategy = {
+      emit: () => true,
+      emitAsync: async () => true,
+    } satisfies IEventStrategy;
+    const provider = EventStrategySelectorProvider({
+      provide: 'EVENT_STRATEGY',
+      defaultStrategy: 'local',
+      strategies: {
+        local: 'LOCAL_EVENT_STRATEGY',
+      },
+    });
+
+    await expect((provider as any).useFactory(eventStrategy)).resolves.toBe(
+      eventStrategy,
+    );
+  });
+});

package/src/context-call.interface.d.ts

@@ -0,0 +1,12 @@
+export interface IObjectWithData<TData> {
+    data?: TData;
+}
+export interface ICallOptions<TData, TParams extends Record<string, any>> extends IObjectWithData<TData> {
+    data?: TData;
+    parameters?: TParams;
+}
+export interface IApiCallStrategy {
+    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>>;
+}

package/src/context-call.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=context-call.interface.js.map

package/src/context-call.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-call.interface.js","sourceRoot":"","sources":["context-call.interface.ts"],"names":[],"mappings":""}

package/src/context-call.interface.ts

@@ -0,0 +1,49 @@
+export interface IObjectWithData<TData> {
+  data?: TData;
+}
+
+/**
+ * @template TData - type of data to be sent to the server (body data in case of http)
+ * @template TParams - type of parameters to be sent to the server (query params in case of http)
+ */
+export interface ICallOptions<
+  TData,
+  TParams extends Record<string, any>,
+> extends IObjectWithData<TData> {
+  data?: TData;
+  parameters?: TParams;
+}
+
+export interface IApiCallStrategy {
+  /**
+   * @template TOptData - type of data to be sent to the server (body data in case of http)
+   * @template TParams - type of parameters to be sent to the server (query params in case of http)
+   * @template TResData - type of data to be received from the server (response data in case of http)
+   */
+  call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>>;
+  /**
+   * alias for call that retrieves data without side effects (read-only)
+   *
+   * @template TOptData - type of data to be sent to the server (body data in case of http)
+   * @template TParams - type of parameters to be sent to the server (query params in case of http)
+   * @template TResData - type of data to be received from the server (response data in case of http)
+   */
+  get<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>>;
+  /**
+   * alias for call that retrieves data with side effects (creation of a resource, etc.)
+   *
+   * @template TOptData - type of data to be sent to the server (body data in case of http)
+   * @template TParams - type of parameters to be sent to the server (query params in case of http)
+   * @template TResData - type of data to be received from the server (response data in case of http)
+   */
+  post<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: ICallOptions<TOptData, TParams>,
+  ): Promise<IObjectWithData<TResData>>;
+}

package/src/context-call.service.d.ts

@@ -0,0 +1,7 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { IApiCallStrategy } from './context-call.interface.js';
+export interface IApiCallService<Strategy extends IApiCallStrategy> {
+    setStrategy(strategy: Strategy): void;
+    getStrategy(): Strategy;
+}
+export declare function ContextCallServiceFactory<Strategy extends IApiCallStrategy>(defaultStrategy: Strategy): ClassType<IApiCallService<Strategy>>;

package/src/context-call.service.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextCallServiceFactory = ContextCallServiceFactory;
+const common_1 = require("@nestjs/common");
+function ContextCallServiceFactory(defaultStrategy) {
+    let ContextCallService = class ContextCallService {
+        constructor(strategy = defaultStrategy) {
+            this.strategy = strategy;
+        }
+        setStrategy(strategy) {
+            this.strategy = strategy;
+        }
+        getStrategy() {
+            return this.strategy;
+        }
+    };
+    ContextCallService = __decorate([
+        (0, common_1.Injectable)(),
+        __metadata("design:paramtypes", [Object])
+    ], ContextCallService);
+    return ContextCallService;
+}
+//# sourceMappingURL=context-call.service.js.map

package/src/context-call.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-call.service.js","sourceRoot":"","sources":["context-call.service.ts"],"names":[],"mappings":";;;;;;;;;;;AASA,8DAqBC;AA7BD,2CAA4C;AAQ5C,SAAgB,yBAAyB,CACvC,eAAyB;IAEzB,IACM,kBAAkB,GADxB,MACM,kBAAkB;QAKtB,YAAsB,WAAqB,eAAe;YAApC,aAAQ,GAAR,QAAQ,CAA4B;QAAG,CAAC;QAE9D,WAAW,CAAC,QAAkB;YAC5B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC3B,CAAC;QAED,WAAW;YACT,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;KACF,CAAA;IAdK,kBAAkB;QADvB,IAAA,mBAAU,GAAE;;OACP,kBAAkB,CAcvB;IAED,OAAO,kBAAkB,CAAC;AAC5B,CAAC"}

package/src/context-call.service.ts

@@ -0,0 +1,31 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { Injectable } from '@nestjs/common';
+import { IApiCallStrategy } from './context-call.interface.js';
+
+export interface IApiCallService<Strategy extends IApiCallStrategy> {
+  setStrategy(strategy: Strategy): void;
+  getStrategy(): Strategy;
+}
+
+export function ContextCallServiceFactory<Strategy extends IApiCallStrategy>(
+  defaultStrategy: Strategy,
+): ClassType<IApiCallService<Strategy>> {
+  @Injectable()
+  class ContextCallService {
+    /**
+     *
+     * @param strategy - by default, it will use the strategy provided in the factory
+     */
+    constructor(protected strategy: Strategy = defaultStrategy) {}
+
+    setStrategy(strategy: Strategy) {
+      this.strategy = strategy;
+    }
+
+    getStrategy() {
+      return this.strategy;
+    }
+  }
+
+  return ContextCallService;
+}

package/src/context-event.interface.d.ts

@@ -0,0 +1,4 @@
+export interface IEventStrategy<P = any, R = any, O = any> {
+    emit(path: string, payload: P, options?: O): R;
+    emitAsync(path: string, payload: P, options?: O): Promise<R>;
+}

package/src/context-event.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=context-event.interface.js.map

package/src/context-event.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-event.interface.js","sourceRoot":"","sources":["context-event.interface.ts"],"names":[],"mappings":""}

package/src/context-event.interface.ts

@@ -0,0 +1,4 @@
+export interface IEventStrategy<P = any, R = any, O = any> {
+  emit(path: string, payload: P, options?: O): R;
+  emitAsync(path: string, payload: P, options?: O): Promise<R>;
+}

package/src/context-event.service.d.ts

@@ -0,0 +1,7 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { IEventStrategy } from './context-event.interface.js';
+export interface IApiMessageService<Strategy extends IEventStrategy> {
+    setStrategy(strategy: Strategy): void;
+    getStrategy(): Strategy;
+}
+export declare function ContextEventServiceFactory<Strategy extends IEventStrategy>(defaultStrategy: Strategy): ClassType<IApiMessageService<Strategy>>;

package/src/context-event.service.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextEventServiceFactory = ContextEventServiceFactory;
+const common_1 = require("@nestjs/common");
+function ContextEventServiceFactory(defaultStrategy) {
+    let ContextEventService = class ContextEventService {
+        constructor(strategy = defaultStrategy) {
+            this.strategy = strategy;
+        }
+        setStrategy(strategy) {
+            this.strategy = strategy;
+        }
+        getStrategy() {
+            return this.strategy;
+        }
+    };
+    ContextEventService = __decorate([
+        (0, common_1.Injectable)(),
+        __metadata("design:paramtypes", [Object])
+    ], ContextEventService);
+    return ContextEventService;
+}
+//# sourceMappingURL=context-event.service.js.map

package/src/context-event.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-event.service.js","sourceRoot":"","sources":["context-event.service.ts"],"names":[],"mappings":";;;;;;;;;;;AASA,gEAqBC;AA7BD,2CAA4C;AAQ5C,SAAgB,0BAA0B,CACxC,eAAyB;IAEzB,IACM,mBAAmB,GADzB,MACM,mBAAmB;QAKvB,YAAsB,WAAqB,eAAe;YAApC,aAAQ,GAAR,QAAQ,CAA4B;QAAG,CAAC;QAE9D,WAAW,CAAC,QAAkB;YAC5B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC3B,CAAC;QAED,WAAW;YACT,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;KACF,CAAA;IAdK,mBAAmB;QADxB,IAAA,mBAAU,GAAE;;OACP,mBAAmB,CAcxB;IAED,OAAO,mBAAmB,CAAC;AAC7B,CAAC"}

package/src/context-event.service.ts

@@ -0,0 +1,31 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { Injectable } from '@nestjs/common';
+import { IEventStrategy } from './context-event.interface.js';
+
+export interface IApiMessageService<Strategy extends IEventStrategy> {
+  setStrategy(strategy: Strategy): void;
+  getStrategy(): Strategy;
+}
+
+export function ContextEventServiceFactory<Strategy extends IEventStrategy>(
+  defaultStrategy: Strategy,
+): ClassType<IApiMessageService<Strategy>> {
+  @Injectable()
+  class ContextEventService {
+    /**
+     *
+     * @param strategy - by default, it will use the strategy provided in the factory
+     */
+    constructor(protected strategy: Strategy = defaultStrategy) {}
+
+    setStrategy(strategy: Strategy) {
+      this.strategy = strategy;
+    }
+
+    getStrategy() {
+      return this.strategy;
+    }
+  }
+
+  return ContextEventService;
+}

package/src/header-whitelist.helper.d.ts

@@ -0,0 +1,2 @@
+export declare const headerWhitelist: string[];
+export declare function filterHeaders(headers: Record<string, string> | undefined, whitelist?: string[]): {} | undefined;

package/src/header-whitelist.helper.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headerWhitelist = void 0;
+exports.filterHeaders = filterHeaders;
+exports.headerWhitelist = ['Authorization'];
+function filterHeaders(headers, whitelist = exports.headerWhitelist) {
+    return headers
+        ? Object.entries(headers)
+            .filter(([key]) => whitelist.includes(key))
+            .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
+        : headers;
+}
+//# sourceMappingURL=header-whitelist.helper.js.map

package/src/header-whitelist.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-whitelist.helper.js","sourceRoot":"","sources":["header-whitelist.helper.ts"],"names":[],"mappings":";;;AAEA,sCASC;AAXY,QAAA,eAAe,GAAG,CAAC,eAAe,CAAC,CAAC;AAEjD,SAAgB,aAAa,CAC3B,OAA2C,EAC3C,SAAS,GAAG,uBAAe;IAE3B,OAAO,OAAO;QACZ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;aACpB,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;aAC1C,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAClE,CAAC,CAAC,OAAO,CAAC;AACd,CAAC"}

package/src/header-whitelist.helper.ts

@@ -0,0 +1,12 @@
+export const headerWhitelist = ['Authorization'];
+
+export function filterHeaders(
+  headers: Record<string, string> | undefined,
+  whitelist = headerWhitelist,
+) {
+  return headers
+    ? Object.entries(headers)
+        .filter(([key]) => whitelist.includes(key))
+        .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
+    : headers;
+}

package/src/index.d.ts

@@ -0,0 +1,15 @@
+export * from './context-event.service.js';
+export * from './context-event.interface.js';
+export * from './context-call.service.js';
+export * from './context-call.interface.js';
+export * from './strategy-selector.provider.js';
+export * from './strategies/composite-event.strategy.js';
+export * from './strategies/conditional-call.strategy.js';
+export * from './strategies/conditional-event.strategy.js';
+export * from './strategies/fallback-call.strategy.js';
+export * from './strategies/http-abstract-call.strategy.js';
+export * from './strategies/nest-http-call.strategy.js';
+export * from './strategies/nest-local-call.strategy.js';
+export * from './strategies/nest-local-event.strategy.js';
+export * from './strategies/rabbitmq-event.strategy.js';
+export * from './strategies/shadow-call.strategy.js';

package/src/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context-event.service.js"), exports);
+__exportStar(require("./context-event.interface.js"), exports);
+__exportStar(require("./context-call.service.js"), exports);
+__exportStar(require("./context-call.interface.js"), exports);
+__exportStar(require("./strategy-selector.provider.js"), exports);
+__exportStar(require("./strategies/composite-event.strategy.js"), exports);
+__exportStar(require("./strategies/conditional-call.strategy.js"), exports);
+__exportStar(require("./strategies/conditional-event.strategy.js"), exports);
+__exportStar(require("./strategies/fallback-call.strategy.js"), exports);
+__exportStar(require("./strategies/http-abstract-call.strategy.js"), exports);
+__exportStar(require("./strategies/nest-http-call.strategy.js"), exports);
+__exportStar(require("./strategies/nest-local-call.strategy.js"), exports);
+__exportStar(require("./strategies/nest-local-event.strategy.js"), exports);
+__exportStar(require("./strategies/rabbitmq-event.strategy.js"), exports);
+__exportStar(require("./strategies/shadow-call.strategy.js"), exports);
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAEA,6DAA2C;AAC3C,+DAA6C;AAC7C,4DAA0C;AAC1C,8DAA4C;AAC5C,kEAAgD;AAChD,2EAAyD;AACzD,4EAA0D;AAC1D,6EAA2D;AAC3D,yEAAuD;AACvD,8EAA4D;AAC5D,0EAAwD;AACxD,2EAAyD;AACzD,4EAA0D;AAC1D,0EAAwD;AACxD,uEAAqD"}

package/src/index.ts

@@ -0,0 +1,17 @@
+/* istanbul ignore file */
+
+export * from './context-event.service.js';
+export * from './context-event.interface.js';
+export * from './context-call.service.js';
+export * from './context-call.interface.js';
+export * from './strategy-selector.provider.js';
+export * from './strategies/composite-event.strategy.js';
+export * from './strategies/conditional-call.strategy.js';
+export * from './strategies/conditional-event.strategy.js';
+export * from './strategies/fallback-call.strategy.js';
+export * from './strategies/http-abstract-call.strategy.js';
+export * from './strategies/nest-http-call.strategy.js';
+export * from './strategies/nest-local-call.strategy.js';
+export * from './strategies/nest-local-event.strategy.js';
+export * from './strategies/rabbitmq-event.strategy.js';
+export * from './strategies/shadow-call.strategy.js';

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

@@ -0,0 +1,14 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import type { IEventStrategy } from '../context-event.interface.js';
+export type CompositeEventStrategyErrorMode = 'throw' | 'ignore';
+export interface CompositeEventStrategyOptions {
+    errorMode?: CompositeEventStrategyErrorMode;
+}
+export declare class CompositeEventStrategy<P = any, R = any, O = any> implements IEventStrategy<P, R[], O>, OnModuleDestroy {
+    private readonly strategies;
+    private readonly errorMode;
+    constructor(strategies: IEventStrategy<P, R, O>[], options?: CompositeEventStrategyOptions);
+    emit(path: string, payload: P, options?: O): R[];
+    emitAsync(path: string, payload: P, options?: O): Promise<R[]>;
+    onModuleDestroy(): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeEventStrategy = void 0;
+class CompositeEventStrategy {
+    constructor(strategies, options = {}) {
+        this.strategies = strategies;
+        if (strategies.length === 0) {
+            throw new Error('CompositeEventStrategy requires at least one strategy.');
+        }
+        this.errorMode = options.errorMode ?? 'throw';
+    }
+    emit(path, payload, options) {
+        const results = [];
+        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, payload, options) {
+        const settled = await Promise.allSettled(this.strategies.map((strategy) => strategy.emitAsync(path, payload, options)));
+        const results = [];
+        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);
+        }));
+    }
+}
+exports.CompositeEventStrategy = CompositeEventStrategy;
+async function maybeDestroyStrategy(strategy) {
+    const destroyable = strategy;
+    if (typeof destroyable.onModuleDestroy === 'function') {
+        await destroyable.onModuleDestroy();
+    }
+}
+//# sourceMappingURL=composite-event.strategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composite-event.strategy.js","sourceRoot":"","sources":["composite-event.strategy.ts"],"names":[],"mappings":";;;AASA,MAAa,sBAAsB;IAKjC,YACmB,UAAqC,EACtD,UAAyC,EAAE;QAD1B,eAAU,GAAV,UAAU,CAA2B;QAGtD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC;IAChD,CAAC;IAED,IAAI,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QACxC,MAAM,OAAO,GAAQ,EAAE,CAAC;QAExB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACvC,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;YACtD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,IAAI,CAAC,SAAS,KAAK,OAAO,EAAE,CAAC;oBAC/B,MAAM,KAAK,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,IAAY,EAAE,OAAU,EAAE,OAAW;QACnD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CACtC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAC/B,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAC3C,CACF,CAAC;QACF,MAAM,OAAO,GAAQ,EAAE,CAAC;QAExB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;gBAClC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;iBAAM,IAAI,IAAI,CAAC,SAAS,KAAK,OAAO,EAAE,CAAC;gBACtC,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,eAAe;QACnB,MAAM,OAAO,CAAC,GAAG,CACf,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;YACrC,MAAM,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;CACF;AA1DD,wDA0DC;AAED,KAAK,UAAU,oBAAoB,CAAC,QAAiB;IACnD,MAAM,WAAW,GAAG,QAAoC,CAAC;IAEzD,IAAI,OAAO,WAAW,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;QACtD,MAAM,WAAW,CAAC,eAAe,EAAE,CAAC;IACtC,CAAC;AACH,CAAC"}