cabloy 5.1.205 → 5.1.207

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

@@ -1,10 +1,14 @@
+import type { Worker } from 'node:cluster';
+
 import chalk from 'chalk';
 import cluster from 'node:cluster';
 
 import { useApp } from './useApp.ts';
 
 let __closing = false;
+let __failed = false;
 let __timeout;
+const __reloading = new WeakSet<Worker>();
 
 async function _closeInner() {
   __timeout = setTimeout(() => {
@@ -23,32 +27,39 @@ export function handleProcessMaster(workers: number) {
     });
   });
 
-  for (let i = 0; i < workers; i++) {
-    cluster.fork();
-  }
-
   cluster.on('message', (worker, message) => {
     if (message === 'reload-worker') {
       if (!__closing) {
         cluster.fork();
       }
+      __reloading.add(worker);
       worker.process.kill('SIGTERM');
     }
   });
 
   cluster.on('exit', (_worker, _code, _signal) => {
-    // console.log(`----------------- worker ${_worker.process.pid} died`, _code, _signal);
+    const expectedSignal =
+      (__closing && ['SIGINT', 'SIGUSR2', 'SIGTERM'].includes(_signal)) ||
+      (__reloading.has(_worker) && _signal === 'SIGTERM');
+    __reloading.delete(_worker);
+    if ((_code !== 0 || _signal) && !expectedSignal) {
+      __failed = true;
+    }
     if (cluster.workers && Object.keys(cluster.workers).length === 0) {
       clearTimeout(__timeout);
       // log
       const app = useApp();
       if (app.meta.env.LOGGER_DUMMY !== 'true') {
-        const message = `Master shutdown gracefully: ${process.pid}`;
+        const message = `Master shutdown ${__failed ? 'with worker failure' : 'gracefully'}: ${process.pid}`;
         // eslint-disable-next-line
         console.log(chalk.cyan(message));
       }
       // exit
-      process.exit(0);
+      process.exit(__failed ? 1 : 0);
     }
   });
