cabloy 5.1.203 → 5.1.205

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

@@ -0,0 +1,301 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+
+import type { VonaApplication } from './application.ts';
+
+import {
+  assertIsolatedTestConfig,
+  assertIsolatedTestDatabaseClient,
+  withIsolatedTestDatabaseDiscovery,
+} from './isolationGuard.ts';
+import {
+  getDatabaseTestPrefix,
+  getTestAppName,
+  resolveTestRunId,
+  resolveVonaLocalPaths,
+  TEST_RUN_OWNER_FILE,
+} from './testIsolation.ts';
+
+const runId = '20261014010203-a1b2c3d4';
+const appName = `cabtest${runId}`;
+const timestamp = '20261012-123456';
+
+type Client = {
+  client: string;
+  connection: Record<string, unknown>;
+  connectionPool?: unknown;
+};
+
+function createFixture() {
+  const root = mkdtempSync(path.join(realpathSync(tmpdir()), 'cabloy-orm-isolation-'));
+  const projectPath = path.join(root, 'vona');
+  const paths = resolveVonaLocalPaths(projectPath, 'test', runId);
+  for (const ownedRoot of [paths.dataRoot, paths.generatedRoot]) {
+    mkdirSync(ownedRoot, { recursive: true });
+    writeFileSync(path.join(ownedRoot, TEST_RUN_OWNER_FILE), `${runId}\n`);
+  }
+  const client: Client = {
+    client: 'pg',
+    connection: { database: 'postgres', host: '127.0.0.1', port: 5432, user: 'isolated' },
+  };
+  const config = {
+    server: {
+      publicDir: paths.publicRoot,
+      workers: 1,
+      listen: { hostname: '127.0.0.1', port: 42178 },
+      serve: { protocol: 'http', host: '127.0.0.1:42178' },
+    },
+    logger: { baseDir: paths.logsRoot },
+    database: {
+      testDatabase: true,
+      base: {} as { connection?: unknown; connectionPool?: unknown },
+      defaultClient: 'pg',
+      clients: { pg: client } as Record<string, Client>,
+    },
+    instance: {
+      instances: {} as Record<string, false | { isolate: boolean; isolateClient: string }>,
+    },
+    redis: { base: {}, clients: { default: { keyPrefix: true } } },
+  };
+  const app = {
+    projectPath,
+    name: appName,
+    meta: {
+      appReady: false,
+      env: { META_MODE: 'test', VONA_TEST_RUN_ID: runId, SERVER_LISTEN_PORT: '42178' },
+    },
+    config,
+  } as unknown as VonaApplication;
+  return { root, paths, app, config, client };
+}
+
+function disposable(scope = 'share') {
+  return `${getDatabaseTestPrefix(appName, scope)}${timestamp}`;
+}
+
+test('run IDs require a real UTC second and isolate resources with the random suffix', () => {
+  const siblingId = '20261014010203-d4e5f6a7';
+  const first = resolveVonaLocalPaths('/project/vona', 'test', runId);
+  const second = resolveVonaLocalPaths('/project/vona', 'test', siblingId);
+  assert.equal(first.dataDir, '.app-test-20261014010203-a1b2c3d4');
+  assert.equal(first.generatedDir, '.vona-test-20261014010203-a1b2c3d4');
+  assert.notEqual(first.dataDir, second.dataDir);
+  assert.notEqual(getTestAppName(runId), getTestAppName(siblingId));
+  assert.notEqual(
+    getDatabaseTestPrefix(getTestAppName(runId), 'share'),
+    getDatabaseTestPrefix(getTestAppName(siblingId), 'share'),
+  );
+  for (const invalid of [
+    '0123456789abcdef',
+    '20261014010203',
+    '20260230010203-a1b2c3d4',
+    '20261014250203-a1b2c3d4',
+    '20261014010203-A1B2C3D4',
+    '20261014010203-a1b2c3',
+  ]) {
+    assert.throws(() => resolveTestRunId('test', invalid), /UTC timestamp plus eight hex digits/);
+  }
+  assert.throws(() => resolveTestRunId('dev', runId), /requires test mode/);
+  assert.equal(resolveTestRunId('test', runId), runId);
+});
+
+test('administrative discovery accepts only the configured client and target', async () => {
+  const fixture = createFixture();
+  try {
+    const { app, client } = fixture;
+    assertIsolatedTestConfig(app);
+    assert.throws(() => assertIsolatedTestDatabaseClient(app, 'pg', client), /namespace/);
+    await withIsolatedTestDatabaseDiscovery(app, 'pg', client, async () => {
+      assert.doesNotThrow(() => assertIsolatedTestDatabaseClient(app, 'pg', client));
+      const target = { ...client, connection: { ...client.connection, database: disposable() } };
+      assert.doesNotThrow(() => assertIsolatedTestDatabaseClient(app, 'pg', target));
+      for (const connection of [
+        { ...client.connection, host: 'untrusted.example' },
+        { ...client.connection, port: 5433 },
+        { ...client.connection, user: 'another-user' },
+        { ...client.connection, database: 'development' },
+      ]) {
+        assert.throws(
+          () => assertIsolatedTestDatabaseClient(app, 'pg', { ...client, connection }),
+          /namespace/,
+        );
+      }
+      assert.throws(() => assertIsolatedTestDatabaseClient(app, 'dynamic_1', client), /namespace/);
+      assert.throws(
+        () =>
+          assertIsolatedTestDatabaseClient(app, 'pg', {
+            ...client,
+            connection: {
+              ...client.connection,
+              connectionString: 'postgres://untrusted.example/dev',
+            },
+          }),
+        /connection URL/,
+      );
+      assert.throws(
+        () =>
+          assertIsolatedTestDatabaseClient(app, 'pg', {
+            ...client,
+            connectionPool: {},
+          }),
+        /external pool/,
+      );
+      assert.throws(
+        () =>
+          assertIsolatedTestDatabaseClient(app, 'pg', {
+            ...client,
+            connection: () => ({ database: 'postgres' }),
+          }),
+        /explicit connection target/,
+      );
+    });
+    assert.throws(() => assertIsolatedTestDatabaseClient(app, 'pg', client), /namespace/);
+    assert.throws(
+      () =>
+        assertIsolatedTestDatabaseClient(app, 'pg', {
+          ...client,
+          connection: { database: 'vona-test-unowned-s-20261012-123456' },
+        }),
+      /namespace/,
+    );
+    assert.doesNotThrow(() =>
+      assertIsolatedTestDatabaseClient(app, 'dynamic_1', {
+        client: 'pg',
+        connection: { database: disposable() },
+      }),
+    );
+  } finally {
+    rmSync(fixture.root, { recursive: true, force: true });
+  }
+});
+
+test('discovery rejects unconfigured clients and pinning changes', async () => {
+  const fixture = createFixture();
+  try {
+    const { app, client, config } = fixture;
+    config.database.clients.unused = { client: 'mysql2', connection: { database: 'mysql' } };
+    await assert.rejects(
+      withIsolatedTestDatabaseDiscovery(
+        app,
+        'unused',
+        config.database.clients.unused,
+        async () => {},
+      ),
+      /unconfigured database client/,
+    );
+    await assert.rejects(
+      withIsolatedTestDatabaseDiscovery(
+        app,
+        'pg',
+        {
+          ...client,
+          connection: { ...client.connection, host: 'untrusted.example' },
+        },
+        async () => {},
+      ),
+      /unconfigured database client/,
+    );
+    await withIsolatedTestDatabaseDiscovery(app, 'pg', client, async () => {
+      const originalConnection = client.connection;
+      config.database.clients.pg.connection = { ...client.connection, host: 'untrusted.example' };
+      assert.throws(
+        () =>
+          assertIsolatedTestDatabaseClient(app, 'pg', {
+            ...client,
+            connection: originalConnection,
+          }),
+        /namespace/,
+      );
+      config.database.clients.pg.connection = originalConnection;
+    });
+    (app.meta as { appReady: boolean }).appReady = true;
+    await assert.rejects(
+      withIsolatedTestDatabaseDiscovery(app, 'pg', client, async () => {}),
+      /after startup/,
+    );
+  } finally {
+    rmSync(fixture.root, { recursive: true, force: true });
+  }
+});
+
+test('unused configured clients, base overrides, and URL targets fail before cleanup', () => {
+  const fixture = createFixture();
+  try {
+    const { app, config } = fixture;
+    for (const connection of [
+      'postgres://untrusted.example/dev',
+      () => ({ database: 'postgres' }),
+      { connectionString: 'postgres://untrusted.example/dev' },
+    ]) {
+      config.database.base.connection = connection;
+      assert.throws(() => assertIsolatedTestConfig(app), /base connection target or pool/);
+    }
+    delete config.database.base.connection;
+    config.database.base.connectionPool = {};
+    assert.throws(() => assertIsolatedTestConfig(app), /base connection target or pool/);
+    delete config.database.base.connectionPool;
+    config.database.clients.unused = { client: 'pg', connection: { database: 'postgres' } };
+    assert.doesNotThrow(() => assertIsolatedTestConfig(app));
+    for (const connection of [
+      { database: 'postgres', connectionString: 'postgres://untrusted.example/dev' },
+      { database: 'mysql', uri: 'mysql://untrusted.example/dev' },
+      () => ({ database: 'postgres' }),
+    ]) {
+      config.database.clients.unused.connection = connection as Record<string, unknown>;
+      assert.throws(() => assertIsolatedTestConfig(app), /external target or pool: unused/);
+    }
+    config.database.clients.unused.connection = { database: 'postgres' };
+    config.database.clients.unused.connectionPool = {};
+    assert.throws(() => assertIsolatedTestConfig(app), /external target or pool: unused/);
+    delete config.database.clients.unused.connectionPool;
+    assert.doesNotThrow(() => assertIsolatedTestConfig(app));
+  } finally {
+    rmSync(fixture.root, { recursive: true, force: true });
+  }
+});
+
+test('mysql URL overrides and SQLite escapes are rejected at construction', () => {
+  const fixture = createFixture();
+  try {
+    const { app, paths } = fixture;
+    assert.throws(
+      () =>
+        assertIsolatedTestDatabaseClient(app, 'dynamic_mysql', {
+          client: 'mysql2',
+          connection: { database: disposable(), uri: 'mysql://untrusted.example/dev' },
+        }),
+      /connection URL/,
+    );
+    const filename = path.join(paths.sqliteRoot, `${disposable()}.db`);
+    assert.doesNotThrow(() =>
+      assertIsolatedTestDatabaseClient(app, 'dynamic_sqlite', {
+        client: 'better-sqlite3',
+        connection: { filename },
+      }),
+    );
+    assert.throws(
+      () =>
+        assertIsolatedTestDatabaseClient(app, 'dynamic_sqlite', {
+          client: 'better-sqlite3',
+          connection: { filename: path.join(fixture.root, `${disposable()}.db`) },
+        }),
+      /path escapes/,
+    );
+    mkdirSync(paths.sqliteRoot, { recursive: true });
+    const linked = path.join(paths.sqliteRoot, `${disposable()}.db`);
+    symlinkSync(path.join(fixture.root, 'development.db'), linked);
+    assert.throws(
+      () =>
+        assertIsolatedTestDatabaseClient(app, 'dynamic_sqlite', {
+          client: 'better-sqlite3',
+          connection: { filename: linked },
+        }),
+      /symlink/,
+    );
+  } finally {
+    rmSync(fixture.root, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,312 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { lstatSync } from 'node:fs';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+
+import type { VonaApplication } from './application.ts';
+
+import {
+  assertDisposableDatabaseName,
+  assertTestAppIdentity,
+  assertTestRunOwner,
+  getDatabaseTestPrefix,
+  resolveVonaLocalPaths,
+} from './testIsolation.ts';
+
+const databaseDiscovery = new AsyncLocalStorage<{
+  app: VonaApplication;
+  clientName: string;
+  client: IsolatedDatabaseClient;
+}>();
+
+type IsolatedDatabaseConnection = {
+  database?: string;
+  filename?: string;
+  connectionString?: string;
+  uri?: string;
+};
+
+type IsolatedDatabaseClient = {
+  client: string;
+  connection?: unknown;
+  connectionPool?: unknown;
+};
+
+export async function withIsolatedTestDatabaseDiscovery<T>(
+  app: VonaApplication,
+  clientName: string,
+  client: IsolatedDatabaseClient,
+  fn: () => Promise<T>,
+): Promise<T> {
+  if (!app.meta.env.VONA_TEST_RUN_ID) return fn();
+  if (app.meta.appReady) throw new Error('Isolated test cannot discover databases after startup');
+  const config = app.config as typeof app.config & {
+    database: { defaultClient: string; clients: Record<string, IsolatedDatabaseClient> };
+    instance: { instances: Record<string, false | { isolate?: boolean; isolateClient?: string }> };
+  };
+  const instanceClients = Object.values(config.instance.instances).flatMap(instance =>
+    instance && instance.isolate && instance.isolateClient ? [instance.isolateClient] : [],
+  );
+  if (
+    !client ||
+    (clientName !== config.database.defaultClient && !instanceClients.includes(clientName)) ||
+    config.database.clients[clientName]?.client !== client.client ||
+    !isDeepStrictEqual(client.connection, config.database.clients[clientName].connection) ||
+    !client.connection ||
+    typeof client.connection !== 'object' ||
+    Array.isArray(client.connection)
+  ) {
+    throw new Error(`Isolated test cannot discover an unconfigured database client: ${clientName}`);
+  }
+  return databaseDiscovery.run({ app, clientName, client }, async () => {
+    assertIsolatedTestDatabaseClient(app, clientName, client);
+    return await fn();
+  });
+}
+
+export function assertIsolatedTestDatabaseClient(
+  app: VonaApplication,
+  clientName: string,
+  client: IsolatedDatabaseClient,
+) {
+  const id = assertTestAppIdentity(app.meta.env.META_MODE, app.meta.env.VONA_TEST_RUN_ID, app.name);
+  if (!id) return;
+  const paths = resolveVonaLocalPaths(app.projectPath, 'test', id);
+  assertTestRunOwner(paths.dataRoot, id);
+  if (client.connectionPool !== undefined) {
+    throw new Error(`Isolated test database cannot use an external pool: ${clientName}`);
+  }
+  if (
+    !client.connection ||
+    typeof client.connection !== 'object' ||
+    Array.isArray(client.connection)
+  ) {
+    throw new Error(`Isolated test database requires an explicit connection target: ${clientName}`);
+  }
+  const connection = client.connection as IsolatedDatabaseConnection;
+  if (connection.connectionString !== undefined || connection.uri !== undefined) {
+    throw new Error(`Isolated test database cannot use a connection URL: ${clientName}`);
+  }
+  if (!['better-sqlite3', 'pg', 'mysql', 'mysql2'].includes(client.client)) {
+    throw new Error(`Isolated test database client is unsupported: ${clientName}`);
+  }
+  if (
+    client.client === 'better-sqlite3'
+      ? connection.database !== undefined
+      : connection.filename !== undefined
+  ) {
+    throw new Error(`Isolated test database has conflicting connection targets: ${clientName}`);
+  }
+  const config = app.config as typeof app.config & {
+    database: { clients: Record<string, IsolatedDatabaseClient>; defaultClient: string };
+    instance: { instances: Record<string, false | { isolate?: boolean; isolateClient?: string }> };
+  };
+  const configured = config.database;
+  const discovering = databaseDiscovery.getStore();
+  const target = client.client === 'better-sqlite3' ? connection.filename : connection.database;
+  if (
+    discovering?.app === app &&
+    discovering.clientName === clientName &&
+    !app.meta.appReady &&
+    configured.clients[clientName]?.client === client.client &&
+    client.client === discovering.client.client &&
+    isDeepStrictEqual(connection, discovering.client.connection) &&
+    isDeepStrictEqual(connection, configured.clients[clientName].connection)
+  ) {
+    const discoveryTarget =
+      client.client === 'better-sqlite3' ? '' : client.client === 'pg' ? 'postgres' : 'mysql';
+    if (
+      target === discoveryTarget ||
+      (client.client === 'better-sqlite3' && target === ':memory:')
+    ) {
+      return;
+    }
+  }
+  const scopes = new Set(['share']);
+  for (const [instanceName, instance] of Object.entries(config.instance.instances)) {
+    if (instance && instance.isolate && instance.isolateClient) {
+      scopes.add(`isolate-${instanceName}`);
+    }
+  }
+  if (typeof target !== 'string') {
+    throw new TypeError(`Isolated test database requires a disposable target: ${clientName}`);
+  }
+  let matched = false;
+  for (const scope of scopes) {
+    const prefix = getDatabaseTestPrefix(app.name, scope);
+    const databaseName = client.client === 'better-sqlite3' ? path.basename(target, '.db') : target;
+    try {
+      assertDisposableDatabaseName(databaseName, prefix);
+      matched = true;
+      break;
+    } catch {
+      // Try the next owned namespace.
+    }
+  }
+  if (!matched) throw new Error(`Isolated test database is outside its namespace: ${clientName}`);
+  if (client.client === 'better-sqlite3') {
+    if (!path.isAbsolute(target) || path.extname(target) !== '.db') {
+      throw new Error(`Isolated test SQLite target must be an owned .db file: ${clientName}`);
+    }
+    assertIsolatedTestPath(target, path.join(paths.sqliteRoot, path.basename(target)));
+  }
+}
+
+export function assertIsolatedTestPath(actual: string, expected: string) {
+  if (path.resolve(actual) !== path.resolve(expected)) {
+    throw new Error(`Isolated test path escapes its owned root: ${actual}`);
+  }
+  let current = path.resolve(actual);
+  while (true) {
+    try {
+      if (lstatSync(current).isSymbolicLink()) {
+        throw new Error(`Isolated test path traverses a symlink: ${current}`);
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+}
+
+export function assertIsolatedTestConfig(app: VonaApplication) {
+  const env = app.meta.env;
+  const id = assertTestAppIdentity(env.META_MODE, env.VONA_TEST_RUN_ID, app.name);
+  if (!id) return;
+  const paths = resolveVonaLocalPaths(app.projectPath, env.META_MODE, id);
+  assertTestRunOwner(paths.dataRoot, id);
+  assertTestRunOwner(paths.generatedRoot, id);
+  assertIsolatedTestPath(app.config.server.publicDir, paths.publicRoot);
+  assertIsolatedTestPath(app.config.logger.baseDir, paths.logsRoot);
+  assertIsolatedTestPath(paths.runtimeRoot, paths.runtimeRoot);
+  assertIsolatedTestPath(paths.sqliteRoot, paths.sqliteRoot);
+  if (app.config.server.workers !== 1) throw new Error('Isolated test requires one Vona worker');
+  const config = app.config as typeof app.config & {
+    database: {
+      testDatabase: boolean;
+      base: {
+        connection?: unknown;
+        connectionPool?: unknown;
+      };
+      defaultClient: string | ((...args: unknown[]) => string);
+      clients: Record<
+        string,
+        {
+          client: string;
+          connection?: unknown;
+          connectionPool?: unknown;
+        }
+      >;
+    };
+    instance: { instances: Record<string, false | { isolate?: boolean; isolateClient?: string }> };
+    redis: {
+      base: { keyPrefix?: string };
+      clients: Record<string, { keyPrefix?: string | true; sentinels?: unknown; nodes?: unknown }>;
+    };
+  };
+  if (process.env.VONA_DB_RESET !== undefined) {
+    throw new Error('Isolated test cannot run a development database reset');
+  }
+  if (!config.database.testDatabase) {
+    throw new Error('Isolated test requires disposable test database configuration');
+  }
+  if (typeof config.database.defaultClient !== 'string') {
+    throw new TypeError('Isolated test requires a static default database client');
+  }
+  if (
+    config.database.base.connection !== undefined ||
+    config.database.base.connectionPool !== undefined
+  ) {
+    throw new Error('Isolated test cannot inherit a database base connection target or pool');
+  }
+  const clientNames = new Set<string>([config.database.defaultClient]);
+  const instances = config.instance.instances;
+  for (const instance of Object.values(instances)) {
+    if (!instance || !instance.isolate) continue;
+    if (!instance.isolateClient)
+      throw new Error('Isolated test instance requires an isolateClient');
+    clientNames.add(instance.isolateClient);
+  }
+  for (const clientName of clientNames) {
+    if (!config.database.clients[clientName]) {
+      throw new Error(`Isolated test has no configured database client: ${clientName}`);
+    }
+  }
+  for (const [clientName, client] of Object.entries(config.database.clients)) {
+    if (client.connectionPool !== undefined) {
+      throw new Error(
+        `Isolated test database client has an external target or pool: ${clientName}`,
+      );
+    }
+    // Optional, unused clients may intentionally remain empty in local configuration.
+    // Any configured connection is still validated, even when that client is not selected.
+    if (client.connection === undefined && !clientNames.has(clientName)) continue;
+    if (
+      typeof client.connection !== 'object' ||
+      client.connection === null ||
+      Array.isArray(client.connection) ||
+      (client.connection as IsolatedDatabaseConnection).connectionString !== undefined ||
+      (client.connection as IsolatedDatabaseConnection).uri !== undefined
+    ) {
+      throw new Error(
+        `Isolated test database client has an external target or pool: ${clientName}`,
+      );
+    }
+    if (!clientNames.has(clientName)) continue;
+    if (!['better-sqlite3', 'pg', 'mysql', 'mysql2'].includes(client.client)) {
+      throw new Error(`Isolated test has an unsupported database client: ${clientName}`);
+    }
+    const connection = client.connection as IsolatedDatabaseConnection;
+    const expected =
+      client.client === 'better-sqlite3' ? '' : client.client === 'pg' ? 'postgres' : 'mysql';
+    const target = client.client === 'better-sqlite3' ? connection.filename : connection.database;
+    if (target !== expected && !(client.client === 'better-sqlite3' && target === ':memory:')) {
+      throw new Error(
+        `Isolated test requires an administrative discovery connection: ${clientName}`,
+      );
+    }
+    if (
+      client.client === 'better-sqlite3'
+        ? connection.database !== undefined
+        : connection.filename !== undefined
+    ) {
+      throw new Error(`Isolated test discovery connection has conflicting targets: ${clientName}`);
+    }
+  }
+  const redis = config.redis;
+  if (redis.base.keyPrefix !== undefined) {
+    throw new Error('Isolated test cannot inherit a Redis base keyPrefix');
+  }
+  for (const [clientName, client] of Object.entries(redis.clients)) {
+    const special = ['queue', 'broadcast'].includes(clientName) || clientName.startsWith('redlock');
+    if (
+      (client as { sentinels?: unknown; nodes?: unknown }).sentinels ||
+      (client as { nodes?: unknown }).nodes
+    ) {
+      throw new Error(`Isolated test cannot use a Redis sentinel or cluster client: ${clientName}`);
+    }
+    if (special ? client.keyPrefix !== undefined : client.keyPrefix !== true) {
+      throw new Error(`Isolated test requires a framework-managed Redis prefix: ${clientName}`);
+    }
+  }
+  const expectedPort = Number(env.SERVER_LISTEN_PORT);
+  const requiresServerOrigin = process.env.VONA_TEST_SERVER_ORIGIN === 'true';
+  if (
+    !Number.isInteger(expectedPort) ||
+    expectedPort <= 0 ||
+    expectedPort > 65535 ||
+    app.config.server.listen.port !== expectedPort ||
+    app.config.server.listen.hostname !== '127.0.0.1' ||
+    (requiresServerOrigin &&
+      (app.config.server.serve.protocol !== 'http' ||
+        app.config.server.serve.host !== `127.0.0.1:${expectedPort}`))
+  ) {
+    throw new Error(
+      requiresServerOrigin
+        ? 'Isolated test listener and server origin must match the assigned loopback port'
+        : 'Isolated test listener must match the assigned loopback port',
+    );
+  }
+}