cabloy 5.1.219 → 5.1.220

package/scripts/strictGenerationStartup.test.ts

@@ -0,0 +1,212 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { registerHooks } from 'node:module';
+import { after, test } from 'node:test';
+import ts from 'typescript';
+
+const root = new URL('../vona/src/suite-vendor/a-vona/modules/', import.meta.url);
+const databaseUrl = new URL('a-version/src/service/database.ts', root).href;
+const startupUrl = new URL('a-startup/src/service/startup.ts', root).href;
+const helperUrl = new URL('a-version/src/lib/databaseTestName.ts', root).href;
+const isolationUrl = new URL(
+  '../vona/packages-vona/vona-core/src/lib/core/testIsolation.ts',
+  import.meta.url,
+).href;
+let strict = true;
+let ready = true;
+const mocks = {
+  'vona': `
+    export class BeanBase {}
+    export function assertFreshTestResourcesReady() { globalThis.__strictGenerationTest.ready(); }
+    export function requiresFreshTestResources() { return globalThis.__strictGenerationTest.strict(); }
+    export function assertIsolatedTestConfig() {}
+    export function assertIsolatedTestPath() {}
+    export function assertTestRunOwner() {}
+    export function resolveVonaLocalPaths() { return { dataRoot: '/synthetic' }; }
+    export async function withIsolatedTestDatabaseDiscovery(_app, _name, _client, fn) { return await fn(); }
+    export function cast(value) { return value; }
+    export function getRuntimePathPhysicalRoot() { throw new Error('must not get mutating runtime path'); }
+    export { createDatabaseTestName, getDatabaseTestPrefix } from ${JSON.stringify(helperUrl)};
+    export { assertDisposableDatabaseName } from ${JSON.stringify(isolationUrl)};
+  `,
+  'vona-module-a-bean': 'export function Service() { return value => value; }',
+  'fs-extra':
+    'export default { async remove() { throw new Error("must not remove directory"); } };',
+};
+
+// Execute the real service bodies; replace only framework collaborators. No app or drivers.
+const previous = Object.getOwnPropertyDescriptor(globalThis, '__strictGenerationTest');
+Object.defineProperty(globalThis, '__strictGenerationTest', {
+  configurable: true,
+  value: {
+    strict: () => strict,
+    ready: () => {
+      if (!ready) throw new Error('freshness missing');
+    },
+  },
+});
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if ([databaseUrl, startupUrl].includes(context.parentURL ?? '') && mocks[specifier]) {
+      return {
+        url: `data:text/javascript,${encodeURIComponent(mocks[specifier])}`,
+        shortCircuit: true,
+      };
+    }
+    if (context.parentURL === helperUrl && specifier === 'vona') {
+      return { url: isolationUrl, shortCircuit: true };
+    }
+    return nextResolve(specifier, context);
+  },
+  load(url, context, nextLoad) {
+    if ([databaseUrl, startupUrl].includes(url)) {
+      const source = ts.transpileModule(readFileSync(new URL(url), 'utf8'), {
+        compilerOptions: {
+          experimentalDecorators: true,
+          target: ts.ScriptTarget.ESNext,
+          module: ts.ModuleKind.ESNext,
+        },
+      }).outputText;
+      return { format: 'module', source, shortCircuit: true };
+    }
+    return nextLoad(url, context);
+  },
+});
+let ServiceDatabase: any;
+let ServiceStartup: any;
+try {
+  ({ ServiceDatabase } = await import(databaseUrl));
+  ({ ServiceStartup } = await import(startupUrl));
+} finally {
+  hooks.deregister();
+}
+
+function databaseFixture(existing: string[] = []) {
+  let current = 'postgres';
+  const calls: string[] = [];
+  const app = { name: 'synthetic', meta: { isTest: true, isDev: false, isProd: false, env: {} } };
+  const client = {
+    clientName: 'main',
+    db: { dialectName: 'pg' },
+    getDatabaseName: () => current,
+    connection: {
+      schema: {
+        fetchDatabases: async () => {
+          calls.push('discover');
+          return existing.map(name => ({ name }));
+        },
+        createDatabase: async (name: string) => {
+          calls.push('create');
+          existing.push(name);
+          return name;
+        },
+        dropDatabase: async () => {
+          throw new Error('must not drop');
+        },
+      },
+    },
+    changeConfigConnectionAndReloadWorker: async (name: string) => {
+      calls.push('reload');
+      current = name;
+    },
+  };
+  const service = Object.create(ServiceDatabase.prototype);
+  Object.defineProperties(service, {
+    app: { value: app },
+    bean: { value: { database: { current: { client } } } },
+    $logger: { value: { silly() {} } },
+  });
+  return {
+    service,
+    calls,
+    setCurrent: (name: string) => {
+      current = name;
+    },
+  };
+}
+
+// This file owns the collaborator sentinel for its entire isolated node:test process.
+// Restore it after every test has settled, including assertions that fail.
+after(() => {
+  if (previous) Object.defineProperty(globalThis, '__strictGenerationTest', previous);
+  else Reflect.deleteProperty(globalThis, '__strictGenerationTest');
+});
+
+test('strict database startup refuses preexisting matches and unowned selected targets without deletion', async () => {
+  strict = true;
+  ready = true;
+  const f = databaseFixture(['vona-test-synthetic-s-20261019-010203']);
+  await assert.rejects(f.service.__prepareDatabaseInner(), /no longer fresh/);
+  assert.deepEqual(f.calls, ['discover']);
+  f.setCurrent('vona-test-synthetic-s-20261019-010203');
+  await assert.rejects(f.service.__prepareDatabaseInner(), /unowned database/);
+  assert.deepEqual(f.calls, ['discover']);
+});
+
+test('strict database startup creates once and reuses only its successful own creation', async () => {
+  strict = true;
+  ready = true;
+  const f = databaseFixture();
+  await f.service.__prepareDatabaseInner();
+  await f.service.__prepareDatabaseInner();
+  assert.deepEqual(f.calls, ['discover', 'create', 'reload']);
+  f.setCurrent('vona-test-synthetic-s-20261019-010203');
+  await assert.rejects(f.service.__prepareDatabaseInner(), /unowned database/);
+  ready = false;
+  await assert.rejects(f.service.__prepareDatabaseInner(), /freshness missing/);
+  ready = true;
+});
+
+test('strict startup bypasses clearing only with established proof and does not bypass later startups', async () => {
+  strict = true;
+  ready = true;
+  const calls: string[] = [];
+  const service = Object.create(ServiceStartup.prototype);
+  Object.defineProperties(service, {
+    app: { value: { meta: { isTest: true, isDev: false, env: {} } } },
+    $scope: {
+      value: {
+        redis: {
+          service: {
+            redis: {
+              clearAllData: async () => {
+                throw new Error('must not clear Redis');
+              },
+            },
+          },
+        },
+      },
+    },
+    bean: {
+      value: {
+        onion: {
+          startup: {
+            getOnionsEnabledCached: () => [{ name: 'synthetic', beanOptions: { options: {} } }],
+          },
+        },
+      },
+    },
+    runStartup: {
+      value: async () => {
+        calls.push('startup');
+      },
+    },
+  });
+  await service.appStart();
+  assert.deepEqual(calls, ['startup']);
+  ready = false;
+  await assert.rejects(service.appStart(), /freshness missing/);
+  assert.deepEqual(calls, ['startup']);
+  ready = true;
+});
+
+test('ordinary test database selected-target behavior remains unchanged without strict flag', async () => {
+  strict = false;
+  ready = false;
+  const f = databaseFixture();
+  f.setCurrent('vona-test-synthetic-s-20261019-010203');
+  await f.service.__prepareDatabaseInner();
+  assert.deepEqual(f.calls, []);
+  strict = true;
+  ready = true;
+});

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.165",
+  "version": "1.1.166",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.163",
+  "version": "1.1.164",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.110",
+  "version": "5.1.111",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/packages-vona/vona-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-core",
-  "version": "5.1.47",
+  "version": "5.1.48",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [

package/vona/packages-vona/vona-core/src/lib/bean/beanBase.ts

@@ -4,6 +4,8 @@ import type { ILoggerChildRecord, ILoggerClientRecord } from '../../types/interf
 // import type { IModuleLocaleText } from './resource/locale/type.ts';
 import type { IBeanScopeContainer } from './scope/beanScopeContainer.ts';
 
+import { getSuppressedDiagnosticLogger } from '../core/logger/diagnosticLogger.ts';
+import { getRequestBoundary } from '../core/requestBoundary.ts';
 import { BeanBaseSimple, SymbolBeanInstanceKey, SymbolModuleBelong } from './beanBaseSimple.ts';
 
 // const SymbolText = Symbol('SymbolText');
@@ -30,6 +32,7 @@ export class BeanBase extends BeanBaseSimple {
   }
 
   protected $loggerClient(clientName: keyof ILoggerClientRecord = 'default') {
+    if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
     if (!this[SymbolLogger][clientName]) {
       this[SymbolLogger][clientName] = this.app.meta.logger
         .get(clientName)
@@ -42,6 +45,7 @@ export class BeanBase extends BeanBaseSimple {
     childName: keyof ILoggerChildRecord,
     clientName: keyof ILoggerClientRecord = 'default',
   ) {
+    if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
     if (!this[SymbolLoggerChildren][clientName])
       this[SymbolLoggerChildren][clientName] = {} as never;
     if (!this[SymbolLoggerChildren][clientName][childName]) {

package/vona/packages-vona/vona-core/src/lib/core/asyncLocalStorage.ts

@@ -2,9 +2,17 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 
 import type { VonaContext } from '../../types/context/index.ts';
 import type { VonaApplication } from './application.ts';
+import type {
+  RequestBoundaryCapture,
+  VonaScopeOutcome,
+  VonaScopeOutcomeObserver,
+} from './requestBoundary.ts';
+
+import { captureRequestBoundary } from './requestBoundary.ts';
 
 export class VonaAsyncLocalStorage extends AsyncLocalStorage<VonaContext> {
   app: VonaApplication;
+  private readonly observedRuns = new WeakMap<VonaContext, { settled: boolean }>();
 
   constructor(app: VonaApplication) {
     super();
@@ -20,18 +28,82 @@ export class VonaAsyncLocalStorage extends AsyncLocalStorage<VonaContext> {
     if (store === this.app.currentContext) {
       return await callback(...args);
     }
-    return super.run(
-      store,
-      async (...args) => {
-        try {
-          this.app.meta.ctxCounter.increment();
-          return await callback(...args);
-        } finally {
-          await store.bean.dispose();
-          this.app.meta.ctxCounter.decrement();
+    if (this.observedRuns.has(store)) throw new Error('Context scope already owned');
+    return this._runOwned(store, () => callback(...args));
+  }
+
+  async runObserved<R>(
+    store: VonaContext,
+    callback: () => R,
+    observer: VonaScopeOutcomeObserver,
+  ): Promise<R> {
+    if (store === this.app.currentContext || this.observedRuns.has(store)) {
+      throw new Error('Context scope already owned');
+    }
+    const frame = { settled: false };
+    this.observedRuns.set(store, frame);
+    try {
+      return await this._runOwned(store, callback, observer);
+    } finally {
+      frame.settled = true;
+    }
+  }
+
+  private _runOwned<R>(
+    store: VonaContext,
+    callback: () => R,
+    observer?: VonaScopeOutcomeObserver,
+  ): Promise<R> {
+    const capture = captureRequestBoundary();
+    return super.run(store, async () => {
+      try {
+        this.app.meta.ctxCounter.increment();
+        return await callback();
+      } finally {
+        await this._disposeOwned(store, observer, capture);
+      }
+    });
+  }
+
+  private async _disposeOwned(
+    store: VonaContext,
+    observer: VonaScopeOutcomeObserver | undefined,
+    capture: RequestBoundaryCapture | undefined,
+  ): Promise<void> {
+    try {
+      await store.bean.dispose();
+    } catch (error) {
+      this._notifyScopeOutcome(observer, 'dispose_failed', capture);
+      throw error;
+    }
+    try {
+      this.app.meta.ctxCounter.decrement();
+    } catch (error) {
+      capture?.reportFailure('diagnostic_failed');
+      throw error;
+    }
+    this._notifyScopeOutcome(observer, 'disposed', capture);
+  }
+
+  private _notifyScopeOutcome(
+    observer: VonaScopeOutcomeObserver | undefined,
+    outcome: VonaScopeOutcome,
+    capture: RequestBoundaryCapture | undefined,
+  ): void {
+    if (!observer) return;
+    try {
+      const result: unknown = observer(outcome);
+      if (result && (typeof result === 'object' || typeof result === 'function')) {
+        const then = (result as PromiseLike<unknown>).then;
+        if (typeof then === 'function') {
+          capture?.reportFailure('observer_failed');
+          void new Promise<unknown>((resolve, reject) => {
+            then.call(result, resolve, reject);
+          }).catch(() => {});
         }
-      },
-      ...args,
-    );
+      }
+    } catch {
+      capture?.reportFailure('observer_failed');
+    }
   }
 }

package/vona/packages-vona/vona-core/src/lib/core/index.ts

@@ -7,6 +7,20 @@ export * from './locales.ts';
 export * from './logger/index.ts';
 export * from './meta.ts';
 export * from './metadata.ts';
+export type {
+  RequestBoundary,
+  RequestBoundaryCapture,
+  RequestBoundaryFailure,
+  VonaScopeOutcome,
+  VonaScopeOutcomeObserver,
+} from './requestBoundary.ts';
+export {
+  captureRequestBoundary,
+  createRequestBoundary,
+  getRequestBoundary,
+  runWithRequestBoundary,
+} from './requestBoundary.ts';
 export * from './resource.ts';
 export * from './testClaim.ts';
 export * from './testIsolation.ts';
+export * from './testFreshness.ts';

package/vona/packages-vona/vona-core/src/lib/core/logger/appLogger.ts

@@ -13,28 +13,36 @@ import type {
 
 import { BeanSimple } from '../../bean/beanSimple.ts';
 import { deepExtend } from '../../utils/util.ts';
+import { getRequestBoundary } from '../requestBoundary.ts';
+import { createDiagnosticLogger, getSuppressedDiagnosticLogger } from './diagnosticLogger.ts';
 
 const SymbolLoggerInstances = Symbol('SymbolLoggerInstances');
+const SymbolRawLoggerInstances = Symbol('SymbolRawLoggerInstances');
 
 export class AppLogger extends BeanSimple {
   private [SymbolLoggerInstances]: Record<keyof ILoggerClientRecord, Winston.Logger> = {} as any;
+  private [SymbolRawLoggerInstances]: Record<keyof ILoggerClientRecord, Winston.Logger> = {} as any;
 
   public async dispose() {
-    for (const key in this[SymbolLoggerInstances]) {
-      const logger = this[SymbolLoggerInstances][key];
+    for (const key in this[SymbolRawLoggerInstances]) {
+      const logger = this[SymbolRawLoggerInstances][key];
       await _closeLogger(logger);
     }
   }
 
   get(clientName?: keyof ILoggerClientRecord) {
+    if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
     clientName = clientName || 'default';
     if (!this[SymbolLoggerInstances][clientName]) {
-      this[SymbolLoggerInstances][clientName] = this._createClient(clientName);
+      const raw = this._createClient(clientName);
+      this[SymbolRawLoggerInstances][clientName] = raw;
+      this[SymbolLoggerInstances][clientName] = createDiagnosticLogger(raw);
     }
     return this[SymbolLoggerInstances][clientName];
   }
 
   child(childName?: keyof ILoggerChildRecord, clientName?: keyof ILoggerClientRecord) {
+    if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
     const logger = this.get(clientName);
     if (!childName) return logger;
     return logger.child({ name: childName });

package/vona/packages-vona/vona-core/src/lib/core/logger/diagnosticLogger.test.ts

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import * as Winston from 'winston';
+import Transport from 'winston-transport';
+
+import { createRequestBoundary, runWithRequestBoundary } from '../requestBoundary.ts';
+import { AppLogger } from './appLogger.ts';
+
+class MemoryTransport extends Transport {
+  count = 0;
+
+  override log(_info: unknown, callback: () => void) {
+    this.count++;
+    callback();
+  }
+}
+
+// No boundary formatter: only the facade can prevent Winston from reading input.
+function fixture() {
+  const sink = new MemoryTransport();
+  const raw = Winston.createLogger({ transports: [sink] });
+  const factory = new AppLogger();
+  let creations = 0;
+  Object.defineProperty(factory, '_createClient', {
+    value() {
+      creations++;
+      return raw;
+    },
+  });
+  const logger = factory.get();
+  return {
+    raw,
+    logger,
+    sink,
+    factory,
+    creations: () => creations,
+    async close() {
+      try {
+        await factory.dispose();
+      } finally {
+        raw.close();
+        sink.close?.();
+      }
+    },
+  };
+}
+
+function payloadProbe() {
+  let reads = 0;
+  return {
+    payload: {
+      get message() {
+        reads++;
+        return 'local';
+      },
+    },
+    reads: () => reads,
+  };
+}
+
+test('cached diagnostic handlers never expose raw Winston to a request boundary', async () => {
+  const local = fixture();
+  const { raw, logger, sink } = local;
+  const exceptions = logger.exceptions;
+  const rejections = logger.rejections;
+  const probe = payloadProbe();
+  try {
+    assert.equal(local.factory.get(), logger);
+    assert.equal(local.creations(), 1);
+    assert.equal(logger.exceptions, exceptions);
+    assert.equal(logger.rejections, rejections);
+    for (const handler of [exceptions, rejections]) {
+      assert.equal(handler.logger, logger);
+      assert.equal(Reflect.set(handler, 'logger', raw), false);
+    }
+    assert.equal(raw.exceptions.logger, raw);
+    assert.equal(raw.rejections.logger, raw);
+    runWithRequestBoundary(createRequestBoundary(), () => {
+      logger.error(probe.payload);
+      logger.exceptions.logger.error(probe.payload);
+      logger.rejections.logger.error(probe.payload);
+      exceptions.logger.error(probe.payload);
+      rejections.logger.error(probe.payload);
+    });
+    assert.equal(probe.reads(), 0);
+    assert.equal(sink.count, 0);
+    for (const handler of [exceptions, rejections]) {
+      const before = probe.reads();
+      handler.logger.error(probe.payload);
+      assert.ok(probe.reads() > before);
+    }
+    assert.equal(sink.count, 2);
+    const before = probe.reads();
+    raw.error(probe.payload);
+    assert.ok(probe.reads() > before);
+    assert.equal(sink.count, 3);
+  } finally {
+    await local.close();
+  }
+});
+
+test('diagnostic handler methods keep their raw receiver and map fluent returns', async () => {
+  const local = fixture();
+  try {
+    for (const key of ['exceptions', 'rejections'] as const) {
+      const rawHandler = local.raw[key];
+      const handler = local.logger[key];
+      const marker = {};
+      const original = rawHandler.getAllInfo;
+      Object.defineProperty(rawHandler, 'getAllInfo', {
+        configurable: true,
+        value(this: typeof rawHandler, value: unknown) {
+          assert.equal(this, rawHandler);
+          assert.equal(value, marker);
+          return this;
+        },
+      });
+      try {
+        assert.equal(handler.handlers, rawHandler.handlers);
+        assert.equal(handler.getAllInfo(marker as any), handler);
+        assert.equal(handler.logger, local.logger);
+      } finally {
+        Object.defineProperty(rawHandler, 'getAllInfo', {
+          configurable: true,
+          value: original,
+        });
+      }
+    }
+    const exceptions = local.logger.exceptions;
+    const rejections = local.logger.rejections;
+    local.logger.configure({ transports: [local.sink] });
+    assert.notEqual(local.logger.exceptions, exceptions);
+    assert.notEqual(local.logger.rejections, rejections);
+    assert.equal(local.logger.exceptions.logger, local.logger);
+    assert.equal(local.logger.rejections.logger, local.logger);
+    assert.equal(exceptions.logger, local.logger);
+    assert.equal(rejections.logger, local.logger);
+    runWithRequestBoundary(createRequestBoundary(), () => {
+      exceptions.logger.error('local');
+      rejections.logger.error('local');
+    });
+    assert.equal(local.sink.count, 0);
+  } finally {
+    await local.close();
+  }
+});