@futdevpro/nts-dynamo 1.15.151 → 1.15.154

package/src/_services/server/app-safe-diagnostic.spec.ts

@@ -0,0 +1,124 @@
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import { DyNTS_Http_Settings } from '../../_models/control-models/http-settings.control-model';
+import { DyNTS_GlobalService_Settings } from '../../_models/interfaces/global-service-settings.interface';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_App } from './app.server';
+
+class DyNTS_SafeDiagnosticTestApp extends DyNTS_App {
+  protected override asyncConstruct(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Supplies the minimal valid application parameters for the boundary test. */
+  getAppParams(): DyNTS_App_Params {
+    return new DyNTS_App_Params({
+      name: 'SafeDiagnosticTestApp',
+      version: '1.0.0',
+      dbName: 'safe_diagnostic_test',
+    });
+  }
+
+  /** Keeps the test application independent from concrete global services. */
+  getGlobalServiceCollection(): DyNTS_GlobalService_Settings {
+    return {};
+  }
+
+  /** Keeps the test application independent from a listening HTTP server. */
+  getPortSettings(): DyNTS_Http_Settings {
+    return new DyNTS_Http_Settings();
+  }
+}
+
+class DyNTS_FailingBootstrapTestApp extends DyNTS_SafeDiagnosticTestApp {
+  protected override asyncConstruct(): Promise<void> {
+    return Promise.reject(new Error(DyNTS_FailingBootstrapTestApp.canary));
+  }
+
+  static readonly canary: string = 'mongodb://bootstrap-user:bootstrap-secret@private-host.example/database';
+}
+
+describe('| DyNTS_App safe process boundary', (): void => {
+  const rejectionCanary: string = 'mongodb://rejection-user:rejection-secret@private-host.example/database';
+  let originalHandler: typeof DyNTS_GlobalService.globalErrorHandler;
+  let initialListeners: NodeJS.UnhandledRejectionListener[];
+
+  beforeEach((): void => {
+    originalHandler = DyNTS_GlobalService.globalErrorHandler;
+    initialListeners = process.listeners('unhandledRejection');
+  });
+
+  afterEach((): void => {
+    DyNTS_GlobalService.globalErrorHandler = originalHandler;
+    process.listeners('unhandledRejection').forEach((listener: NodeJS.UnhandledRejectionListener): void => {
+      if (!initialListeners.includes(listener)) {
+        process.removeListener('unhandledRejection', listener);
+      }
+    });
+  });
+
+  it('| projects an unhandled rejection before logging or forwarding it', async (): Promise<void> => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+    const handlerSpy: jasmine.Spy = jasmine.createSpy('globalErrorHandler').and.resolveTo();
+
+    DyNTS_GlobalService.globalErrorHandler = handlerSpy;
+    new DyNTS_SafeDiagnosticTestApp();
+
+    const addedListeners: NodeJS.UnhandledRejectionListener[] = process
+      .listeners('unhandledRejection')
+      .filter((listener: NodeJS.UnhandledRejectionListener): boolean => !initialListeners.includes(listener));
+
+    expect(addedListeners.length).toBe(1);
+    addedListeners[0](new Error(rejectionCanary), Promise.resolve());
+    await Promise.resolve();
+
+    const serializedLogs: string = JSON.stringify(logSpy.calls.allArgs());
+    const serializedForwardedError: string = JSON.stringify(handlerSpy.calls.mostRecent().args[0]);
+
+    expect(serializedLogs).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('DYNTS-AS0-BASE-UR');
+    expect(handlerSpy.calls.mostRecent().args.length).toBe(1);
+    expect(serializedLogs).not.toContain(rejectionCanary);
+    expect(serializedLogs).not.toContain('rejection-secret');
+    expect(serializedForwardedError).not.toContain(rejectionCanary);
+    expect(serializedForwardedError).not.toContain('rejection-secret');
+  });
+
+  it('| projects a bootstrap rejection before logging, forwarding and exiting', async (): Promise<void> => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+    const handlerSpy: jasmine.Spy = jasmine.createSpy('globalErrorHandler').and.resolveTo();
+    const exitSpy: jasmine.Spy = spyOn(process, 'exit');
+
+    DyNTS_GlobalService.globalErrorHandler = handlerSpy;
+    new DyNTS_FailingBootstrapTestApp();
+    await new Promise<void>((resolve: () => void): NodeJS.Immediate => setImmediate(resolve));
+
+    const serializedLogs: string = JSON.stringify(logSpy.calls.allArgs());
+    const serializedForwardedError: string = JSON.stringify(handlerSpy.calls.mostRecent().args[0]);
+
+    expect(exitSpy).toHaveBeenCalledOnceWith(1);
+    expect(serializedLogs).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('DYNTS-AS0-BOOTSTRAP-FAILED');
+    expect(handlerSpy.calls.mostRecent().args.length).toBe(1);
+    expect(serializedLogs).not.toContain(DyNTS_FailingBootstrapTestApp.canary);
+    expect(serializedLogs).not.toContain('bootstrap-secret');
+    expect(serializedForwardedError).not.toContain(DyNTS_FailingBootstrapTestApp.canary);
+    expect(serializedForwardedError).not.toContain('bootstrap-secret');
+  });
+
+  it('| projects raw failures in the default global error handler', async (): Promise<void> => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+
+    await DyNTS_GlobalService.setServices({});
+    await DyNTS_GlobalService.globalErrorHandler(new Error(rejectionCanary));
+
+    const serializedLogs: string = JSON.stringify(logSpy.calls.allArgs());
+
+    expect(serializedLogs).toContain('dynts-safe-diagnostic/1');
+    expect(serializedLogs).not.toContain(rejectionCanary);
+    expect(serializedLogs).not.toContain('rejection-secret');
+  });
+});

