cabloy 5.1.220 → 5.1.222

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

@@ -1,10 +1,22 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { afterEach, beforeEach, test } from 'node:test';
 import * as Winston from 'winston';
 import Transport from 'winston-transport';
 
 import { createRequestBoundary, runWithRequestBoundary } from '../requestBoundary.ts';
+import { requiresFreshTestResources, TEST_REQUIRE_FRESH_RESOURCES_ENV } from '../testStrictMode.ts';
 import { AppLogger } from './appLogger.ts';
+import { getSuppressedDiagnosticLogger } from './diagnosticLogger.ts';
+
+let previousStrictFlag: string | undefined;
+beforeEach(() => {
+  previousStrictFlag = process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+});
+afterEach(() => {
+  if (previousStrictFlag === undefined) delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  else process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = previousStrictFlag;
+});
 
 class MemoryTransport extends Transport {
   count = 0;
@@ -58,87 +70,275 @@ function payloadProbe() {
   };
 }
 
-test('cached diagnostic handlers never expose raw Winston to a request boundary', async () => {
+function throwingProbe() {
+  let reads = 0;
+  const read = () => {
+    reads++;
+    throw new Error('Synthetic logger input must not be evaluated');
+  };
+  return {
+    value: new Proxy({}, { get: read, ownKeys: read }),
+    read,
+    reads: () => reads,
+  };
+}
+
+test(
+  'cached diagnostic handlers never expose raw Winston to a request boundary',
+  { concurrency: false },
+  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(), () => {
+        assert.equal(local.factory.get(), getSuppressedDiagnosticLogger());
+        assert.equal(local.factory.get('unconfigured' as any), getSuppressedDiagnosticLogger());
+        assert.equal(local.factory.child('synthetic' as any), getSuppressedDiagnosticLogger());
+        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',
+  { concurrency: false },
+  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();
+    }
+  },
+);
+
+test('strict logger bypasses cached clients and payloads', { concurrency: false }, async () => {
   const local = fixture();
-  const { raw, logger, sink } = local;
-  const exceptions = logger.exceptions;
-  const rejections = logger.rejections;
-  const probe = payloadProbe();
+  const probe = throwingProbe();
   try {
-    assert.equal(local.factory.get(), logger);
+    process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+    const suppressed = getSuppressedDiagnosticLogger();
+    assert.equal(local.factory.get(), suppressed);
+    assert.equal(local.factory.get('unconfigured' as any), suppressed);
+    assert.equal(local.factory.child('synthetic' as any), suppressed);
+    assert.equal(local.factory.child('synthetic' as any, 'unconfigured' as any), suppressed);
+    assert.notEqual(suppressed, local.logger);
+    assert.equal(suppressed.error(probe.value), suppressed);
+    assert.equal(suppressed.info(probe.value), suppressed);
+    assert.equal(suppressed.log(probe.value as any), suppressed);
+    assert.equal(suppressed.child(probe.value), suppressed);
+    assert.equal(suppressed.startTimer().done(probe.value), suppressed);
+    let completions = 0;
+    assert.equal(
+      suppressed.write(probe.value, () => completions++),
+      true,
+    );
+    assert.equal(completions, 1);
+    assert.equal(probe.reads(), 0);
     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(local.sink.count, 0);
+    delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+    assert.equal(local.factory.get(), local.logger);
+    local.factory.child().info('ordinary logging remains available');
+    assert.equal(local.sink.count, 1);
+  } finally {
+    await local.close();
+  }
+});
+
+test('strict entry guards precede cache and app access', { concurrency: false }, async () => {
+  const local = fixture();
+  const probe = throwingProbe();
+  const descriptors = Object.getOwnPropertyDescriptors(local.factory);
+  const cacheKeys = Object.getOwnPropertySymbols(local.factory);
+  try {
+    assert.equal(cacheKeys.length, 2);
+    for (const key of cacheKeys) {
+      Object.defineProperty(local.factory, key, { configurable: true, get: probe.read });
     }
-    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);
-    });
+    Object.defineProperty(local.factory, 'app', { configurable: true, get: probe.read });
+    process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+    assert.equal(local.factory.get(), getSuppressedDiagnosticLogger());
+    assert.equal(local.factory.get(probe.value as any), getSuppressedDiagnosticLogger());
+    Object.defineProperty(local.factory, 'get', { configurable: true, get: probe.read });
+    assert.equal(local.factory.child(), getSuppressedDiagnosticLogger());
+    assert.equal(
+      local.factory.child(probe.value as any, probe.value as any),
+      getSuppressedDiagnosticLogger(),
+    );
+    assert.equal(local.creations(), 1);
     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);
+    assert.equal(local.sink.count, 0);
   } finally {
+    delete (local.factory as any).get;
+    delete (local.factory as any).app;
+    Object.defineProperties(local.factory, descriptors);
     await local.close();
   }
 });
 