+
+  for (let i = 0; i < workers; i++) {
+    cluster.fork();
+  }
 }

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

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+
+const startUrl = new URL('./start.ts', import.meta.url).href;
+
+// Execute Start's real lifecycle with only its imported collaborators mocked. No application,
+// environment files, database/Redis connections, or server listeners are created.
+const lifecycleSource = `
+  import assert from 'node:assert/strict';
+  import { readFile } from 'node:fs/promises';
+  import { registerHooks } from 'node:module';
+  const startUrl = ${JSON.stringify(startUrl)};
+  const mocks = {
+    '../../types/index.ts': 'export const EnumAppEvent = { AppStartError: "error", AppStarted: "started" };',
+    '../core/isolationGuard.ts': 'export function assertIsolatedTestConfig() {}',
+    '../core/testClaim.ts': 'export function registerTestClaimResourceInventory() {}',
+    '../module/loader.ts': 'export class ModuleLoader { async execute() { await globalThis.phase("Load"); } }',
+    '../utils/util.ts': 'export function deepExtend(target, source) { Object.assign(target, source); }',
+  };
+  registerHooks({
+    resolve(specifier, context, nextResolve) {
+      if (context.parentURL === startUrl && mocks[specifier]) {
+        return { url: 'data:text/javascript,' + encodeURIComponent(mocks[specifier]), shortCircuit: true };
+      }
+      return nextResolve(specifier, context);
+    },
+  });
+  const { Start } = await import(startUrl);
+  const [projectPath, lockPath, lockContents, failingPhase] = process.argv.slice(1);
+  const phases = [];
+  const events = [];
+  const failure = new Error(failingPhase);
+  globalThis.phase = async phase => {
+    assert.equal(await readFile(lockPath, 'utf8'), lockContents);
+    phases.push(phase);
+    if (phase === failingPhase) throw failure;
+  };
+  const config = {
+    database: { testDatabase: true },
+    server: { keys: ['test-key'], subdomainOffset: 2 },
+    proxy: { enable: false, ipHeaders: 'X-Forwarded-For', maxIpsCount: 0 },
+  };
+  const app = {
+    projectPath,
+    name: 'app',
+    meta: { env: { META_MODE: 'dev' } },
+    options: { async config() {
+      await globalThis.phase('Config');
+      return { default: [() => config] };
+    } },
+    bean: { _newBean: Bean => new Bean() },
+    util: { async monkeyModule(_appMonkey, _modulesMonkey, _forward, hook) {
+      await globalThis.phase(hook.slice(3));
+    } },
+    emit(event, error) {
+      events.push({ event, error, phases: [...phases] });
+    },
+  };
+  const start = new Start(app);
+  const order = ['Config', 'Load', 'Start', 'Ready', 'Started'];
+  if (failingPhase) {
+    await assert.rejects(start.start(), error => error === failure);
+    assert.equal(app.meta.appStartError, failure);
+    assert.deepEqual(phases, order.slice(0, order.indexOf(failingPhase) + 1));
+    assert.equal(events.at(-1).event, 'error');
+    assert.equal(events.at(-1).error, failure);
+    assert.deepEqual(events.at(-1).phases, phases);
+  } else {
+    await start.start();
+    assert.deepEqual(phases, order);
+    assert.equal(app.meta.appStartError, undefined);
+  }
+  const reachesStarted = !failingPhase || failingPhase === 'Started';
+  assert.equal(app.meta.appStarted, reachesStarted ? true : undefined);
+  const reachesReady = reachesStarted || failingPhase === 'Ready';
+  assert.equal(app.meta.appReady, reachesReady ? true : undefined);
+  if (reachesReady) assert.deepEqual(app.meta.appReadyInstances, {});
+  assert.deepEqual(events.map(item => item.event), [
+    ...(reachesStarted ? ['started'] : []),
+    ...(failingPhase ? ['error'] : []),
+  ]);
+  if (reachesStarted) {
+    assert.deepEqual(events[0].phases, ['Config', 'Load', 'Start', 'Ready']);
+  }
+  assert.equal(await readFile(lockPath, 'utf8'), lockContents);
+  console.log('verified');
+`;
+
+for (const failingPhase of ['', 'Config', 'Load', 'Start', 'Ready', 'Started']) {
+  test(`Start ignores the legacy preparation lock on ${failingPhase ? `${failingPhase} failure` : 'success'}`, async () => {
+    const root = await mkdtemp(path.join(await realpath(tmpdir()), 'vona-start-'));
+    try {
+      const identity = createHash('sha256')
+        .update(JSON.stringify([root, 'app']))
+        .digest('hex');
+      const lockPath = path.join(root, '.app', 'dev-database-preparation', `${identity}.lock`);
+      const lockContents = `${JSON.stringify({ token: 'legacy-owner', pid: process.pid })}\n`;
+      await mkdir(path.dirname(lockPath), { recursive: true });
+      await writeFile(lockPath, lockContents);
+      const result = spawnSync(
+        process.execPath,
+        [
+          '--input-type=module',
+          '--eval',
+          lifecycleSource,
+          root,
+          lockPath,
+          lockContents,
+          failingPhase,
+        ],
+        { encoding: 'utf8', timeout: 5_000 },
+      );
+      assert.ifError(result.error);
+      assert.equal(result.signal, null, result.stderr);
+      assert.equal(result.status, 0, result.stderr);
+      assert.equal(result.stdout.trim(), 'verified');
+      assert.equal(await readFile(lockPath, 'utf8'), lockContents);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+}

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

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

package/vona/pnpm-lock.yaml

@@ -1652,7 +1652,7 @@ importers:
         specifier: ^5.0.3
         version: link:modules/a-markdown
       vona-module-a-rbac:
-        specifier: ^5.0.9
+        specifier: ^5.0.10
         version: link:modules/a-rbac
       vona-module-a-socket:
         specifier: workspace:^

package/vona/src/suite-vendor/a-vona/modules/a-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-core",
-  "version": "5.1.58",
+  "version": "5.1.59",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-redis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-redis",
-  "version": "5.1.17",
+  "version": "5.1.18",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-redis/src/service/redis.ts

@@ -1,67 +1,102 @@
 import type { Redis } from 'ioredis';
 
-import { BeanBase, resolveTestRunId } from 'vona';
+import { assertTestAppIdentity, BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
 
 import type { IRedisClientRecord } from '../types/redis.ts';
 
 import { getRedisClientKeyPrefix, prepareRedisClientKeyPrefix } from '../lib/redis.ts';
 
+interface RedisCleanupTarget {
+  redis: Redis;
+  expectedPrefix: string;
+  keyPrefix: string | undefined;
+}
+
 @Service()
 export class ServiceRedis extends BeanBase {
   async clearAllData() {
     const app = this.app;
-    // clear keys
-    await this._clearRedisKeys(
-      app.bean.redis.get('queue'),
-      getRedisClientKeyPrefix('bull', app),
-      true,
+    const isolated = assertTestAppIdentity(
+      app.meta.env.META_MODE,
+      app.meta.env.VONA_TEST_RUN_ID,
+      app.name,
     );
-    // broadcast channel has subscribed
-    // await _clearRedisKeys(app.redis.get('broadcast'), `${getRedisClientKeyPrefix('broadcast', app)}*`);
-    for (const _clientName in app.config.redis.clients) {
+    if (isolated && app.config.redis.base.keyPrefix !== undefined) {
+      throw new Error('Isolated test cannot inherit a Redis base keyPrefix');
+    }
+
+    // Prepare every target before looking up keys or deleting anything.
+    const targets = [this._prepareCleanupTarget('queue', Boolean(isolated))];
+    for (const _clientName of Object.keys(app.config.redis.clients)) {
       const clientName = _clientName as keyof IRedisClientRecord;
+      // Broadcast carries subscriptions, not cleanup keys.
       if (['queue', 'broadcast'].includes(clientName)) continue;
-      if (clientName.startsWith('redlock')) {
-        await this._clearRedisKeys(
-          app.bean.redis.get(clientName),
-          getRedisClientKeyPrefix('redlock', app),
-          true,
-        );
-      } else {
-        const client = app.config.redis.clients[clientName];
-        const keyPrefix = prepareRedisClientKeyPrefix(client.keyPrefix, clientName, this.app);
-        await this._clearRedisKeys(app.bean.redis.get(clientName), keyPrefix!);
+      targets.push(this._prepareCleanupTarget(clientName, Boolean(isolated)));
+    }
+
+    // KEYS returns full keys even for prefixed clients. Validate the complete
+    // lookup result for every target before issuing the first DEL.
+    const deletions: { redis: Redis; keys: string[] }[] = [];
+    for (const { redis, expectedPrefix, keyPrefix } of targets) {
+      const fullKeys = await redis.keys(`${expectedPrefix}*`);
+      if (
+        !Array.isArray(fullKeys) ||
+        fullKeys.some(key => typeof key !== 'string' || !key.startsWith(expectedPrefix))
+      ) {
+        throw new Error('Redis cleanup lookup returned a key outside the owned prefix');
       }
+      deletions.push({
+        redis,
+        keys: fullKeys.map(key => (keyPrefix ? key.substring(keyPrefix.length) : key)),
+      });
+    }
+    for (const { redis, keys } of deletions) {
+      if (keys.length > 0) await redis.del(keys);
     }
   }
 
-  private async _clearRedisKeys(redis: Redis, expectedPrefix: string, unprefixedClient = false) {
-    if (!redis) return;
-    const isolated = resolveTestRunId(
-      this.app.meta.env.META_MODE,
-      this.app.meta.env.VONA_TEST_RUN_ID,
+  private _prepareCleanupTarget(
+    clientName: keyof IRedisClientRecord,
+    isolated: boolean,
+  ): RedisCleanupTarget {
+    const app = this.app;
+    const configClient = app.config.redis.clients[clientName];
+    if (!configClient) throw new Error(`Redis cleanup client is not configured: ${clientName}`);
+    if (isolated && ('sentinels' in configClient || 'nodes' in configClient)) {
+      throw new Error(`Isolated test cannot use a Redis sentinel or cluster client: ${clientName}`);
+    }
+    const unprefixedClient = clientName === 'queue' || clientName.startsWith('redlock');
+    const frameworkPrefix = getRedisClientKeyPrefix(
+      clientName === 'queue' ? 'bull' : unprefixedClient ? 'redlock' : clientName,
+      app,
     );
-    const keyPrefix = redis.options.keyPrefix;
-    if (isolated) {
-      if (!expectedPrefix.includes(this.app.name) || !expectedPrefix.endsWith(':')) {
-        throw new Error('Isolated test Redis cleanup prefix does not belong to this run');
-      }
-      if (unprefixedClient ? Boolean(keyPrefix) : keyPrefix !== expectedPrefix) {
-        throw new Error('Isolated test Redis cleanup uses an unexpected client prefix');
-      }
+    const configuredPrefix = prepareRedisClientKeyPrefix(configClient.keyPrefix, clientName, app);
+    const expectedPrefix = unprefixedClient ? frameworkPrefix : configuredPrefix;
+    if (
+      !app.name ||
+      typeof expectedPrefix !== 'string' ||
+      !expectedPrefix.startsWith(frameworkPrefix) ||
+      !expectedPrefix.endsWith(':') ||
+      /[*?[\]\\]/.test(expectedPrefix) ||
+      Array.from(expectedPrefix).some(
+        char => char.charCodeAt(0) <= 32 || char.charCodeAt(0) === 127,
+      )
+    ) {
+      throw new Error(`Redis cleanup prefix does not belong to this app: ${clientName}`);
     }
-    const keys = await redis.keys(`${expectedPrefix}*`);
-    const keysDel: string[] = [];
-    for (const fullKey of keys) {
-      if (isolated && !fullKey.startsWith(expectedPrefix)) {
-        throw new Error('Isolated test Redis lookup returned a key outside the owned prefix');
-      }
-      const key = keyPrefix ? fullKey.substring(keyPrefix.length) : fullKey;
-      keysDel.push(key);
+    // Custom prefixes may narrow the framework namespace, never widen it.
+    if (unprefixedClient && configuredPrefix !== undefined && configuredPrefix !== '') {
+      throw new Error(`Redis cleanup requires an unprefixed client: ${clientName}`);
     }
-    if (keysDel.length > 0) {
-      await redis.del(keysDel);
+    const redis = app.bean.redis.get(clientName);
+    if (!redis?.options) throw new Error(`Redis cleanup client is unavailable: ${clientName}`);
+    const keyPrefix = redis.options.keyPrefix;
+    if (
+      unprefixedClient ? keyPrefix !== undefined && keyPrefix !== '' : keyPrefix !== expectedPrefix
+    ) {
+      throw new Error(`Redis cleanup uses an unexpected client prefix: ${clientName}`);
     }
+    return { redis, expectedPrefix, keyPrefix };
   }
 }