package/src/_services/server/app.server-retention.spec.ts

@@ -1,106 +1,106 @@
-import { DyNTS_App, DyNTS_TtlIndexAction, DyNTS_TtlIndexCollection, DyNTS_TtlIndexInfo } from './app.server';
-
-/**
- * FR-258 / SR-2 — unit tests for the retention TTL-index reconciliation logic
- * (`DyNTS_App.ensureRetentionTtlIndex`). Pure with respect to a mockable native-driver collection;
- * no live MongoDB required. Covers create / no-op / differs(boot-safe, no rebuild) and edge cases.
- */
-describe('| DyNTS_App.ensureRetentionTtlIndex (FR-258 / SR-2)', () => {
-
-  interface MockColl {
-    coll: DyNTS_TtlIndexCollection;
-    created: { keys: Record<string, number>; options: { expireAfterSeconds: number } }[];
-    dropped: string[];
-  }
-
-  function makeMockCollection(existing: DyNTS_TtlIndexInfo[], opts?: { noIndexesFn?: boolean }): MockColl {
-    const created: { keys: Record<string, number>; options: { expireAfterSeconds: number } }[] = [];
-    const dropped: string[] = [];
-    const coll: DyNTS_TtlIndexCollection = {
-      createIndex: async (keys: Record<string, number>, options: { expireAfterSeconds: number }): Promise<string> => {
-        created.push({ keys: keys, options: options });
-        return '__created_1';
-      },
-      dropIndex: async (name: string): Promise<void> => { dropped.push(name); },
-    };
-    if (!opts?.noIndexesFn) {
-      coll.indexes = async (): Promise<DyNTS_TtlIndexInfo[]> => existing;
-    }
-    return { coll: coll, created: created, dropped: dropped };
-  }
-
-  const TTL_14D: number = 14 * 86400;
-
-  it('| no existing __created index → creates a TTL index (action "created")', async () => {
-    const m: MockColl = makeMockCollection([]);
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, TTL_14D);
-    expect(action).toBe('created');
-    expect(m.created.length).toBe(1);
-    expect(m.created[0].keys).toEqual({ __created: 1 });
-    expect(m.created[0].options).toEqual({ expireAfterSeconds: TTL_14D });
-    expect(m.dropped.length).toBe(0);
-  });
-
-  it('| existing index with the SAME ttl → no-op (action "noop", no create, no drop)', async () => {
-    const m: MockColl = makeMockCollection([
-      { name: '__created_1', key: { __created: 1 }, expireAfterSeconds: TTL_14D },
-    ]);
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, TTL_14D);
-    expect(action).toBe('noop');
-    expect(m.created.length).toBe(0);
-    expect(m.dropped.length).toBe(0);
-  });
-
-  it('| existing index with a DIFFERENT ttl → BOOT-SAFE: left untouched (action "differs", NO drop/recreate)', async () => {
-    const m: MockColl = makeMockCollection([
-      { name: '__created_1', key: { __created: 1 }, expireAfterSeconds: 999 },
-    ]);
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, TTL_14D);
-    expect(action).toBe('differs');
-    // Critical: never rebuild a live index at boot (heavy op on large collections → health-probe starvation).
-    expect(m.dropped.length).toBe(0);
-    expect(m.created.length).toBe(0);
-  });
-
-  it('| existing NON-TTL __created index (no expireAfterSeconds) → BOOT-SAFE: left untouched (action "differs")', async () => {
-    const m: MockColl = makeMockCollection([
-      { name: '__created_1', key: { __created: 1 } },
-    ]);
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, 604800);
-    expect(action).toBe('differs');
-    expect(m.dropped.length).toBe(0);
-    expect(m.created.length).toBe(0);
-  });
-
-  it('| ignores indexes on OTHER fields — only reconciles { __created: 1 }', async () => {
-    const m: MockColl = makeMockCollection([
-      { name: 'project_1', key: { project: 1 }, expireAfterSeconds: 50 },
-      { name: '_id_', key: { _id: 1 } },
-    ]);
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, 86400);
-    expect(action).toBe('created');
-    expect(m.created.length).toBe(1);
-    expect(m.dropped.length).toBe(0);
-  });
-
-  it('| no indexes() method available → treats as none and creates', async () => {
-    const m: MockColl = makeMockCollection([], { noIndexesFn: true });
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, 86400);
-    expect(action).toBe('created');
-    expect(m.created.length).toBe(1);
-  });
-
-  it('| indexes() rejecting → treated as empty (resilient), still creates', async () => {
-    const created: { keys: Record<string, number>; options: { expireAfterSeconds: number } }[] = [];
-    const coll: DyNTS_TtlIndexCollection = {
-      indexes: async (): Promise<DyNTS_TtlIndexInfo[]> => { throw new Error('boom'); },
-      createIndex: async (keys: Record<string, number>, options: { expireAfterSeconds: number }): Promise<string> => {
-        created.push({ keys: keys, options: options });
-        return 'x';
-      },
-    };
-    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(coll, 86400);
-    expect(action).toBe('created');
-    expect(created.length).toBe(1);
-  });
-});
+import { DyNTS_App, DyNTS_TtlIndexAction, DyNTS_TtlIndexCollection, DyNTS_TtlIndexInfo } from './app.server';
+
+/**
+ * FR-258 / SR-2 — unit tests for the retention TTL-index reconciliation logic
+ * (`DyNTS_App.ensureRetentionTtlIndex`). Pure with respect to a mockable native-driver collection;
+ * no live MongoDB required. Covers create / no-op / differs(boot-safe, no rebuild) and edge cases.
+ */
+describe('| DyNTS_App.ensureRetentionTtlIndex (FR-258 / SR-2)', () => {
+
+  interface MockColl {
+    coll: DyNTS_TtlIndexCollection;
+    created: { keys: Record<string, number>; options: { expireAfterSeconds: number } }[];
+    dropped: string[];
+  }
+
+  function makeMockCollection(existing: DyNTS_TtlIndexInfo[], opts?: { noIndexesFn?: boolean }): MockColl {
+    const created: { keys: Record<string, number>; options: { expireAfterSeconds: number } }[] = [];
+    const dropped: string[] = [];
+    const coll: DyNTS_TtlIndexCollection = {
+      createIndex: async (keys: Record<string, number>, options: { expireAfterSeconds: number }): Promise<string> => {
+        created.push({ keys: keys, options: options });
+        return '__created_1';
+      },
+      dropIndex: async (name: string): Promise<void> => { dropped.push(name); },
+    };
+    if (!opts?.noIndexesFn) {
+      coll.indexes = async (): Promise<DyNTS_TtlIndexInfo[]> => existing;
+    }
+    return { coll: coll, created: created, dropped: dropped };
+  }
+
+  const TTL_14D: number = 14 * 86400;
+
+  it('| no existing __created index → creates a TTL index (action "created")', async () => {
+    const m: MockColl = makeMockCollection([]);
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, TTL_14D);
+    expect(action).toBe('created');
+    expect(m.created.length).toBe(1);
+    expect(m.created[0].keys).toEqual({ __created: 1 });
+    expect(m.created[0].options).toEqual({ expireAfterSeconds: TTL_14D });
+    expect(m.dropped.length).toBe(0);
+  });
+
+  it('| existing index with the SAME ttl → no-op (action "noop", no create, no drop)', async () => {
+    const m: MockColl = makeMockCollection([
+      { name: '__created_1', key: { __created: 1 }, expireAfterSeconds: TTL_14D },
+    ]);
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, TTL_14D);
+    expect(action).toBe('noop');
+    expect(m.created.length).toBe(0);
+    expect(m.dropped.length).toBe(0);
+  });
+
+  it('| existing index with a DIFFERENT ttl → BOOT-SAFE: left untouched (action "differs", NO drop/recreate)', async () => {
+    const m: MockColl = makeMockCollection([
+      { name: '__created_1', key: { __created: 1 }, expireAfterSeconds: 999 },
+    ]);
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, TTL_14D);
+    expect(action).toBe('differs');
+    // Critical: never rebuild a live index at boot (heavy op on large collections → health-probe starvation).
+    expect(m.dropped.length).toBe(0);
+    expect(m.created.length).toBe(0);
+  });
+
+  it('| existing NON-TTL __created index (no expireAfterSeconds) → BOOT-SAFE: left untouched (action "differs")', async () => {
+    const m: MockColl = makeMockCollection([
+      { name: '__created_1', key: { __created: 1 } },
+    ]);
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, 604800);
+    expect(action).toBe('differs');
+    expect(m.dropped.length).toBe(0);
+    expect(m.created.length).toBe(0);
+  });
+
+  it('| ignores indexes on OTHER fields — only reconciles { __created: 1 }', async () => {
+    const m: MockColl = makeMockCollection([
+      { name: 'project_1', key: { project: 1 }, expireAfterSeconds: 50 },
+      { name: '_id_', key: { _id: 1 } },
+    ]);
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, 86400);
+    expect(action).toBe('created');
+    expect(m.created.length).toBe(1);
+    expect(m.dropped.length).toBe(0);
+  });
+
+  it('| no indexes() method available → treats as none and creates', async () => {
+    const m: MockColl = makeMockCollection([], { noIndexesFn: true });
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(m.coll, 86400);
+    expect(action).toBe('created');
+    expect(m.created.length).toBe(1);
+  });
+
+  it('| indexes() rejecting → treated as empty (resilient), still creates', async () => {
+    const created: { keys: Record<string, number>; options: { expireAfterSeconds: number } }[] = [];
+    const coll: DyNTS_TtlIndexCollection = {
+      indexes: async (): Promise<DyNTS_TtlIndexInfo[]> => { throw new Error('boom'); },
+      createIndex: async (keys: Record<string, number>, options: { expireAfterSeconds: number }): Promise<string> => {
+        created.push({ keys: keys, options: options });
+        return 'x';
+      },
+    };
+    const action: DyNTS_TtlIndexAction = await DyNTS_App.ensureRetentionTtlIndex(coll, 86400);
+    expect(action).toBe('created');
+    expect(created.length).toBe(1);
+  });
+});