cabloy 5.1.203 → 5.1.205

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

@@ -0,0 +1,153 @@
+import type { TestClaimManifest } from 'vona-core';
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import {
+  getTestClaimCreatedAt,
+  getTestClaimPaths,
+  getTestClaimRedisPrefix,
+  getDatabaseTestPrefix,
+  getTestAppName,
+} from 'vona-core';
+
+import type { TestCleanupConfigDependencies } from './resolveTestCleanupConfig.ts';
+
+import { resolveTestCleanupConfig } from './resolveTestCleanupConfig.ts';
+
+const runId = '20261011010203-deadbeef';
+const projectPath = '/canonical-checkout/vona';
+function fixture() {
+  const prefix = getDatabaseTestPrefix(getTestAppName(runId), 'share');
+  const paths = getTestClaimPaths(projectPath, runId);
+  const claim: TestClaimManifest = {
+    version: 1,
+    runId,
+    projectPath,
+    createdAt: getTestClaimCreatedAt(runId),
+    kind: 'unit',
+    owner: { pid: 1, startTime: 'fake', host: 'fake' },
+    status: 'failed',
+    locals: [
+      { kind: 'generated', path: paths.generatedRoot, stage: 'owned' },
+      { kind: 'data', path: paths.dataRoot, stage: 'owned' },
+    ],
+    databases: [
+      {
+        clientName: 'pg',
+        scope: 'share',
+        prefix,
+        endpoint: {
+          dialect: 'pg',
+          transport: 'tcp',
+          host: 'override-db',
+          port: 6543,
+          tls: false,
+          adminDatabase: 'postgres',
+        },
+        creations: [{ name: `${prefix}20261011-010203`, stage: 'intent' }],
+      },
+    ],
+    redis: [
+      {
+        clientName: 'cache',
+        ...getTestClaimRedisPrefix(runId, 'cache')!,
+        endpoint: { transport: 'tcp', host: 'override-redis', port: 6380, tls: false, db: 4 },
+        released: false,
+      },
+    ],
+    processes: [],
+    cleanup: { processes: false, databases: false, redis: false, locals: false },
+  };
+  const base = {
+    meta: { mode: 'test', flavor: 'normal' },
+    database: {
+      testDatabase: true,
+      defaultClient: 'pg',
+      base: { connection: { host: 'base-db', port: 5432, password: 'memory-only-secret' } },
+      clients: { pg: { client: 'pg', connection: { database: 'postgres', user: 'user' } } },
+    },
+    redis: {
+      base: { host: 'base-redis', port: 6379, db: 0, password: 'memory-only-secret' },
+      clients: { cache: { keyPrefix: true } },
+    },
+    instance: { instances: {} },
+  };
+  const override = {
+    database: { clients: { pg: { connection: { host: 'override-db', port: 6543 } } } },
+    redis: { clients: { cache: { host: 'override-redis', port: 6380, db: 4 } } },
+  };
+  const env = {
+    NODE_ENV: 'test' as const,
+    META_MODE: 'test' as const,
+    META_FLAVOR: 'normal' as const,
+    VONA_TEST_RUN_ID: runId,
+    APP_NAME: getTestAppName(runId),
+  };
+  const evaluated: string[] = [];
+  const deps: TestCleanupConfigDependencies = {
+    loadEnvs: () => env,
+    files: ['default', 'test', 'local'],
+    async loadConfig(file) {
+      return {
+        default: async () => {
+          evaluated.push(file);
+          return file === 'default' ? base : file === 'local' ? override : {};
+        },
+      };
+    },
+    createApp: currentEnv =>
+      ({
+        options: { projectPath, configResolutionOnly: true },
+        projectPath,
+        name: currentEnv.APP_NAME,
+        meta: { env: currentEnv },
+      }) as any,
+  };
+  return { claim, deps, base, override, env, evaluated };
+}
+
+test('current source config evaluation and ordered deep precedence, credentials stay memory-only', async () => {
+  const f = fixture();
+  const resolved = await resolveTestCleanupConfig(f.claim, f.deps);
+  assert.deepEqual(f.evaluated, ['default', 'test', 'local']);
+  assert.equal(resolved.databaseOptions.get('pg')!.connection.host, 'override-db');
+  assert.equal(resolved.databaseOptions.get('pg')!.connection.password, 'memory-only-secret');
+  assert.equal(resolved.redisOptions.get('cache')!.host, 'override-redis');
+  assert.equal(resolved.redisOptions.get('cache')!.keyPrefix, undefined);
+  assert.ok(!JSON.stringify(f.claim).includes('memory-only-secret'));
+});
+
+test('current configuration drift and unsupported targets fail before any driver access', async () => {
+  for (const mutate of [
+    (f: ReturnType<typeof fixture>) => {
+      f.override.database.clients.pg.connection.host = 'different';
+    },
+    (f: ReturnType<typeof fixture>) => {
+      f.override.redis.clients.cache.db = 5;
+    },
+    (f: ReturnType<typeof fixture>) => {
+      f.base.database.clients.pg.connection.database = 'development';
+    },
+    (f: ReturnType<typeof fixture>) => {
+      f.base.redis.clients.cache.keyPrefix = false as any;
+    },
+    (f: ReturnType<typeof fixture>) => {
+      (f.base.database.clients.pg.connection as any).connectionString = 'secret://different';
+    },
+    (f: ReturnType<typeof fixture>) => {
+      (f.base.redis.clients.cache as any).sentinels = [];
+    },
+  ]) {
+    const f = fixture();
+    mutate(f);
+    await assert.rejects(resolveTestCleanupConfig(f.claim, f.deps));
+  }
+});
+
+test('cleanup source-only resolution rejects wrong identity and does not call lifecycle loaders', async () => {
+  const f = fixture();
+  const resolved = await resolveTestCleanupConfig(f.claim, f.deps);
+  assert.equal(resolved.databaseOptions.size, 1);
+  f.env.APP_NAME = 'development';
+  await assert.rejects(resolveTestCleanupConfig(f.claim, f.deps), /identity mismatch/);
+});

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

