cabloy 5.1.219 → 5.1.221

package/scripts/strictGenerationDiagnostics.ts

@@ -0,0 +1,61 @@
+import type { StdioOptions } from 'node:child_process';
+
+import { Writable } from 'node:stream';
+
+import { requiresFreshTestResources } from '../vona/packages-vona/vona-core/src/lib/core/testStrictMode.ts';
+
+export type StrictGenerationStage =
+  | 'arguments'
+  | 'preparation'
+  | 'startup'
+  | 'operation'
+  | 'shutdown'
+  | 'operation-and-shutdown'
+  | 'generator'
+  | 'cleanup'
+  | 'run';
+
+const failureStages = new WeakMap<object, StrictGenerationStage>();
+
+export class StrictGenerationError extends Error {
+  readonly stage: StrictGenerationStage;
+
+  constructor(stage: StrictGenerationStage) {
+    super(`Strict contract generation failed: ${stage}`);
+    this.name = 'StrictGenerationError';
+    this.stage = stage;
+    failureStages.set(this, stage);
+  }
+}
+
+export function strictGenerationFailure(stage: StrictGenerationStage, error?: unknown) {
+  const previous = error && typeof error === 'object' ? failureStages.get(error) : undefined;
+  return new StrictGenerationError(previous ?? stage);
+}
+
+export function usesStrictGeneration(env: NodeJS.ProcessEnv): boolean {
+  try {
+    return requiresFreshTestResources(env);
+  } catch {
+    throw new StrictGenerationError('arguments');
+  }
+}
+
+export function guardianStdio(strict: boolean): StdioOptions {
+  return strict ? ['ignore', 'ignore', 'ignore', 'ipc'] : ['inherit', 'inherit', 'inherit', 'ipc'];
+}
+
+export function discardNativeOutput() {
+  const discard = () =>
+    new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      },
+    });
+  return { stdout: discard(), stderr: discard() };
+}
+
+export function reportIsolatedDiagnostic(strict: boolean, category: string, value?: unknown) {
+  if (strict) console.error(`Strict contract generation: ${category}`);
+  else console.error(value);
+}

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/package.original.json

@@ -2,7 +2,7 @@
   "name": "vona",
   "private": true,
   "type": "module",
