cabloy 5.1.203 → 5.1.205

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

@@ -0,0 +1,139 @@
+import { register, createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+// Register before dynamically importing source config/framework (decorators and
+// workspace TS exports). Dependencies resolve from this checkout's Vona install.
+register(import.meta.resolve('ts-node-maintained/esm'), pathToFileURL(`${process.cwd()}/`));
+const require = createRequire(pathToFileURL(path.join(process.cwd(), 'package.json')));
+let queue = Promise.resolve();
+let claim: import('vona-core').TestClaimManifest | undefined;
+let config: import('./resolveTestCleanupConfig.ts').TestCleanupResolvedConfig | undefined;
+
+process.on('message', (message: any) => {
+  if (!message || !Number.isSafeInteger(message.id) || typeof message.command !== 'string') return;
+  queue = queue
+    .then(async () => {
+      let ok = false;
+      try {
+        if (message.command === 'prepare') {
+          if (claim || typeof message.claimPath !== 'string')
+            throw new Error('Invalid cleanup initialization');
+          const inventory = await import('vona-core');
+          claim = await inventory.loadTestClaim(message.claimPath);
+          if (claim.projectPath !== process.cwd() || claim.runId !== process.env.VONA_TEST_RUN_ID)
+            throw new Error('Cleanup process identity mismatch');
+          config = await (
+            await import('./resolveTestCleanupConfig.ts')
+          ).resolveTestCleanupConfig(claim);
+        } else if (message.command === 'database') {
+          if (!claim || !config) throw new Error('Cleanup not initialized');
+          const database = claim.databases.find(
+            db => db.clientName === message.clientName && db.scope === message.scope,
+          );
+          if (
+            !database ||
+            !database.creations.some(item => item.name === message.name) ||
+            database.endpoint.dialect === 'better-sqlite3'
+          ) {
+            throw new Error('Unknown cleanup database intent');
+          }
+          const options = config.databaseOptions.get(database.clientName)!;
+          const knex = require('knex');
+          const source = options.connection;
+          // Project only supported target/auth/TLS fields. Never carry application
+          // hooks, connectors, search paths, session setup, or pool callbacks.
+          const target: Record<string, any> = {
+            user: source.user,
+            password: source.password,
+            ssl: source.ssl,
+            database: database.endpoint.adminDatabase,
+          };
+          if (database.endpoint.transport === 'tcp') {
+            target.host = database.endpoint.host;
+            target.port = database.endpoint.port;
+          } else if (database.endpoint.dialect === 'pg') {
+            target.host = database.endpoint.socketPath;
+            target.port = database.endpoint.port;
+          } else {
+            target.socketPath = database.endpoint.socketPath;
+          }
+          target.connectionTimeoutMillis = 10000;
+          target.connectTimeout = 10000;
+          const connection = knex({
+            client: database.endpoint.dialect,
+            connection: target,
+            pool: { min: 0, max: 1 },
+            acquireConnectionTimeout: 10000,
+          });
+          const { dropExactCleanupDatabase } = await import('./testCleanupAdapters.ts');
+          const { assertDisposableDatabaseName, getDatabaseTestPrefix, getTestAppName } =
+            await import('vona-core');
+          await dropExactCleanupDatabase(
+            connection,
+            database.endpoint.dialect,
+            message.name,
+            name =>
+              assertDisposableDatabaseName(
+                name,
+                getDatabaseTestPrefix(getTestAppName(claim!.runId), database.scope),
+              ),
+          );
+        } else if (message.command === 'redis') {
+          if (!claim || !config) throw new Error('Cleanup not initialized');
+          const resource = claim.redis.find(item => item.clientName === message.clientName);
+          if (!resource) throw new Error('Unknown cleanup Redis resource');
+          const options = config.redisOptions.get(resource.clientName)!;
+          const Redis = require('ioredis').Redis;
+          const target: Record<string, any> = {
+            username: options.username,
+            password: options.password,
+            tls: options.tls,
+            db: resource.endpoint.db,
+          };
+          if (resource.endpoint.transport === 'socket') {
+            target.path = resource.endpoint.socketPath;
+          } else {
+            target.host = resource.endpoint.host;
+            target.port = resource.endpoint.port;
+          }
+          const connection = new Redis({
+            ...target,
+            keyPrefix: undefined,
+            lazyConnect: true,
+            connectTimeout: 10000,
+            commandTimeout: 10000,
+            retryStrategy: () => null,
+            maxRetriesPerRequest: 0,
+            enableOfflineQueue: false,
+          });
+          // Never emit error details, even if a driver embeds a credential or URL.
+          connection.on('error', () => {});
+          try {
+            await connection.connect();
+            const { clearExactRedisPrefix } = await import('./testCleanupAdapters.ts');
+            const { getTestClaimRedisPrefix } = await import('vona-core');
+            await clearExactRedisPrefix(connection, resource.prefix, prefix => {
+              if (prefix !== getTestClaimRedisPrefix(claim!.runId, resource.clientName)?.prefix)
+                throw new Error('Foreign cleanup prefix');
+            });
+          } finally {
+            connection.disconnect();
+          }
+        } else if (message.command === 'close') {
+          config = undefined;
+          claim = undefined;
+        } else {
+          throw new Error('Unknown cleanup operation');
+        }
+        ok = true;
+      } catch {
+        /* The IPC protocol deliberately contains no raw errors/config. */
+      }
+      if (process.connected) process.send?.({ id: message.id, ok });
+    })
+    .catch(() => {});
+});
+process.on('disconnect', () => {
+  process.exit(0);
+});

package/vona/packages-cli/cli-set-api/src/lib/utils.ts

@@ -82,7 +82,6 @@ export function copyTemplateIfNeed(fileSrc: string, fileDest: string) {
   }
 }
 