@@ -0,0 +1,141 @@
+import type { TestClaimManifest, VonaConfig, VonaConfigEnv } from 'vona-core';
+
+import { getEnvFiles } from '@cabloy/dotenv';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isDeepStrictEqual } from 'node:util';
+import {
+  VonaApplication,
+  deepExtend,
+  getTestAppName,
+  getTestClaimRedisPrefix,
+  mergeTestClaimDatabaseOptions,
+  mergeTestClaimRedisOptions,
+  normalizeTestClaimDatabaseEndpoint,
+  normalizeTestClaimRedisEndpoint,
+  getDatabaseTestPrefix,
+  assertDisposableDatabaseName,
+} from 'vona-core';
+
+import { createConfigUtils } from './configUtils.ts';
+
+export interface TestCleanupResolvedConfig {
+  databaseOptions: Map<string, Record<string, any>>;
+  redisOptions: Map<string, Record<string, any>>;
+}
+export interface TestCleanupConfigDependencies {
+  loadEnvs(): NodeJS.ProcessEnv;
+  files: string[];
+  loadConfig(file: string): Promise<{ default: (app: VonaApplication) => unknown }>;
+  createApp(env: NodeJS.ProcessEnv): VonaApplication;
+}
+
+export async function resolveTestCleanupConfig(
+  claim: TestClaimManifest,
+  injected?: TestCleanupConfigDependencies,
+): Promise<TestCleanupResolvedConfig> {
+  const meta = { flavor: 'normal' as const, mode: 'test' as const };
+  const deps = injected ?? {
+    loadEnvs: createConfigUtils(meta as any, {
+      appDir: claim.projectPath,
+      runtimeDir: '.unused-cleanup',
+    }).loadEnvs,
+    files: getEnvFiles(
+      { ...meta, local: 'local' },
+      path.join(claim.projectPath, 'src/backend/config/config'),
+      'config',
+      ['.ts', '.tsx'],
+    )!,
+    loadConfig: (file: string) => import(pathToFileURL(file).href),
+    createApp: (env: NodeJS.ProcessEnv) =>
+      new VonaApplication({
+        name: getTestAppName(claim.runId),
+        projectPath: claim.projectPath,
+        env: env as unknown as VonaConfigEnv,
+        configResolutionOnly: true,
+        config: async () => {
+          throw new Error('Cleanup config is source-only');
+        },
+        modulesMeta: async () => {
+          throw new Error('Cleanup never loads modules');
+        },
+        locales: async () => {
+          throw new Error('Cleanup never loads locales');
+        },
+      }),
+  };
+  const env = deps.loadEnvs();
+  if (
+    env.META_MODE !== 'test' ||
+    env.VONA_TEST_RUN_ID !== claim.runId ||
+    env.APP_NAME !== getTestAppName(claim.runId)
+  ) {
+    throw new Error('Cleanup config identity mismatch');
+  }
+  const app = deps.createApp(env);
+  const loaders = await Promise.all(deps.files.map(file => deps.loadConfig(file)));
+  // Exactly Start's concurrent evaluation and ordered deep merge, without Start,
+  // createGeneralApp/createApp, module loading, listeners, migrations or seeds.
+  const items = await Promise.all(loaders.map(loader => loader.default(app)));
+  const config: Record<string, any> = {};
+  for (const item of items) {
+    if (item) deepExtend(config, item);
+  }
+  app.config = config as VonaConfig;
+  if (
+    config.meta?.mode !== 'test' ||
+    config.meta?.flavor !== 'normal' ||
+    config.database?.testDatabase !== true
+  ) {
+    throw new Error('Unsupported cleanup config mode');
+  }
+  const databaseOptions = new Map<string, Record<string, any>>();
+  const redisOptions = new Map<string, Record<string, any>>();
+  for (const database of claim.databases) {
+    const client = config.database.clients?.[database.clientName];
+    if (!client) throw new Error('Cleanup database client missing');
+    // Built-in dialect defaults only shape pools/afterCreate, never endpoints.
+    // Admin cleanup uses a dedicated bounded pool instead of application hooks.
+    const options = mergeTestClaimDatabaseOptions(config.database.base, undefined, client);
+    const endpoint = normalizeTestClaimDatabaseEndpoint(options, claim.projectPath, claim.runId);
+    if (!isDeepStrictEqual(endpoint, database.endpoint))
+      throw new Error('Cleanup database endpoint drift');
+    if (database.prefix !== getDatabaseTestPrefix(getTestAppName(claim.runId), database.scope))
+      throw new Error('Cleanup database namespace drift');
+    if (database.scope !== 'share') {
+      const instance = config.instance?.instances?.[database.scope.slice('isolate-'.length)];
+      if (!instance?.isolate || instance.isolateClient !== database.clientName)
+        throw new Error('Cleanup database scope drift');
+    } else if (config.database.defaultClient !== database.clientName) {
+      throw new Error('Cleanup default database client drift');
+    }
+    if (endpoint.dialect !== 'better-sqlite3') {
+      if (options.connection.database !== endpoint.adminDatabase)
+        throw new Error('Cleanup administrative target drift');
+      for (const creation of database.creations)
+        assertDisposableDatabaseName(creation.name, database.prefix);
+    }
+    databaseOptions.set(database.clientName, options);
+  }
+  for (const resource of claim.redis) {
+    const client = config.redis?.clients?.[resource.clientName];
+    if (!client || config.redis.base?.keyPrefix !== undefined)
+      throw new Error('Unsupported cleanup Redis prefix');
+    const options = mergeTestClaimRedisOptions(config.redis.base, client);
+    const endpoint = normalizeTestClaimRedisEndpoint(options);
+    const owned = getTestClaimRedisPrefix(claim.runId, resource.clientName);
+    if (
+      !isDeepStrictEqual(endpoint, resource.endpoint) ||
+      !owned ||
+      owned.prefix !== resource.prefix ||
+      owned.kind !== resource.kind
+    ) {
+      throw new Error('Cleanup Redis endpoint or namespace drift');
+    }
+    if (resource.kind === 'client' ? options.keyPrefix !== true : options.keyPrefix !== undefined)
+      throw new Error('Cleanup Redis prefix drift');
+    delete options.keyPrefix;
+    redisOptions.set(resource.clientName, options);
+  }
+  return { databaseOptions, redisOptions };
+}

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