-  "packageManager": "pnpm@11.5.2",
+  "packageManager": "pnpm@12.14.0",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "repository": {
     "type": "git",
@@ -15,7 +15,8 @@
   },
   "homepage": "https://github.com/vonajs/vona#readme",
   "engines": {
-    "node": ">=24.4.0"
+    "node": ">=24.4.0",
+    "pnpm": ">=11.5.2"
   },
   "scripts": {
     "vona": "node ./packages-cli/cli/src/bin/vona.ts",

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.165",
+  "version": "1.1.167",
   "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.165",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.dev.ts

@@ -5,7 +5,7 @@ import { BeanCliBase } from '@cabloy/cli';
 import { spawn } from 'node:child_process';
 import nodemon from 'nodemon';
 import { rimraf } from 'rimraf';
-import { resolveVonaLocalPaths } from 'vona-core';
+import { requiresFreshTestResources, resolveVonaLocalPaths } from 'vona-core';
 
 import type { VonaBinConfigOptions } from './toolsBin/types.ts';
 
@@ -48,16 +48,21 @@ export class CliBinDev extends BeanCliBase {
     const workers = resolveTestWorkers(mode, argv.workers);
     const flavor: VonaMetaFlavor = argv.flavor || 'normal';
     const configMeta: VonaConfigMeta = { flavor, mode };
+    const strict = requiresFreshTestResources();
     const paths = resolveVonaLocalPaths(projectPath, mode);
+    if (strict && (mode !== 'test' || !paths.runId)) {
+      throw new Error('Strict generation requires an isolated test run in test mode');
+    }
     const configOptions: VonaBinConfigOptions = {
       appDir: projectPath,
       runtimeDir: paths.generatedDir,
       workers,
     };
     try {
-      const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+      const { env, modulesMeta } = await generateVonaMeta(configMeta, configOptions);
       if (mode === 'test') {
-        await this._runTest(projectPath);
+        if (strict) await this._runTest(projectPath, env);
+        else await this._runTest(projectPath);
       } else {
         await this._run(projectPath, modulesMeta);
       }
@@ -66,7 +71,11 @@ export class CliBinDev extends BeanCliBase {
     }
   }
 
-  async _runTest(projectPath: string) {
+  async _runTest(projectPath: string, resolvedEnv?: NodeJS.ProcessEnv) {
+    const strict = requiresFreshTestResources();
+    if (strict && !resolvedEnv) {
+      throw new Error('Strict generation requires resolved environment handoff');
+    }
     const generatedDir = resolveVonaLocalPaths(projectPath, 'test').generatedDir;
     const child = spawn(
       process.execPath,
@@ -74,6 +83,7 @@ export class CliBinDev extends BeanCliBase {
       {
         cwd: projectPath,
         stdio: 'inherit',
+        ...(strict ? { env: { ...process.env, ...resolvedEnv } } : {}),
       },
     );
     const forwardSignal = (signal: NodeJS.Signals) => child.kill(signal);

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/generateEntryFiles.ts

@@ -10,6 +10,7 @@ import type { VonaBinConfigOptions } from './types.ts';
 
 import { resolveTemplatePath } from '../../../utils.ts';
 import { copyTemplateFile, getEnvMeta } from '../../utils.ts';
+import { validateGenerationPaths } from './validateGenerationPaths.ts';
 // import { generateZod } from './generateZod.ts';
 
 export async function generateEntryFiles(
@@ -18,6 +19,7 @@ export async function generateEntryFiles(
   modulesMeta: Awaited<ReturnType<typeof glob>>,
   env: NodeJS.ProcessEnv,
 ) {
+  const strict = validateGenerationPaths(configMeta, configOptions);
   // config
   await __generateConfig();
   // modules meta
@@ -103,7 +105,10 @@ export async function generateEntryFiles(
   }
 
   async function __generateEnvJson() {
-    const contentDest = `export default ${JSON.stringify(env, null, 2)} as unknown as NodeJS.ProcessEnv;\n`;
+    // Strict generation retains the selected app.meta.env surface, never its resolved values.
+    const contentDest = strict
+      ? `const keys = ${JSON.stringify(Object.keys(env).filter(key => env[key] !== undefined))};\nexport default Object.fromEntries(keys.filter(key => process.env[key] !== undefined).map(key => [key, process.env[key]])) as NodeJS.ProcessEnv;\n`
+      : `export default ${JSON.stringify(env, null, 2)} as unknown as NodeJS.ProcessEnv;\n`;
     // output
     const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'env.ts');
     fse.ensureFileSync(fileDest);

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/generateVonaMeta.ts

@@ -1,24 +1,16 @@
 import type { VonaConfigMeta } from '@cabloy/module-info';
 
-import { assertTestRunOwner, resolveVonaLocalPaths } from 'vona-core';
-
 import type { VonaBinConfigOptions } from './types.ts';
 
 import { createConfigUtils } from './configUtils.ts';
 import { generateEntryFiles } from './generateEntryFiles.ts';
+import { validateGenerationPaths } from './validateGenerationPaths.ts';
 
 export async function generateVonaMeta(
   configMeta: VonaConfigMeta,
   configOptions: VonaBinConfigOptions,
 ) {
-  const paths = resolveVonaLocalPaths(configOptions.appDir, configMeta.mode);
-  if (paths.runId) {
-    if (configOptions.runtimeDir !== paths.generatedDir) {
-      throw new Error('Isolated test generated directory does not match its run ID');
-    }
-    assertTestRunOwner(paths.dataRoot, paths.runId);
-    assertTestRunOwner(paths.generatedRoot, paths.runId);
-  }
+  validateGenerationPaths(configMeta, configOptions);
   // config utils
   const configUtils = createConfigUtils(configMeta, configOptions);
   // env

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/validateGenerationPaths.ts

@@ -0,0 +1,27 @@
+import type { VonaConfigMeta } from '@cabloy/module-info';
+
+import { assertTestRunOwner, requiresFreshTestResources, resolveVonaLocalPaths } from 'vona-core';
+
+import type { VonaBinConfigOptions } from './types.ts';
+
+export function validateGenerationPaths(
+  configMeta: VonaConfigMeta,
+  configOptions: VonaBinConfigOptions,
+) {
+  const strict = requiresFreshTestResources();
+  if (strict && configMeta.mode !== 'test') {
+    throw new Error('Strict generation requires test mode');
+  }
+  const paths = resolveVonaLocalPaths(configOptions.appDir, configMeta.mode);
+  if (strict && !paths.runId) {
+    throw new Error('Strict generation requires an isolated test run');
+  }
+  if (paths.runId) {
+    if (configOptions.runtimeDir !== paths.generatedDir) {
+      throw new Error('Isolated test generated directory does not match its run ID');
+    }
+    assertTestRunOwner(paths.dataRoot, paths.runId);
+    assertTestRunOwner(paths.generatedRoot, paths.runId);
+  }
+  return strict;
+}

package/vona/packages-cli/cli-set-api/test/binDevLifecycle.test.ts

@@ -26,7 +26,7 @@ const source = `
     '@cabloy/cli': 'export class BeanCliBase {}',
     'nodemon': 'export default globalThis.nodemonMock;',
     'rimraf': 'export function rimraf() { throw new Error("Unexpected cleanup"); }',
-    'vona-core': 'export function resolveVonaLocalPaths() { throw new Error("Unexpected app access"); }',
+    'vona-core': 'export function resolveVonaLocalPaths() { throw new Error("Unexpected app access"); } export function requiresFreshTestResources() { return false; }',
     '../utils.ts': 'export function getImportEsm() { return "--import=./.vona/register.js"; }',
     './toolsBin/generateVonaMeta.ts': 'export function generateVonaMeta() { throw new Error("Unexpected generation"); }',
   };