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

package/src/__tests__/event-strategy-composition.spec.ts

@@ -1,185 +1,185 @@
-import { jest, describe, expect, it } from "@jest/globals";
-import type { IEventStrategy } from "../context-event.interface.js";
-import { CompositeEventStrategy } from "../strategies/composite-event.strategy.js";
-import { ConditionalEventStrategy } from "../strategies/conditional-event.strategy.js";
-
-function eventStrategy(
-  overrides: Partial<IEventStrategy<object, boolean>> & {
-    onModuleDestroy?: () => Promise<void>;
-  } = {}
-) {
-  return {
-    emit: jest.fn(() => true),
-    emitAsync: jest.fn(async () => true),
-    ...overrides,
-  } satisfies IEventStrategy<object, boolean> & {
-    onModuleDestroy?: () => Promise<void>;
-  };
-}
-
-describe("CompositeEventStrategy", () => {
-  it("requires at least one strategy", () => {
-    expect(() => new CompositeEventStrategy([])).toThrow("at least one");
-  });
-
-  it("emits to every strategy synchronously", () => {
-    const first = eventStrategy();
-    const second = eventStrategy({ emit: jest.fn(() => false) });
-    const strategy = new CompositeEventStrategy([first, second]);
-
-    const result = strategy.emit("event.name", { ok: true });
-
-    expect(result).toEqual([true, false]);
-    expect(first.emit).toHaveBeenCalledWith(
-      "event.name",
-      { ok: true },
-      undefined
-    );
-    expect(second.emit).toHaveBeenCalledWith(
-      "event.name",
-      { ok: true },
-      undefined
-    );
-  });
-
-  it("throws sync errors by default", () => {
-    const error = new Error("sync failure");
-    const strategy = new CompositeEventStrategy([
-      eventStrategy({
-        emit: jest.fn(() => {
-          throw error;
-        }),
-      }),
-    ]);
-
-    expect(() => strategy.emit("event.name", {})).toThrow(error);
-  });
-
-  it("ignores sync errors when configured", () => {
-    const strategy = new CompositeEventStrategy(
-      [
-        eventStrategy({
-          emit: jest.fn(() => {
-            throw new Error("sync failure");
-          }),
-        }),
-        eventStrategy(),
-      ],
-      { errorMode: "ignore" }
-    );
-
-    expect(strategy.emit("event.name", {})).toEqual([true]);
-  });
-
-  it("emits to every strategy asynchronously", async () => {
-    const first = eventStrategy();
-    const second = eventStrategy({ emitAsync: jest.fn(async () => false) });
-    const strategy = new CompositeEventStrategy([first, second]);
-
-    await expect(
-      strategy.emitAsync("event.name", { ok: true })
-    ).resolves.toEqual([true, false]);
-  });
-
-  it("throws async errors by default", async () => {
-    const error = new Error("async failure");
-    const strategy = new CompositeEventStrategy([
-      eventStrategy({
-        emitAsync: jest.fn(async () => {
-          throw error;
-        }),
-      }),
-    ]);
-
-    await expect(strategy.emitAsync("event.name", {})).rejects.toThrow(error);
-  });
-
-  it("ignores async errors when configured", async () => {
-    const strategy = new CompositeEventStrategy(
-      [
-        eventStrategy({
-          emitAsync: jest.fn(async () => {
-            throw new Error("async failure");
-          }),
-        }),
-        eventStrategy(),
-      ],
-      { errorMode: "ignore" }
-    );
-
-    await expect(strategy.emitAsync("event.name", {})).resolves.toEqual([true]);
-  });
-
-  it("destroys nested strategies that implement module destroy", async () => {
-    const onModuleDestroy = jest.fn(async () => undefined);
-    const strategy = new CompositeEventStrategy([
-      eventStrategy({ onModuleDestroy }),
-      eventStrategy(),
-    ]);
-
-    await strategy.onModuleDestroy();
-
-    expect(onModuleDestroy).toHaveBeenCalled();
-  });
-});
-
-describe("ConditionalEventStrategy", () => {
-  it("emits when enabled", () => {
-    const target = eventStrategy();
-    const strategy = new ConditionalEventStrategy(target, {
-      enabled: () => true,
-    });
-
-    expect(strategy.emit("event.name", {})).toBe(true);
-    expect(target.emit).toHaveBeenCalled();
-  });
-
-  it("returns the disabled result when disabled", () => {
-    const target = eventStrategy();
-    const strategy = new ConditionalEventStrategy(target, {
-      enabled: false,
-      disabledResult: false,
-    });
-
-    expect(strategy.emit("event.name", {})).toBe(false);
-    expect(target.emit).not.toHaveBeenCalled();
-  });
-
-  it("skips events rejected by the predicate", async () => {
-    const target = eventStrategy();
-    const strategy = new ConditionalEventStrategy(target, {
-      shouldEmit: () => false,
-      disabledResult: false,
-    });
-
-    await expect(strategy.emitAsync("event.name", {})).resolves.toBe(false);
-    expect(target.emitAsync).not.toHaveBeenCalled();
-  });
-
-  it("delegates async events when enabled and accepted", async () => {
-    const target = eventStrategy();
-    const strategy = new ConditionalEventStrategy(target, {
-      shouldEmit: () => true,
-    });
-
-    await expect(strategy.emitAsync("event.name", {})).resolves.toBe(true);
-    expect(target.emitAsync).toHaveBeenCalled();
-  });
-
-  it("destroys the wrapped strategy when supported", async () => {
-    const onModuleDestroy = jest.fn(async () => undefined);
-    const strategy = new ConditionalEventStrategy(
-      eventStrategy({ onModuleDestroy })
-    );
-
-    await strategy.onModuleDestroy();
-
-    expect(onModuleDestroy).toHaveBeenCalled();
-  });
-
-  it("ignores destroy when the wrapped strategy has no lifecycle hook", async () => {
-    const strategy = new ConditionalEventStrategy(eventStrategy());
-
-    await expect(strategy.onModuleDestroy()).resolves.toBeUndefined();
-  });
-});
+import { jest, describe, expect, it } from "@jest/globals";
+import type { IEventStrategy } from "../context-event.interface.js";
+import { CompositeEventStrategy } from "../strategies/composite-event.strategy.js";
+import { ConditionalEventStrategy } from "../strategies/conditional-event.strategy.js";
+
+function eventStrategy(
+  overrides: Partial<IEventStrategy<object, boolean>> & {
+    onModuleDestroy?: () => Promise<void>;
+  } = {}
+) {
+  return {
+    emit: jest.fn(() => true),
+    emitAsync: jest.fn(async () => true),
+    ...overrides,
+  } satisfies IEventStrategy<object, boolean> & {
+    onModuleDestroy?: () => Promise<void>;
+  };
+}
+
+describe("CompositeEventStrategy", () => {
+  it("requires at least one strategy", () => {
+    expect(() => new CompositeEventStrategy([])).toThrow("at least one");
+  });
+
+  it("emits to every strategy synchronously", () => {
+    const first = eventStrategy();
+    const second = eventStrategy({ emit: jest.fn(() => false) });
+    const strategy = new CompositeEventStrategy([first, second]);
+
+    const result = strategy.emit("event.name", { ok: true });
+
+    expect(result).toEqual([true, false]);
+    expect(first.emit).toHaveBeenCalledWith(
+      "event.name",
+      { ok: true },
+      undefined
+    );
+    expect(second.emit).toHaveBeenCalledWith(
+      "event.name",
+      { ok: true },
+      undefined
+    );
+  });
+
+  it("throws sync errors by default", () => {
+    const error = new Error("sync failure");
+    const strategy = new CompositeEventStrategy([
+      eventStrategy({
+        emit: jest.fn(() => {
+          throw error;
+        }),
+      }),
+    ]);
+
+    expect(() => strategy.emit("event.name", {})).toThrow(error);
+  });
+
+  it("ignores sync errors when configured", () => {
+    const strategy = new CompositeEventStrategy(
+      [
+        eventStrategy({
+          emit: jest.fn(() => {
+            throw new Error("sync failure");
+          }),
+        }),
+        eventStrategy(),
+      ],
+      { errorMode: "ignore" }
+    );
+
+    expect(strategy.emit("event.name", {})).toEqual([true]);
+  });
+
+  it("emits to every strategy asynchronously", async () => {
+    const first = eventStrategy();
+    const second = eventStrategy({ emitAsync: jest.fn(async () => false) });
+    const strategy = new CompositeEventStrategy([first, second]);
+
+    await expect(
+      strategy.emitAsync("event.name", { ok: true })
+    ).resolves.toEqual([true, false]);
+  });
+
+  it("throws async errors by default", async () => {
+    const error = new Error("async failure");
+    const strategy = new CompositeEventStrategy([
+      eventStrategy({
+        emitAsync: jest.fn(async () => {
+          throw error;
+        }),
+      }),
+    ]);
+
+    await expect(strategy.emitAsync("event.name", {})).rejects.toThrow(error);
+  });
+
+  it("ignores async errors when configured", async () => {
+    const strategy = new CompositeEventStrategy(
+      [
+        eventStrategy({
+          emitAsync: jest.fn(async () => {
+            throw new Error("async failure");
+          }),
+        }),
+        eventStrategy(),
+      ],
+      { errorMode: "ignore" }
+    );
+
+    await expect(strategy.emitAsync("event.name", {})).resolves.toEqual([true]);
+  });
+
+  it("destroys nested strategies that implement module destroy", async () => {
+    const onModuleDestroy = jest.fn(async () => undefined);
+    const strategy = new CompositeEventStrategy([
+      eventStrategy({ onModuleDestroy }),
+      eventStrategy(),
+    ]);
+
+    await strategy.onModuleDestroy();
+
+    expect(onModuleDestroy).toHaveBeenCalled();
+  });
+});
+
+describe("ConditionalEventStrategy", () => {
+  it("emits when enabled", () => {
+    const target = eventStrategy();
+    const strategy = new ConditionalEventStrategy(target, {
+      enabled: () => true,
+    });
+
+    expect(strategy.emit("event.name", {})).toBe(true);
+    expect(target.emit).toHaveBeenCalled();
+  });
+
+  it("returns the disabled result when disabled", () => {
+    const target = eventStrategy();
+    const strategy = new ConditionalEventStrategy(target, {
+      enabled: false,
+      disabledResult: false,
+    });
+
+    expect(strategy.emit("event.name", {})).toBe(false);
+    expect(target.emit).not.toHaveBeenCalled();
+  });
+
+  it("skips events rejected by the predicate", async () => {
+    const target = eventStrategy();
+    const strategy = new ConditionalEventStrategy(target, {
+      shouldEmit: () => false,
+      disabledResult: false,
+    });
+
+    await expect(strategy.emitAsync("event.name", {})).resolves.toBe(false);
+    expect(target.emitAsync).not.toHaveBeenCalled();
+  });
+
+  it("delegates async events when enabled and accepted", async () => {
+    const target = eventStrategy();
+    const strategy = new ConditionalEventStrategy(target, {
+      shouldEmit: () => true,
+    });
+
+    await expect(strategy.emitAsync("event.name", {})).resolves.toBe(true);
+    expect(target.emitAsync).toHaveBeenCalled();
+  });
+
+  it("destroys the wrapped strategy when supported", async () => {
+    const onModuleDestroy = jest.fn(async () => undefined);
+    const strategy = new ConditionalEventStrategy(
+      eventStrategy({ onModuleDestroy })
+    );
+
+    await strategy.onModuleDestroy();
+
+    expect(onModuleDestroy).toHaveBeenCalled();
+  });
+
+  it("ignores destroy when the wrapped strategy has no lifecycle hook", async () => {
+    const strategy = new ConditionalEventStrategy(eventStrategy());
+
+    await expect(strategy.onModuleDestroy()).resolves.toBeUndefined();
+  });
+});