-export function getImportEsm() {
-  // return '--loader=ts-node/esm';
-  return '--import=./.vona/register.js';
+export function getImportEsm(runtimeDir = '.vona') {
+  return `--import=./${runtimeDir}/register.js`;
 }

package/vona/packages-cli/cli-set-api/templates/config/_tsconfig_project.json

@@ -5,6 +5,7 @@
   },
   "include": [
     ".vona/**/*.ts",
+    ".vona-test-*/**/*.ts",
     "src/backend/package.json",
     "src/backend/config",
     "src/backend/play",

package/vona/packages-cli/cli-set-api/templates/config/_tsconfig_source.json

@@ -5,6 +5,7 @@
   },
   "include": [
     ".vona/**/*.ts",
+    ".vona-test-*/**/*.ts",
     "src/backend/package.json",
     "src/backend/config",
     "src/backend/play",

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

@@ -4,6 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { describe, it } from 'node:test';
 
+import { CliBinDbReset } from '../src/lib/bean/cli.bin.dbReset.ts';
 import { CliBinDev, resolveDevMode, resolveTestWorkers } from '../src/lib/bean/cli.bin.dev.ts';
 import command from '../src/lib/command/bin.dev.ts';
 
@@ -31,6 +32,23 @@ describe('bin.dev mode', () => {
     }
   });
 