@@ -0,0 +1,148 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import {
+  clearExactRedisPrefix,
+  dropExactCleanupDatabase,
+  escapeRedisCleanupPattern,
+  quoteCleanupDatabase,
+} from './testCleanupAdapters.ts';
+
+const validate = (value: string) => {
+  if (!value.startsWith('owned:')) throw new Error('foreign');
+};
+function redis(keys: string[], error?: Error) {
+  const deleted: string[][] = [];
+  const fallback: string[][] = [];
+  const patterns: string[] = [];
+  let closed = false;
+  return {
+    deleted,
+    fallback,
+    patterns,
+    get closed() {
+      return closed;
+    },
+    connection: {
+      async scan(
+        _cursor: string,
+        _match: 'MATCH',
+        pattern: string,
+        _count: 'COUNT',
+        _size: number,
+      ): Promise<[string, string[]]> {
+        patterns.push(pattern);
+        return ['0', keys];
+      },
+      async unlink(...batch: string[]) {
+        if (error) throw error;
+        deleted.push(batch);
+      },
+      async del(...batch: string[]) {
+        fallback.push(batch);
+      },
+      disconnect() {
+        closed = true;
+      },
+    },
+  };
+}
+
+test('database cleanup quotes exact identifiers, has bounded PG locks, and always closes', async () => {
+  assert.equal(quoteCleanupDatabase('a"b', 'pg'), '"a""b"');
+  assert.equal(quoteCleanupDatabase('a`b', 'mysql2'), '`a``b`');
+  assert.throws(() => quoteCleanupDatabase('x', 'unsupported'));
+  const statements: string[] = [];
+  let closed = false;
+  await dropExactCleanupDatabase(
+    {
+      async raw(sql) {
+        statements.push(sql);
+      },
+      async destroy() {
+        closed = true;
+      },
+    },
+    'pg',
+    'owned:exact',
+    validate,
+  );
+  assert.equal(statements.at(-1), 'DROP DATABASE IF EXISTS "owned:exact"');
+  assert.equal(statements.length, 3);
+  assert.ok(closed);
+  assert.ok(statements.every(sql => !/FORCE|terminate|LIKE|pg_database/i.test(sql)));
+  await assert.rejects(
+    dropExactCleanupDatabase(
+      {
+        async raw() {
+          throw new Error('in use');
+        },
+        async destroy() {
+          closed = true;
+        },
+      },
+      'mysql2',
+      'owned:exact',
+      validate,
+    ),
+    /in use/,
+  );
+});
+
+test('Redis scans escaped literal prefixes, deletes bounded batches and leaves development sentinel', async () => {
+  const sentinel = 'dev:important';
+  const fake = redis(['owned:[x]:1', 'owned:[x]:2', 'owned:[x]:3']);
+  await clearExactRedisPrefix(fake.connection, 'owned:[x]:', validate, { batchSize: 2 });
+  assert.equal(escapeRedisCleanupPattern('a*?[x]\\'), 'a\\*\\?\\[x\\]\\\\');
+  assert.deepEqual(
+    fake.deleted.map(batch => batch.length),
+    [2, 1],
+  );
+  assert.deepEqual(fake.patterns, ['owned:\\[x\\]:*']);
+  assert.ok(!fake.deleted.flat().includes(sentinel));
+  assert.ok(fake.closed);
+});
+
+test('Redis rejects a foreign key before deleting any batch', async () => {
+  const fake = redis(['owned:1', 'development:sentinel']);
+  await assert.rejects(
+    clearExactRedisPrefix(fake.connection, 'owned:', validate, { batchSize: 1 }),
+    /foreign key/,
+  );
+  assert.deepEqual(fake.deleted, []);
+  assert.ok(fake.closed);
+});
+
+test('Redis only falls back for missing UNLINK, never ACL or network errors', async () => {
+  const old = redis(
+    ['owned:1'],
+    new Error("ERR unknown command 'UNLINK', with args beginning with:"),
+  );
+  await clearExactRedisPrefix(old.connection, 'owned:', validate);
+  assert.deepEqual(old.fallback, [['owned:1']]);
+  for (const message of ['NOPERM UNLINK denied', 'connection reset', 'ERR unrelated error']) {
+    const fake = redis(['owned:1'], new Error(message));
+    await assert.rejects(clearExactRedisPrefix(fake.connection, 'owned:', validate));
+    assert.deepEqual(fake.fallback, []);
+    assert.ok(fake.closed);
+  }
+});
+
+test('Redis scan loops have a finite bound', async () => {
+  let closed = false;
+  const connection = {
+    async scan(): Promise<[string, string[]]> {
+      return ['1', []];
+    },
+    async unlink() {},
+    async del() {},
+    disconnect() {
+      closed = true;
+    },
+  };
+  await assert.rejects(
+    clearExactRedisPrefix(connection, 'owned:', validate, { maxScans: 2 }),
+    /limit exceeded/,
+  );
+  assert.ok(closed);
+});

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