package/src/__tests__/header-whitelist.helper.spec.ts

@@ -1,30 +1,41 @@
-import { describe, it, expect } from '@jest/globals';
-
-import { filterHeaders } from '../header-whitelist.helper.js';
-
-describe('whitelistHeaders', () => {
-  it('should be defined', () => {
-    expect(filterHeaders).toBeDefined();
-  });
-
-  it('should filter headers', () => {
-    const headers = {
-      'x-header': 'x-header',
-      'x-header-2': 'x-header-2',
-      'x-header-3': 'x-header-3',
-    };
-    const whitelist = ['x-header', 'x-header-2'];
-    const filteredHeaders = filterHeaders(headers, whitelist);
-    expect(filteredHeaders).toEqual({
-      'x-header': 'x-header',
-      'x-header-2': 'x-header-2',
-    });
-  });
-
-  it('should return undefined if headers are undefined', () => {
-    const headers = undefined;
-    const whitelist = ['x-header', 'x-header-2'];
-    const filteredHeaders = filterHeaders(headers, whitelist);
-    expect(filteredHeaders).toBeUndefined();
-  });
-});
+import { describe, it, expect } from '@jest/globals';
+
+import { filterHeaders } from '../header-whitelist.helper.js';
+
+describe('whitelistHeaders', () => {
+  it('should be defined', () => {
+    expect(filterHeaders).toBeDefined();
+  });
+
+  it('should filter headers', () => {
+    const headers = {
+      'x-header': 'x-header',
+      'x-header-2': 'x-header-2',
+      'x-header-3': 'x-header-3',
+    };
+    const whitelist = ['x-header', 'x-header-2'];
+    const filteredHeaders = filterHeaders(headers, whitelist);
+    expect(filteredHeaders).toEqual({
+      'x-header': 'x-header',
+      'x-header-2': 'x-header-2',
+    });
+  });
+
+  it('should return undefined if headers are undefined', () => {
+    const headers = undefined;
+    const whitelist = ['x-header', 'x-header-2'];
+    const filteredHeaders = filterHeaders(headers, whitelist);
+    expect(filteredHeaders).toBeUndefined();
+  });
+
+  it('should use default whitelist', () => {
+    const headers = {
+      'Authorization': 'Bearer 123',
+      'x-header-2': 'x-header-2',
+    };
+    const filteredHeaders = filterHeaders(headers);
+    expect(filteredHeaders).toEqual({
+      'Authorization': 'Bearer 123'
+    });
+  });
+});

package/src/__tests__/http-abstract-call.strategy.spec.ts

@@ -1,17 +1,17 @@
-import {
-  expect,
-  jest,
-  describe,
-  it,
-  beforeEach,
-  beforeAll,
-  afterAll,
-  afterEach,
-} from '@jest/globals';
-import { HttpAbstractStrategy } from '../strategies/http-abstract-call.strategy.js';
-
-describe('HttpAbstractStrategy', () => {
-  it('should be defined', () => {
-    expect(HttpAbstractStrategy).toBeDefined();
-  });
-});
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { HttpAbstractStrategy } from '../strategies/http-abstract-call.strategy.js';
+
+describe('HttpAbstractStrategy', () => {
+  it('should be defined', () => {
+    expect(HttpAbstractStrategy).toBeDefined();
+  });
+});