+  it('launches db:reset with dev-mode generated runtime', async () => {
+    const cli = Object.create(CliBinDbReset.prototype) as CliBinDbReset;
+    const calls: Array<{ cmd: string; args: string[]; options: { cwd: string } }> = [];
+    Object.defineProperty(cli, 'helper', {
+      value: {
+        spawnExe: async options => {
+          calls.push(options);
+        },
+      },
+    });
+    await cli._run('/tmp/vona-reset-project', {} as never);
+    assert.equal(calls.length, 1);
+    assert.deepEqual(calls[0].args.slice(0, 1), ['--import=./.vona/register.js']);
+    assert.match(calls[0].args[1], /dbReset\.ts$/);
+    assert.equal(calls[0].args[2], '/tmp/vona-reset-project');
+  });
+
   it('supervises test-mode bootstrap exit without starting a server', async () => {
     const projectPath = mkdtempSync(join(tmpdir(), 'vona-bin-dev-mode-'));
     try {

package/vona/packages-cli/cli-set-api/toolsIsolate/dbReset.ts

@@ -6,6 +6,19 @@ const projectPath = argv[0];
 await dbResetRun(projectPath);
 
 async function dbResetRun(projectPath: string) {
-  await createGeneralApp(projectPath);
-  await closeApp();
+  if (process.env.META_MODE !== 'dev') {
+    throw new Error('db:reset requires dev mode');
+  }
+  const previousReset = process.env.VONA_DB_RESET;
+  process.env.VONA_DB_RESET = 'true';
+  try {
+    await createGeneralApp(projectPath);
+  } finally {
+    try {
+      await closeApp();
+    } finally {
+      if (previousReset === undefined) delete process.env.VONA_DB_RESET;
+      else process.env.VONA_DB_RESET = previousReset;
+    }
+  }
 }

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

@@ -6,5 +6,6 @@
     "declaration": true,
     "emitDeclarationOnly": true
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["src/lib/bean/toolsBin/*.test.ts"]
 }

package/vona/packages-utils/babel-plugin-vona-bean-module/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-vona-bean-module",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "babel-plugin-vona-bean-module",
   "keywords": [

package/vona/packages-utils/babel-plugin-vona-bean-module/src/index.test.ts

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import { isValidBeanModuleFile } from './index.ts';
+
+test('excludes timestamped generated Vona roots from bean module transforms', () => {
+  assert.equal(
+    isValidBeanModuleFile('/project/vona/.vona-test-20261014010203-a1b2c3d4/app.ts'),
+    false,
+  );
+  assert.equal(
+    isValidBeanModuleFile('C:\\project\\vona\\.vona-test-20261014010203-a1b2c3d4\\app.ts'),
+    false,
+  );
+  assert.equal(isValidBeanModuleFile('/project/vona/src/module/foo/src/index.ts'), true);
+});

package/vona/packages-utils/babel-plugin-vona-bean-module/src/index.ts

@@ -65,7 +65,7 @@ function __parseBeanInfo(state) {
 }
 
 function __getModuleName(sourceFileName: string | null | undefined) {
-  if (!__checkIfValid(sourceFileName)) return;
+  if (!isValidBeanModuleFile(sourceFileName)) return;
   const moduleInfo = parseInfoFromPath(sourceFileName);
   if (!moduleInfo) return;
   return moduleInfo.relativeName;
@@ -93,8 +93,9 @@ function __createDecoratorNode(beanInfo) {
 //   }
 // }
 
-function __checkIfValid(fileName?: string | null) {
+export function isValidBeanModuleFile(fileName?: string | null) {
   if (!fileName) return false;
+  if (/[\\/].vona-test-\d{14}-[a-f0-9]{8}[\\/]/.test(fileName)) return false;
   return !['src/boot/app/', '.zova/app/', 'src/backend/', '.vona/'].some(item => {
     return fileName.includes(item);
   });

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

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.103",
+  "version": "5.1.105",
   "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.42",
+  "version": "5.1.44",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [

package/vona/packages-vona/vona-core/src/lib/addon/sqlite3.ts

@@ -11,7 +11,7 @@ export function getSqlite3DatabaseNameDefault(app: VonaApplication) {
   const mode = app.meta.env.META_MODE;
   if (mode !== 'prod') return '';
   const dbPath = path.join(getHomeVonaAppDir(app), 'sqlite3');
-  fse.ensureDirSync(dbPath);
+  if (!app.options.configResolutionOnly) fse.ensureDirSync(dbPath);
   return path.join(dbPath, `${app.name}.db`);
 }
 

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

@@ -6,6 +6,8 @@ import type { PowerPartial } from '../../types/utils/powerPartial.ts';
 import type { VonaApplication } from './application.ts';
 
 import { deepExtend } from '../utils/util.ts';
+import { assertIsolatedTestPath } from './isolationGuard.ts';
+import { assertTestRunOwner, resolveVonaLocalPaths } from './testIsolation.ts';
 
 export type TypeConfigLoader<T> = (app: VonaApplication) => Promise<PowerPartial<T>>;
 
@@ -32,11 +34,18 @@ export function getLoggerPathPhysicalRoot(app: VonaApplication) {
   const mode = app.meta.env.META_MODE;
   let loggerDir: string;
   if (mode === 'test' || mode === 'dev') {
-    loggerDir = path.join(app.projectPath, '.app/logs');
+    loggerDir = resolveVonaLocalPaths(
+      app.projectPath,
+      mode,
+      app.meta.env.VONA_TEST_RUN_ID,
+    ).logsRoot;
   } else {
     loggerDir = path.join(getHomeVonaAppDir(app), 'logs');
   }
-  fse.ensureDirSync(loggerDir);
+  if (!app.options.configResolutionOnly) {
+    assertOwnedLocalPath(app, loggerDir, 'logsRoot');
+    fse.ensureDirSync(loggerDir);
+  }
   return loggerDir;
 }
 
@@ -44,11 +53,18 @@ export function getPublicPathPhysicalRoot(app: VonaApplication) {
   const mode = app.meta.env.META_MODE;
   let publicDir: string;
   if (mode === 'test' || mode === 'dev') {
-    publicDir = path.join(app.projectPath, '.app/public');
+    publicDir = resolveVonaLocalPaths(
+      app.projectPath,
+      mode,
+      app.meta.env.VONA_TEST_RUN_ID,
+    ).publicRoot;
   } else {
     publicDir = path.join(getHomeVonaAppDir(app), 'public');
   }
-  fse.ensureDirSync(publicDir);
+  if (!app.options.configResolutionOnly) {
+    assertOwnedLocalPath(app, publicDir, 'publicRoot');
+    fse.ensureDirSync(publicDir);
+  }
   return publicDir;
 }
 
@@ -56,14 +72,36 @@ export function getRuntimePathPhysicalRoot(app: VonaApplication) {
   const mode = app.meta.env.META_MODE;
   let runtimeDir: string;
   if (mode === 'test' || mode === 'dev') {
-    runtimeDir = path.join(app.options.projectPath, '.app/runtime');
+    runtimeDir = resolveVonaLocalPaths(
+      app.options.projectPath,
+      mode,
+      app.meta.env.VONA_TEST_RUN_ID,
+    ).runtimeRoot;
   } else {
     runtimeDir = path.join(getHomeVonaAppDir(app), 'runtime');
   }
-  fse.ensureDirSync(runtimeDir);
+  if (!app.options.configResolutionOnly) {
+    assertOwnedLocalPath(app, runtimeDir, 'runtimeRoot');
+    fse.ensureDirSync(runtimeDir);
+  }
   return runtimeDir;
 }
 
+function assertOwnedLocalPath(
+  app: VonaApplication,
+  actual: string,
+  leaf: 'logsRoot' | 'publicRoot' | 'runtimeRoot',
+) {
+  const paths = resolveVonaLocalPaths(
+    app.projectPath,
+    app.meta.env.META_MODE,
+    app.meta.env.VONA_TEST_RUN_ID,
+  );
+  if (!paths.runId) return;
+  assertTestRunOwner(paths.dataRoot, paths.runId);
+  assertIsolatedTestPath(actual, paths[leaf]);
+}
+
 export function getHomeVonaAppDir(app: VonaApplication) {
   return path.join(os.homedir(), '.vona', app.name);
 }

package/vona/packages-vona/vona-core/src/lib/core/configCleanup.test.ts

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import { lstat, mkdir, mkdtemp, realpath, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+
+import { getSqlite3DatabaseNameDefault } from '../addon/sqlite3.ts';
+import {
+  getLoggerPathPhysicalRoot,
+  getPublicPathPhysicalRoot,
+  getRuntimePathPhysicalRoot,
+} from './config.ts';
+import { resolveVonaLocalPaths } from './testIsolation.ts';
+
+test('internal config resolution computes canonical paths without creating or requiring released roots', async () => {
+  const parent = await mkdtemp(path.join(await realpath(os.tmpdir()), 'cleanup-config-'));
+  const projectPath = path.join(parent, 'vona');
+  await mkdir(projectPath);
+  const runId = '20261011010203-deadbeef';
+  const app = {
+    projectPath,
+    name: `cabtest${runId}`,
+    options: { projectPath, configResolutionOnly: true },
+    meta: { env: { META_MODE: 'test', VONA_TEST_RUN_ID: runId } },
+  } as any;
+  try {
+    const expected = resolveVonaLocalPaths(projectPath, 'test', runId);
+    assert.equal(getPublicPathPhysicalRoot(app), expected.publicRoot);
+    assert.equal(getRuntimePathPhysicalRoot(app), expected.runtimeRoot);
+    assert.equal(getLoggerPathPhysicalRoot(app), expected.logsRoot);
+    assert.equal(getSqlite3DatabaseNameDefault(app), '');
+    await assert.rejects(lstat(expected.dataRoot), { code: 'ENOENT' });
+    await assert.rejects(lstat(expected.generatedRoot), { code: 'ENOENT' });
+    app.options.configResolutionOnly = false;
+    assert.throws(() => getPublicPathPhysicalRoot(app));
+    await assert.rejects(lstat(expected.dataRoot), { code: 'ENOENT' });
+  } finally {
+    await rm(parent, { recursive: true, force: true });
+  }
+});

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

@@ -2,8 +2,11 @@ export * from './application.ts';
 export * from './config.ts';
 export * from './hmr.ts';
 export * from './hmrDeps.ts';
+export * from './isolationGuard.ts';
 export * from './locales.ts';
 export * from './logger/index.ts';
 export * from './meta.ts';
 export * from './metadata.ts';
 export * from './resource.ts';
+export * from './testClaim.ts';
+export * from './testIsolation.ts';