-test('diagnostic handler methods keep their raw receiver and map fluent returns', async () => {
+test('strict logger skips real configuration factories', { concurrency: false }, async () => {
+  const factory = new AppLogger();
+  const probe = throwingProbe();
+  let configurations = 0;
+  Object.defineProperty(factory, 'app', {
+    value: {
+      config: {
+        logger: {
+          base() {
+            configurations++;
+            return probe.read();
+          },
+          clients: {
+            default() {
+              configurations++;
+              return probe.read();
+            },
+          },
+          get baseDir() {
+            return probe.read();
+          },
+          get rotate() {
+            return probe.read();
+          },
+        },
+      },
+    },
+  });
+  try {
+    process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+    assert.equal(factory.get(), getSuppressedDiagnosticLogger());
+    assert.equal(factory.child('synthetic' as any), getSuppressedDiagnosticLogger());
+    assert.equal(configurations, 0);
+    assert.equal(probe.reads(), 0);
+  } finally {
+    await factory.dispose();
+  }
+});
+
+test('strict file transport fails before any input access', { concurrency: false }, () => {
+  const factory = new AppLogger();
+  const probe = throwingProbe();
+  const args = [probe.value, probe.value, probe.value] as unknown as Parameters<
+    AppLogger['createTransportFile']
+  >;
+  Object.defineProperty(factory, 'app', { get: probe.read });
+  process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+  assert.throws(() => factory.createTransportFile(...args), {
+    message: 'Strict test file logger transport is disabled',
+  });
+  runWithRequestBoundary(createRequestBoundary(), () => {
+    assert.throws(() => factory.createTransportFile(...args), {
+      message: 'Strict test file logger transport is disabled',
+    });
+  });
+  assert.equal(probe.reads(), 0);
+});
+
+test('invalid strict flags never fall back to loggers', { concurrency: false }, async () => {
   const local = fixture();
+  const probe = throwingProbe();
+  Object.defineProperty(local.factory, 'app', { get: probe.read });
+  const args = [probe.value, probe.value, probe.value] as unknown as Parameters<
+    AppLogger['createTransportFile']
+  >;
   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 env: NodeJS.ProcessEnv = { NODE_ENV: 'test', META_FLAVOR: 'normal', META_MODE: 'test' };
+    assert.equal(requiresFreshTestResources(), false);
+    assert.equal(requiresFreshTestResources(env), false);
+    assert.equal(
+      requiresFreshTestResources({ ...env, [TEST_REQUIRE_FRESH_RESOURCES_ENV]: 'true' }),
+      true,
+    );
+    for (const flag of ['', 'false', 'TRUE', 'synthetic-invalid-flag']) {
+      process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = flag;
+      const expected = { message: 'Invalid strict test resource freshness flag' };
+      assert.throws(() => requiresFreshTestResources(), expected);
+      assert.throws(
+        () => requiresFreshTestResources({ ...env, [TEST_REQUIRE_FRESH_RESOURCES_ENV]: flag }),
+        expected,
+      );
+      const calls = [
+        () => local.factory.get(),
+        () => local.factory.child('synthetic' as any),
+        () => local.factory.createTransportFile(...args),
+      ];
+      for (const call of calls) {
+        assert.throws(call, expected);
+        runWithRequestBoundary(createRequestBoundary(), () => assert.throws(call, expected));
       }
     }
-    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(probe.reads(), 0);
+    assert.equal(local.creations(), 1);
     assert.equal(local.sink.count, 0);
   } finally {
     await local.close();

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

@@ -15,6 +15,7 @@ import type { AppResource } from './resource.ts';
 import { EnumAppEvent } from '../../types/index.ts';
 import { BeanSimple } from '../bean/beanSimple.ts';
 import { AppLocale, BeanScopeContainer } from '../bean/index.ts';
+import { closeCompletedReadiness, createCompletedReadiness } from './completedReadiness.ts';
 import { CtxCounter } from './ctxCounter.ts';
 import { AppHmr } from './hmr.ts';
 import { AppLogger } from './logger/appLogger.ts';
@@ -51,6 +52,8 @@ export class AppMeta extends BeanSimple {
   hmrCacheLocaleModules: TypeModuleResourceLocaleModules;
   hmrCacheConfigModules: IBeanScopeConfig;
   //
+  completedReadiness: ReturnType<typeof createCompletedReadiness>;
+
   appReady: boolean;
   appReadyInstances: Record<string, boolean>;
   //
@@ -61,6 +64,7 @@ export class AppMeta extends BeanSimple {
   appClosed: boolean;
 
   protected __init__(env: VonaConfigEnv) {
+    this.completedReadiness = createCompletedReadiness(this.app);
     // env
     this.env = env;
     this._prepareEnv();
@@ -121,6 +125,7 @@ export class AppMeta extends BeanSimple {
   }
 
   async close() {
+    closeCompletedReadiness(this.completedReadiness);
     if (!this[SymbolClosePromise]) {
       this[SymbolClosePromise] = this._closeInner();
     }

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

@@ -12,17 +12,11 @@ import {
   mergeTestClaimRedisOptions,
 } from './testClaim.ts';
 import { resolveVonaLocalPaths } from './testIsolation.ts';
+import { requiresFreshTestResources } from './testStrictMode.ts';
 
-export const TEST_REQUIRE_FRESH_RESOURCES_ENV = 'VONA_TEST_REQUIRE_FRESH_RESOURCES';
-const freshApps = new WeakSet<VonaApplication>();
+export { requiresFreshTestResources, TEST_REQUIRE_FRESH_RESOURCES_ENV } from './testStrictMode.ts';
 
-export function requiresFreshTestResources() {
-  const value = process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
-  if (value !== undefined && value !== 'true') {
-    throw new Error('Invalid strict test resource freshness flag');
-  }
-  return value === 'true';
-}
+const freshApps = new WeakSet<VonaApplication>();
 
 export function assertFreshTestResourcesReady(app: VonaApplication) {
   if (!requiresFreshTestResources()) return;

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

@@ -0,0 +1,9 @@
+export const TEST_REQUIRE_FRESH_RESOURCES_ENV = 'VONA_TEST_REQUIRE_FRESH_RESOURCES';
+
+export function requiresFreshTestResources(env: NodeJS.ProcessEnv = process.env) {
+  const value = env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  if (value !== undefined && value !== 'true') {
+    throw new Error('Invalid strict test resource freshness flag');
+  }
+  return value === 'true';
+}

package/vona/packages-vona/vona-core/src/lib/framework/start.test.ts

@@ -31,6 +31,7 @@ const lifecycleSource = `
       return nextResolve(specifier, context);
     },
   });
+  const { createCompletedReadiness } = await import(new URL('../core/completedReadiness.ts', startUrl).href);
   const { Start } = await import(startUrl);
   const [projectPath, lockPath, lockContents, failingPhase] = process.argv.slice(1);
   const phases = [];
@@ -39,6 +40,13 @@ const lifecycleSource = `
   globalThis.phase = async phase => {
     assert.equal(await readFile(lockPath, 'utf8'), lockContents);
     phases.push(phase);
+    assert.equal(app.meta.completedReadiness.snapshot().application, 'starting');
+    if (phase === 'Started') {
+      assert.equal(app.meta.appReady, true);
+      assert.equal(app.meta.appStarted, true);
+      await Promise.resolve();
+      assert.equal(app.meta.completedReadiness.snapshot().application, 'starting');
+    }
     if (phase === failingPhase) throw failure;
   };
   const config = {
@@ -62,6 +70,7 @@ const lifecycleSource = `
       events.push({ event, error, phases: [...phases] });
     },
   };
+  app.meta.completedReadiness = createCompletedReadiness(app);
   const start = new Start(app);
   const order = ['Config', 'Freshness', 'Load', 'Start', 'Ready', 'Started'];
   if (failingPhase) {
@@ -76,6 +85,7 @@ const lifecycleSource = `
     assert.deepEqual(phases, order);
     assert.equal(app.meta.appStartError, undefined);
   }
+  assert.equal(app.meta.completedReadiness.snapshot().application, failingPhase ? 'failed' : 'ready');
   const reachesStarted = !failingPhase || failingPhase === 'Started';
   assert.equal(app.meta.appStarted, reachesStarted ? true : undefined);
   const reachesReady = reachesStarted || failingPhase === 'Ready';

package/vona/packages-vona/vona-core/src/lib/framework/start.ts

@@ -2,6 +2,10 @@ import type { VonaConfig, VonaConfigOptional } from '../../types/index.ts';
 import type { VonaApplication } from '../core/application.ts';
 
 import { EnumAppEvent } from '../../types/index.ts';
+import {
+  beginCompletedApplication,
+  finishCompletedApplication,
+} from '../core/completedReadiness.ts';
 import { assertIsolatedTestConfig } from '../core/isolationGuard.ts';
 import { registerTestClaimResourceInventory } from '../core/testClaim.ts';
 import { assertFreshTestResources } from '../core/testFreshness.ts';
@@ -17,6 +21,8 @@ export class Start {
 
   async start() {
     const app = this.app;
+    const owner = app.meta.completedReadiness;
+    const attempt = beginCompletedApplication(owner);
     try {
       await this._start_appConfig();
       await assertFreshTestResources(app);
@@ -24,7 +30,9 @@ export class Start {
       await this._start_appStart();
       await this._start_appReady();
       await this._start_appStarted();
+      finishCompletedApplication(owner, attempt, true);
     } catch (err) {
+      finishCompletedApplication(owner, attempt, false);
       // record
       app.meta.appStartError = err as Error;
       // event: appReadyError

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-mock",
-  "version": "6.1.48",
+  "version": "6.1.50",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona mock",
   "keywords": [