cabloy 5.1.213 → 5.1.214

package/vona/src/suite-vendor/a-vona/modules/a-startup/test/devSeed.test.ts

@@ -1,22 +1,45 @@
 import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
+import { afterEach, beforeEach, describe, it } from 'node:test';
 
+import { ServiceInstance } from '../../a-instance/src/service/instance.ts';
 import { ServiceStartup } from '../src/service/startup.ts';
 
 function fixture(created: string[] = []) {
   const calls: string[] = [];
+  const optionsSeen: { name: string; instance: string | null; force?: boolean }[] = [];
   const pending = new Set(created);
   const app = {
-    meta: { isDev: true, isTest: false, appReadyInstances: {} as Record<string, boolean> },
+    meta: {
+      isDev: true,
+      isTest: false,
+      appReady: true,
+      appReadyInstances: {} as Record<string, boolean>,
+      env: {},
+    },
     config: { server: { listen: { disable: false } } },
   };
   const service = Object.create(ServiceStartup.prototype) as ServiceStartup;
   const startups = [
+    { name: 'a-version:databaseInit', beanOptions: { options: {} } },
+    { name: 'a-version:databaseName', beanOptions: { options: {} } },
     { name: 'a-version:instanceInit', beanOptions: { options: { instance: true } } },
+    { name: 'a-schedule:loadSchedules', beanOptions: { options: { instance: true, after: true } } },
     { name: 'a-runtime:runtime', beanOptions: { options: { instance: true, after: true } } },
+    { name: 'a-printtip:printTip', beanOptions: { options: { instance: true, after: true } } },
     { name: 'a-queue:loadQueueWorkers', beanOptions: { options: { instance: true, after: true } } },
     { name: 'a-web:listen', beanOptions: { options: { after: true } } },
   ];
+  function instanceService(instanceName: string) {
+    const instance = Object.create(ServiceInstance.prototype) as ServiceInstance;
+    Object.defineProperties(instance, {
+      app: { value: app },
+      ctx: { value: { app, instanceName } },
+      $scope: { value: { startup: { service: { startup: service } } } },
+      getConfigInstanceBase: { value: () => ({}) },
+      _cacheInstanceConfig: { value: async () => {} },
+    });
+    return instance;
+  }
   Object.defineProperties(service, {
     app: { value: app },
     _startups: { value: startups },
@@ -26,6 +49,9 @@ function fixture(created: string[] = []) {
         version: {
           service: {
             database: {
+              prepareDevDatabases: async () => {
+                calls.push('prepareDevDatabases');
+              },
               get createdInstanceNames() {
                 return [...pending];
               },
@@ -42,42 +68,115 @@ function fixture(created: string[] = []) {
           service: {
             instance: {
               instanceStartupIsolate: async (name: string, options: any) =>
-                service.runStartupInstance(name as never, options),
+                instanceService(name).instanceStartup(name as never, options),
             },
           },
         },
       },
     },
-    runStartup: {
-      value: async (name: string, instance: string) => {
-        calls.push(`${name}:${instance}`);
-      },
-    },
   });
-  return { service, app, calls, pending };
+  service.runStartup = async (name, instance, options) => {
+    calls.push(`${name}:${instance}`);
+    optionsSeen.push({ name, instance: instance as string | null, force: options?.force });
+    if (
+      startups.find(startup => startup.name === name)?.beanOptions.options.after === true &&
+      instance !== null
+    ) {
+      assert.equal(app.meta.appReadyInstances[instance as string], true);
+    }
+  };
+  return { service, app, calls, pending, instanceService, optionsSeen, startups };
 }
 
+const defaultCalls = [
+  'a-version:instanceInit:',
+  'seed:',
+  'a-schedule:loadSchedules:',
+  'a-runtime:runtime:',
+  'a-printtip:printTip:',
+  'a-queue:loadQueueWorkers:',
+];
+const isolateCalls = [
+  'a-version:instanceInit:isolateTest',
+  'a-schedule:loadSchedules:isolateTest',
+  'a-runtime:runtime:isolateTest',
+  'a-printtip:printTip:isolateTest',
+  'a-queue:loadQueueWorkers:isolateTest',
+];
+
 describe('creation-driven dev seed', { concurrency: false }, () => {
-  it('seeds fresh instances before runtime, queues, and listening', async () => {
-    const { service, calls, pending, app } = fixture(['', 'isolateTest']);
+  let previousReset: string | undefined;
+  beforeEach(() => {
+    previousReset = process.env.VONA_DB_RESET;
+    delete process.env.VONA_DB_RESET;
+  });
+  afterEach(() => {
+    if (previousReset === undefined) delete process.env.VONA_DB_RESET;
+    else process.env.VONA_DB_RESET = previousReset;
+  });
+
+  it('skips all after-startups during reset while completing data preparation', async () => {
+    process.env.VONA_DB_RESET = 'true';
+    const { service, app, calls, pending, optionsSeen, startups } = fixture(['', 'isolateTest']);
+    startups.push(
+      { name: 'test:prepareApp', beanOptions: { options: { after: false } } },
+      { name: 'test:prepareInstance', beanOptions: { options: { instance: true, after: false } } },
+      { name: 'test:afterApp', beanOptions: { options: { after: true } } },
+      { name: 'test:afterInstance', beanOptions: { options: { instance: true, after: true } } },
+    );
+    await service.appStart();
     await service.appReady();
+    assert.deepEqual(calls, [
+      'prepareDevDatabases',
+      'a-version:databaseInit:null',
+      'a-version:databaseName:null',
+      'test:prepareApp:null',
+      'a-version:instanceInit:',
+      'test:prepareInstance:',
+      'seed:',
+      'a-version:instanceInit:isolateTest',
+      'test:prepareInstance:isolateTest',
+    ]);
+    assert.equal(app.config.server.listen.disable, true);
     assert.equal(pending.size, 0);
-    const lastSeed = calls.indexOf('seed:isolateTest');
-    assert.ok(lastSeed > calls.indexOf('seed:'));
-    for (const call of ['a-runtime:runtime:', 'a-queue:loadQueueWorkers:', 'a-web:listen:null']) {
-      assert.ok(calls.indexOf(call) > lastSeed, `${call} must follow all seeds`);
-    }
+    assert.deepEqual(app.meta.appReadyInstances, { '': true, 'isolateTest': true });
+    assert.equal(optionsSeen.find(call => call.name === 'a-version:databaseInit')?.force, true);
+    assert.ok(
+      optionsSeen.filter(call => call.instance !== null).every(call => call.force === true),
+    );
+  });
+
+  it('retains after-startups when the reset flag is false', async () => {
+    process.env.VONA_DB_RESET = 'false';
+    const { service, calls } = fixture(['', 'isolateTest']);
+    await service.appReady();
+    assert.deepEqual(calls, [...defaultCalls, ...isolateCalls, 'a-web:listen:null']);
+  });
+
+  it('seeds only default and completes each instance before application after-startups', async () => {
+    const { service, calls, pending, app, optionsSeen, instanceService } = fixture([
+      '',
+      'isolateTest',
+    ]);
+    await service.appReady();
+    assert.equal(pending.size, 0);
+    assert.deepEqual(calls, [...defaultCalls, ...isolateCalls, 'a-web:listen:null']);
     assert.equal(app.meta.appReadyInstances[''], true);
     assert.equal(app.meta.appReadyInstances.isolateTest, true);
-    await service.runStartupInstance('' as never);
+    assert.ok(
+      optionsSeen.filter(call => call.instance !== null).every(call => call.force === true),
+    );
+    await instanceService('').instanceStartup('' as never, { force: true });
     assert.equal(calls.filter(call => call === 'seed:').length, 1);
   });
 
-  it('does not seed existing default when only an isolated database is new', async () => {
-    const { service, calls } = fixture(['isolateTest']);
+  it('does not seed either instance when only an isolated database is new', async () => {
+    const { service, calls, pending, app } = fixture(['isolateTest']);
     await service.appReady();
-    assert.ok(calls.includes('seed:isolateTest'));
-    assert.ok(!calls.includes('seed:'));
+    assert.ok(!calls.some(call => call.startsWith('seed:')));
+    assert.ok(calls.includes('a-version:instanceInit:isolateTest'));
+    assert.equal(pending.size, 0);
+    assert.equal(app.meta.appReadyInstances.isolateTest, true);
   });
 
   it('does not seed when all databases are reused', async () => {
@@ -86,19 +185,172 @@ describe('creation-driven dev seed', { concurrency: false }, () => {
     assert.ok(!calls.some(call => call.startsWith('seed:')));
   });
 
-  it('fails before after-startups and readiness if seeding fails', async () => {
-    const { service, app, calls, pending } = fixture(['']);
+  it('retains default-only test seeding through its existing lifecycle even with the reset flag', async () => {
+    process.env.VONA_DB_RESET = 'true';
+    const { service, app, calls } = fixture();
+    app.meta.isDev = false;
+    app.meta.isTest = true;
+    await service.appReady();
+    assert.deepEqual(calls, [
+      'a-web:listen:null',
+      'a-version:instanceInit:',
+      'a-schedule:loadSchedules:',
+      'a-runtime:runtime:',
+      'a-printtip:printTip:',
+      'a-queue:loadQueueWorkers:',
+      'seed:',
+    ]);
+  });
+
+  it('fails before after-startups and readiness if default seeding fails', async () => {
+    const { service, app, calls, pending } = fixture(['', 'isolateTest']);
     (service as any).$scope.version.service.version.__instanceSeed = async () => {
       throw new Error('seed failed');
     };
     await assert.rejects(service.appReady(), /seed failed/);
-    assert.ok(pending.has(''));
+    assert.deepEqual([...pending], ['', 'isolateTest']);
     assert.deepEqual(app.meta.appReadyInstances, {});
-    assert.ok(
-      !calls.some(
-        call =>
-          call.includes('runtime') || call.includes('listen') || call.includes('loadQueueWorkers'),
-      ),
-    );
+    assert.deepEqual(calls, ['a-version:instanceInit:']);
+  });
+
+  it('retains completed default readiness if later isolate initialization fails', async () => {
+    const { service, app, calls, pending } = fixture(['', 'isolateTest']);
+    const runStartup = service.runStartup.bind(service);
+    service.runStartup = async (name, instance, options) => {
+      if (name === 'a-version:instanceInit' && instance === 'isolateTest') {
+        throw new Error('isolate init failed');
+      }
+      await runStartup(name, instance, options);
+    };
+    await assert.rejects(service.appReady(), /isolate init failed/);
+    assert.deepEqual([...pending], ['isolateTest']);
+    assert.deepEqual(app.meta.appReadyInstances, { '': true });
+    assert.deepEqual(calls, defaultCalls);
+  });
+
+  for (const failure of ['seed', 'isolate init']) {
+    it(`preserves reset failure state when ${failure} fails`, async () => {
+      process.env.VONA_DB_RESET = 'true';
+      const { service, app, calls, pending } = fixture(['', 'isolateTest']);
+      if (failure === 'seed') {
+        (service as any).$scope.version.service.version.__instanceSeed = async () => {
+          throw new Error('seed failed');
+        };
+      } else {
+        const runStartup = service.runStartup.bind(service);
+        service.runStartup = async (name, instance, options) => {
+          if (name === 'a-version:instanceInit' && instance === 'isolateTest') {
+            throw new Error('isolate init failed');
+          }
+          await runStartup(name, instance, options);
+        };
+      }
+      await assert.rejects(service.appReady(), new RegExp(`${failure} failed`));
+      assert.deepEqual([...pending], failure === 'seed' ? ['', 'isolateTest'] : ['isolateTest']);
+      assert.deepEqual(app.meta.appReadyInstances, failure === 'seed' ? {} : { '': true });
+      assert.deepEqual(
+        calls,
+        failure === 'seed' ? ['a-version:instanceInit:'] : ['a-version:instanceInit:', 'seed:'],
+      );
+    });
+  }
+
+  for (const [phase, reset] of [
+    ['init', false],
+    ['seed', false],
+    ['init', true],
+    ['seed', true],
+  ] as const) {
+    it(`skips queued broadcast-style startup requests received during ${phase} (reset=${reset})`, async () => {
+      if (reset) process.env.VONA_DB_RESET = 'true';
+      const { service, calls, instanceService, app, pending } = fixture(['']);
+      const entered = Promise.withResolvers<void>();
+      const release = Promise.withResolvers<void>();
+      const enqueued = Promise.withResolvers<void>();
+      if (phase === 'init') {
+        const runStartup = service.runStartup.bind(service);
+        service.runStartup = async (name, instance, options) => {
+          await runStartup(name, instance, options);
+          if (name === 'a-version:instanceInit') {
+            entered.resolve();
+            await release.promise;
+          }
+        };
+      } else {
+        (service as any).$scope.version.service.version.__instanceSeed = async () => {
+          calls.push('seed:');
+          entered.resolve();
+          await release.promise;
+        };
+      }
+      const startup = service.appReady();
+      await entered.promise;
+      const competitor = instanceService('');
+      const queue = competitor.__queueInstanceStartup[''];
+      const push = queue.push.bind(queue);
+      queue.push = (...args: unknown[]) => {
+        const result = push(...args);
+        enqueued.resolve();
+        return result;
+      };
+      let delivered = false;
+      const delivery = competitor.checkAppReadyInstance(true).then(() => {
+        delivered = true;
+      });
+      try {
+        await enqueued.promise;
+        assert.equal(delivered, false);
+      } finally {
+        release.resolve();
+        await Promise.all([startup, delivery]);
+      }
+      assert.equal(delivered, true);
+      assert.equal(app.meta.appReadyInstances[''], true);
+      assert.equal(pending.size, 0);
+      assert.deepEqual(
+        calls,
+        reset ? ['a-version:instanceInit:', 'seed:'] : [...defaultCalls, 'a-web:listen:null'],
+      );
+    });
+  }
+
+  it('preserves forced after-startup debounce semantics', async t => {
+    const service = Object.create(ServiceStartup.prototype) as ServiceStartup;
+    const getset = t.mock.fn(async () => true);
+    const execute = t.mock.fn(async () => {});
+    Object.defineProperties(service, {
+      app: { value: { meta: { isTest: false } } },
+      ctx: { value: { instance: { id: 1 } } },
+      scope: {
+        value: {
+          config: { startup: { debounce: 1000 } },
+          cacheRedis: { startupDebounce: { getset } },
+        },
+      },
+      _runStartupInner: { value: execute },
+    });
+    const startup = {
+      name: 'a-runtime:runtime',
+      beanOptions: { options: { instance: true, after: true, debounce: true } },
+    };
+    await service._runStartupLock(startup as never, '' as never, { force: true });
+    assert.equal(getset.mock.callCount(), 0);
+    assert.equal(execute.mock.callCount(), 1);
+    await service._runStartupLock(startup as never, '' as never, { force: false });
+    assert.equal(getset.mock.callCount(), 1);
+    assert.equal(execute.mock.callCount(), 1);
+  });
+
+  it('allows readiness checks during after-startups without reentering its queue', async () => {
+    const { service, calls, instanceService } = fixture(['']);
+    const runStartup = service.runStartup.bind(service);
+    service.runStartup = async (name, instance, options) => {
+      await runStartup(name, instance, options);
+      if (name === 'a-runtime:runtime') {
+        assert.equal(await instanceService('').checkAppReadyInstance(true), true);
+      }
+    };
+    await service.appReady();
+    assert.deepEqual(calls, [...defaultCalls, 'a-web:listen:null']);
   });
 });

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-version",
-  "version": "5.1.20",
+  "version": "5.1.21",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona-module-a-version",
   "keywords": [

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

@@ -63,6 +63,9 @@ export class ServiceVersion extends BeanBase {
 
   async __instanceSeed(instanceName: keyof IInstanceRecord) {
     await this.__check({ scene: 'seed', instanceName });
+    this.$logger.silly(
+      chalk.cyan(`The instance is seeded successfully: ${instanceName || 'default'}`),
+    );
   }
 
   // scene: update/init/seed

package/vona/src/suite-vendor/a-vona/modules/a-version/test/instanceSeed.test.ts

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { ServiceVersion } from '../src/service/version.ts';
+
+function fixture(check: ServiceVersion['__check']) {
+  const messages: string[] = [];
+  const service = Object.create(ServiceVersion.prototype) as ServiceVersion;
+  Object.defineProperties(service, {
+    __check: { value: check },
+    $logger: { value: { silly: (message: string) => messages.push(message) } },
+  });
+  return { service, messages };
+}
+
+describe('instance seed completion', () => {
+  it('logs default completion only after seeding succeeds', async () => {
+    const entered = Promise.withResolvers<void>();
+    const release = Promise.withResolvers<void>();
+    const { service, messages } = fixture(async options => {
+      assert.equal(options.scene, 'seed');
+      assert.equal(options.instanceName, '');
+      entered.resolve();
+      await release.promise;
+      return {};
+    });
+    const seeding = service.__instanceSeed('');
+    try {
+      await entered.promise;
+      assert.deepEqual(messages, []);
+    } finally {
+      release.resolve();
+      await seeding;
+    }
+    assert.deepEqual(messages, [chalk.cyan('The instance is seeded successfully: default')]);
+  });
+
+  it('propagates seed failure without logging success', async () => {
+    const error = new Error('seed failed');
+    const { service, messages } = fixture(async () => {
+      throw error;
+    });
+    await assert.rejects(service.__instanceSeed(''), error);
+    assert.deepEqual(messages, []);
+  });
+});

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-vona",
-  "version": "5.1.99",
+  "version": "5.1.100",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/zova/pnpm-lock.yaml

@@ -455,7 +455,7 @@ importers:
         specifier: ^7.6.2
         version: 7.8.5
       zova-cli-set-front:
-        specifier: ^1.2.109
+        specifier: ^1.2.111
         version: link:../cli-set-front
     devDependencies:
       clean-package:
@@ -876,7 +876,7 @@ importers:
         specifier: ^5.1.92
         version: link:../zova-core
       zova-suite-a-zova:
-        specifier: ^5.1.166
+        specifier: ^5.1.170
         version: link:../../src/suite-vendor/a-zova
     devDependencies:
       clean-package:
@@ -986,7 +986,7 @@ importers:
         specifier: ^5.0.1
         version: link:modules/a-rbac
       zova-module-rest-resource:
-        specifier: ^5.1.55
+        specifier: ^5.1.56
         version: link:modules/rest-resource
 
   src/suite-vendor/a-cabloy/modules/a-layoutprofile:
@@ -1091,7 +1091,7 @@ importers:
         specifier: ^5.1.25
         version: link:modules/a-fetch
       zova-module-a-form:
-        specifier: ^5.1.51
+        specifier: ^5.1.54
         version: link:modules/a-form
       zova-module-a-icon:
         specifier: ^5.1.27
@@ -1106,19 +1106,19 @@ importers:
         specifier: ^5.1.22
         version: link:modules/a-meta
       zova-module-a-model:
-        specifier: ^5.1.37
+        specifier: ^5.1.38
         version: link:modules/a-model
       zova-module-a-openapi:
-        specifier: ^5.1.55
+        specifier: ^5.1.57
         version: link:modules/a-openapi
       zova-module-a-router:
-        specifier: ^5.1.41
+        specifier: ^5.1.42
         version: link:modules/a-router
       zova-module-a-routerstack:
         specifier: ^5.1.29
         version: link:modules/a-routerstack
       zova-module-a-routertabs:
-        specifier: ^5.1.34
+        specifier: ^5.1.35
         version: link:modules/a-routertabs
       zova-module-a-ssr:
         specifier: ^5.1.40