@@ -0,0 +1,127 @@
+// Cleanup primitives deliberately have no framework startup or connection dependencies.
+export interface CleanupSqlConnection {
+  raw(sql: string): Promise<unknown>;
+  destroy(): Promise<unknown>;
+}
+
+export interface CleanupRedisConnection {
+  scan(
+    cursor: string,
+    match: 'MATCH',
+    pattern: string,
+    count: 'COUNT',
+    size: number,
+  ): Promise<[string, string[]]>;
+  unlink(...keys: string[]): Promise<unknown>;
+  del(...keys: string[]): Promise<unknown>;
+  disconnect(): unknown;
+}
+
+export function quoteCleanupDatabase(name: string, dialect: string): string {
+  if (typeof name !== 'string' || !name || name.includes('\0')) {
+    throw new Error('Invalid cleanup database identifier');
+  }
+  if (dialect === 'pg') return `"${name.replaceAll('"', '""')}"`;
+  if (dialect === 'mysql' || dialect === 'mysql2') return `\`${name.replaceAll('`', '``')}\``;
+  throw new Error('Unsupported cleanup database dialect');
+}
+
+export async function dropExactCleanupDatabase(
+  connection: CleanupSqlConnection,
+  dialect: string,
+  name: string,
+  validate: (name: string) => void,
+) {
+  // Never discover databases, terminate sessions, or use FORCE. IF EXISTS is the only
+  // absent-resource accommodation; authentication and in-use failures propagate.
+  try {
+    validate(name);
+    const identifier = quoteCleanupDatabase(name, dialect);
+    if (dialect === 'pg') {
+      await connection.raw("SET statement_timeout = '10000ms'");
+      await connection.raw("SET lock_timeout = '3000ms'");
+    }
+    await connection.raw(`DROP DATABASE IF EXISTS ${identifier}`);
+  } finally {
+    await connection.destroy();
+  }
+}
+
+export function escapeRedisCleanupPattern(prefix: string): string {
+  return prefix.replace(/[\\*?[\]]/g, '\\$&');
+}
+
+function isUnsupportedUnlink(error: unknown): boolean {
+  // Redis <4 can lack UNLINK. ACL, network, timeout and unrelated command errors
+  // are never reasons to retry a destructive command using a different method.
+  return (
+    error instanceof Error && /^ERR unknown command ['"]?UNLINK['"]?(?:,|\s|$)/i.test(error.message)
+  );
+}
+
+export async function clearExactRedisPrefix(
+  connection: CleanupRedisConnection,
+  prefix: string,
+  validate: (prefix: string) => void,
+  options: { batchSize?: number; maxScans?: number } = {},
+) {
+  const batchSize = options.batchSize ?? 128;
+  const maxScans = options.maxScans ?? 100000;
+  let useDel = false;
+  let scans = 0;
+  let cursor = '0';
+  try {
+    validate(prefix);
+    if (
+      !Number.isSafeInteger(batchSize) ||
+      batchSize <= 0 ||
+      batchSize > 1024 ||
+      !Number.isSafeInteger(maxScans) ||
+      maxScans <= 0
+    ) {
+      throw new Error('Invalid Redis cleanup bounds');
+    }
+    do {
+      if (++scans > maxScans) throw new Error('Redis cleanup scan limit exceeded');
+      const result = await connection.scan(
+        cursor,
+        'MATCH',
+        `${escapeRedisCleanupPattern(prefix)}*`,
+        'COUNT',
+        batchSize,
+      );
+      if (
+        !Array.isArray(result) ||
+        result.length !== 2 ||
+        typeof result[0] !== 'string' ||
+        !/^\d+$/.test(result[0]) ||
+        !Array.isArray(result[1])
+      ) {
+        throw new Error('Invalid Redis cleanup scan response');
+      }
+      cursor = result[0];
+      const keys = result[1];
+      // Validate the entire response before the first deletion, not just each
+      // batch. A server response outside the literal namespace is a hard stop.
+      if (keys.some(key => typeof key !== 'string' || !key.startsWith(prefix))) {
+        throw new Error('Redis cleanup scan returned a foreign key');
+      }
+      for (let offset = 0; offset < keys.length; offset += batchSize) {
+        const batch = keys.slice(offset, offset + batchSize);
+        if (useDel) {
+          await connection.del(...batch);
+        } else {
+          try {
+            await connection.unlink(...batch);
+          } catch (error) {
+            if (!isUnsupportedUnlink(error)) throw error;
+            useDel = true;
+            await connection.del(...batch);
+          }
+        }
+      }
+    } while (cursor !== '0');
+  } finally {
+    connection.disconnect();
+  }
+}

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

@@ -0,0 +1,47 @@
+import { mkdir, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { createTestClaim, getTestClaimRedisPrefix, writeTestClaim } from 'vona-core';
+
+import { prepareCleanupProcess } from '../../../../../../../scripts/testClaimCleanup.ts';
+
+// A fake source config exercises child registration/current resolution/IPC but
+// never opens a database, Redis connection, listener, migration or seed.
+test('cleanup helper launches via process.execPath and resolves only fake source config', async () => {
+  const project = await mkdtemp(path.join(await realpath(os.tmpdir()), 'cleanup-helper-'));
+  const runId = '20261011010203-deadbeef';
+  try {
+    const configDir = path.join(project, 'src/backend/config/config');
+    await mkdir(configDir, { recursive: true });
+    await writeFile(path.join(project, 'package.json'), '{"type":"module"}');
+    await writeFile(
+      path.join(project, 'tsconfig.json'),
+      '{"compilerOptions":{"module":"NodeNext","moduleResolution":"NodeNext","target":"ESNext","allowImportingTsExtensions":true},"ts-node":{"transpileOnly":true}}',
+    );
+    await writeFile(
+      path.join(configDir, 'config.ts'),
+      `export default async function(app) {
+      if (app.server || !app.options.configResolutionOnly) throw new Error('Started application');
+      await app.options.modulesMeta().then(() => { throw new Error('Module loading permitted'); }, () => {});
+      return { meta: { mode: 'test', flavor: 'normal' }, database: { testDatabase: true }, redis: { base: { host: '127.0.0.1', port: 6379, db: 0 }, clients: { cache: { keyPrefix: true } } } };
+    }`,
+    );
+    const { claimPath, manifest } = await createTestClaim(project, runId, 'unit', {
+      pid: process.pid,
+      startTime: 'fake',
+      host: os.hostname(),
+    });
+    manifest.redis.push({
+      clientName: 'cache',
+      ...getTestClaimRedisPrefix(runId, 'cache')!,
+      endpoint: { transport: 'tcp', host: '127.0.0.1', port: 6379, db: 0, tls: false },
+      released: false,
+    });
+    await writeTestClaim(claimPath, manifest);
+    const session = await prepareCleanupProcess(manifest, claimPath);
+    await session.close();
+  } finally {
+    await rm(project, { recursive: true, force: true });
+  }
+});