cabloy 5.1.206 → 5.1.207

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

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

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

@@ -28,17 +28,22 @@ export class ServiceStartup extends BeanBase {
     }
     // clear keys
     await this._clearResources();
+    if (this.app.meta.isDev) {
+      await this.bean.executor.newCtx(
+        () => this.$scope.version.service.database.prepareDevDatabases(),
+        { dbInfo: { level: 1 }, instanceName: null },
+      );
+    }
 
     // run startups: not after
     for (const startup of this._startups) {
       const startupOptions = startup.beanOptions.options;
       if (!startupOptions?.instance && startupOptions?.after !== true) {
-        // A previous dev startup may have left databaseInit's debounce key in Redis.
-        // Only the explicit reset must bypass that key to guarantee recreation.
         const force =
           this.app.meta.isDev &&
-          process.env.VONA_DB_RESET === 'true' &&
-          startup.name === 'a-version:databaseInit';
+          startup.name === 'a-version:databaseInit' &&
+          (process.env.VONA_DB_RESET === 'true' ||
+            this.$scope.version.service.database.createdInstanceNames.length > 0);
         const run = () => this.runStartup(startup.name, null, force ? { force: true } : undefined);
         if (this.app.meta.env.VONA_TEST_RUN_ID && startup.name === 'a-version:databaseInit') {
           const defaultClient = this.app.config.database.defaultClient;
@@ -55,6 +60,25 @@ export class ServiceStartup extends BeanBase {
   }
 
   async appReady() {
+    const createdInstances = this.$scope.version.service.database.createdInstanceNames;
+    const preparingDev = this.app.meta.isDev && createdInstances.length > 0;
+    if (preparingDev) {
+      // Initialize and seed fresh instances before listeners or queue workers start.
+      const instanceNames = [
+        '',
+        ...createdInstances.filter(name => name !== ''),
+      ] as (keyof IInstanceRecord)[];
+      for (const instanceName of instanceNames) {
+        await this._appReadyInstanceStartup(instanceName, true, true);
+      }
+      for (const instanceName of instanceNames) {
+        await this.bean.executor.newCtx(() => this.runStartupInstanceAfter(instanceName), {
+          dbInfo: { level: 1 },
+          instanceName,
+        });
+      }
+    }
+
     // run startups: after
     for (const startup of this._startups) {
       const startupOptions = startup.beanOptions.options;
@@ -65,7 +89,7 @@ export class ServiceStartup extends BeanBase {
 
     // version init : force: should be false
     if (this.app.meta.isTest || this.app.meta.isDev) {
-      await this._appReadyInstanceStartup('', true);
+      if (!preparingDev) await this._appReadyInstanceStartup('', true);
     } else {
       // only start static instances (defined in config)
       for (const key in this.app.config.instance.instances) {
@@ -78,8 +102,8 @@ export class ServiceStartup extends BeanBase {
       }
     }
 
-    // Seed test runs and explicit development resets only, after instance initialization.
-    if (this.app.meta.isTest || (this.app.meta.isDev && process.env.VONA_DB_RESET === 'true')) {
+    // Test seeding retains its existing lifecycle; dev seeding belongs to fresh instances.
+    if (this.app.meta.isTest) {
       await this.seedDefaultInstance();
     }
   }
@@ -94,9 +118,17 @@ export class ServiceStartup extends BeanBase {
     );
   }
 
-  private async _appReadyInstanceStartup(instanceName: keyof IInstanceRecord, wait: boolean) {
+  private async _appReadyInstanceStartup(
+    instanceName: keyof IInstanceRecord,
+    wait: boolean,
+    deferAfter?: boolean,
+  ) {
     const res = this.$scope.instance.service.instance.instanceStartupIsolate(instanceName, {
-      force: this.app.meta.isDev && process.env.VONA_DB_RESET === 'true',
+      force:
+        this.app.meta.isDev &&
+        (process.env.VONA_DB_RESET === 'true' ||
+          this.$scope.version.service.database.createdInstanceNames.includes(instanceName)),
+      deferAfter,
     });
     if (wait) {
       await res;
@@ -182,6 +214,21 @@ export class ServiceStartup extends BeanBase {
         await this.runStartup(startup.name, instanceName, options);
       }
     }
+    if (
+      this.app.meta.isDev &&
+      this.$scope.version.service.database.createdInstanceNames.includes(instanceName)
+    ) {
+      await this.$scope.version.service.version.__instanceSeed(instanceName);
+      this.$scope.version.service.database.consumeCreatedInstance(instanceName);
+    }
+    if (options?.deferAfter) return;
+    await this.runStartupInstanceAfter(instanceName, options);
+  }
+
+  async runStartupInstanceAfter(
+    instanceName: keyof IInstanceRecord,
+    options?: IInstanceStartupOptions,
+  ) {
     // set flag
     this.app.meta.appReadyInstances[instanceName] = true;
     // run startups: after

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

@@ -22,6 +22,7 @@ export interface IDecoratorStartupOptions
 
 export interface IInstanceStartupOptions {
   force?: boolean;
+  deferAfter?: boolean;
   configInstanceBase?: ConfigInstanceBase;
 }
 

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

@@ -0,0 +1,104 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { ServiceStartup } from '../src/service/startup.ts';
+
+function fixture(created: string[] = []) {
+  const calls: string[] = [];
+  const pending = new Set(created);
+  const app = {
+    meta: { isDev: true, isTest: false, appReadyInstances: {} as Record<string, boolean> },
+    config: { server: { listen: { disable: false } } },
+  };
+  const service = Object.create(ServiceStartup.prototype) as ServiceStartup;
+  const startups = [
+    { name: 'a-version:instanceInit', beanOptions: { options: { instance: true } } },
+    { name: 'a-runtime:runtime', beanOptions: { options: { instance: true, after: true } } },
+    { name: 'a-queue:loadQueueWorkers', beanOptions: { options: { instance: true, after: true } } },
+    { name: 'a-web:listen', beanOptions: { options: { after: true } } },
+  ];
+  Object.defineProperties(service, {
+    app: { value: app },
+    _startups: { value: startups },
+    bean: { value: { executor: { newCtx: async (fn: () => Promise<unknown>) => fn() } } },
+    $scope: {
+      value: {
+        version: {
+          service: {
+            database: {
+              get createdInstanceNames() {
+                return [...pending];
+              },
+              consumeCreatedInstance: (name: string) => pending.delete(name),
+            },
+            version: {
+              __instanceSeed: async (name: string) => {
+                calls.push(`seed:${name}`);
+              },
+            },
+          },
+        },
+        instance: {
+          service: {
+            instance: {
+              instanceStartupIsolate: async (name: string, options: any) =>
+                service.runStartupInstance(name as never, options),
+            },
+          },
+        },
+      },
+    },
+    runStartup: {
+      value: async (name: string, instance: string) => {
+        calls.push(`${name}:${instance}`);
+      },
+    },
+  });
+  return { service, app, calls, pending };
+}
+
+describe('creation-driven dev seed', { concurrency: false }, () => {
+  it('seeds fresh instances before runtime, queues, and listening', async () => {
+    const { service, calls, pending, app } = fixture(['', 'isolateTest']);
+    await service.appReady();
+    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.equal(app.meta.appReadyInstances[''], true);
+    assert.equal(app.meta.appReadyInstances.isolateTest, true);
+    await service.runStartupInstance('' as never);
+    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']);
+    await service.appReady();
+    assert.ok(calls.includes('seed:isolateTest'));
+    assert.ok(!calls.includes('seed:'));
+  });
+
+  it('does not seed when all databases are reused', async () => {
+    const { service, calls } = fixture();
+    await service.appReady();
+    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(['']);
+    (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(app.meta.appReadyInstances, {});
+    assert.ok(
+      !calls.some(
+        call =>
+          call.includes('runtime') || call.includes('listen') || call.includes('loadQueueWorkers'),
+      ),
+    );
+  });
+});

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

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

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

@@ -1,4 +1,4 @@
-import type { IInstanceRecord } from 'vona';
+import type { IInstanceRecord, VonaApplication } from 'vona';
 import type { ConfigInstanceBase } from 'vona-module-a-instance';
 import type { IDatabaseClientRecord, ServiceDatabaseClient } from 'vona-module-a-orm';
 
@@ -20,6 +20,26 @@ import { createDatabaseTestName, getDatabaseTestPrefix } from '../lib/databaseTe
 const __separator = '-';
 const __timeFormat = `yyyyMMdd${__separator}HHmmss`;
 
+interface IDevDatabaseTarget {
+  clientName: keyof IDatabaseClientRecord;
+  instanceName?: keyof IInstanceRecord;
+  configInstanceBase?: ConfigInstanceBase;
+}
+
+interface IDevDatabasePlan extends IDevDatabaseTarget {
+  databasePrefix: string;
+  sqliteRoot?: string;
+  databases: string[];
+  create: boolean;
+}
+
+interface IDevDatabasePreparation {
+  prepared: boolean;
+  createdInstances: Set<keyof IInstanceRecord>;
+}
+
+const devDatabasePreparations = new WeakMap<VonaApplication, IDevDatabasePreparation>();
+
 export function assertDisposableDatabaseName(
   databaseName: string,
   databasePrefix: string,
@@ -49,6 +69,110 @@ export class ServiceDatabase extends BeanBase {
     return getDatabaseTestPrefix(this.app.name, scope);
   }
 
+  get createdInstanceNames(): (keyof IInstanceRecord)[] {
+    return [...(devDatabasePreparations.get(this.app)?.createdInstances ?? [])];
+  }
+
+  consumeCreatedInstance(instanceName: keyof IInstanceRecord) {
+    devDatabasePreparations.get(this.app)?.createdInstances.delete(instanceName);
+  }
+
+  public async prepareDevDatabases(reset = process.env.VONA_DB_RESET === 'true') {
+    if (!this.app.meta.isDev) return;
+    if (!this.configDatabase.testDatabase) {
+      if (reset) {
+        throw new Error('db:reset requires database.testDatabase=true in the dev configuration');
+      }
+      return;
+    }
+    if (devDatabasePreparations.get(this.app)?.prepared) return;
+
+    if (typeof this.configDatabase.defaultClient !== 'string') {
+      throw new TypeError('Disposable dev database preparation requires a static default client');
+    }
+    // Validate every target before clearing any application resources.
+    const plans: IDevDatabasePlan[] = [];
+    const clientNames = new Set<keyof IDatabaseClientRecord>();
+    for (const target of this.__databaseTargets()) {
+      if (target.configInstanceBase?.isolate && !target.configInstanceBase.id) {
+        throw new Error(`should specify id for isolate instance: ${target.instanceName}`);
+      }
+      const clientName = this.$scope.orm.service.database.prepareClientNameReal(target.clientName);
+      if (clientNames.has(clientName)) {
+        throw new Error(`Disposable database targets must use distinct clients: ${clientName}`);
+      }
+      clientNames.add(clientName);
+      plans.push(
+        await this.bean.database.switchDb(async () => {
+          const client = this.bean.database.current.client;
+          const databasePrefix = this.getDatabasePrefix(
+            target.instanceName,
+            target.configInstanceBase,
+          );
+          const sqliteRoot = this.__sqliteRoot(client);
+          const currentName = client.getDatabaseName();
+          const currentFilename = sqliteRoot ? path.basename(currentName, '.db') : currentName;
+          if (currentFilename.startsWith(databasePrefix)) {
+            assertDisposableDatabaseName(currentName, databasePrefix, sqliteRoot);
+            if (reset) {
+              throw new Error('db:reset requires a connection outside the disposable database');
+            }
+          }
+          const dbs = await this.__fetchDatabases(
+            client,
+            target.instanceName,
+            target.configInstanceBase,
+          );
+          for (const db of dbs) {
+            assertDisposableDatabaseName(db.name, databasePrefix, sqliteRoot);
+          }
+          return {
+            ...target,
+            databasePrefix,
+            sqliteRoot,
+            databases: dbs.map(db => db.name),
+            create: reset,
+          };
+        }, target.clientName),
+      );
+    }
+
+    if (!reset) {
+      const missing = plans.find(plan => plan.databases.length === 0);
+      if (missing) this.__missingDevDatabase(missing.instanceName);
+    }
+
+    if (reset) {
+      await this.$scope.redis.service.redis.clearAllData();
+      await this.bean.worker.setAlive();
+    }
+    const preparation: IDevDatabasePreparation = {
+      prepared: false,
+      createdInstances: new Set(),
+    };
+    for (const plan of plans) {
+      await this.bean.database.switchDb(async () => {
+        const client = this.bean.database.current.client;
+        if (reset) {
+          for (const databaseName of plan.databases) {
+            assertDisposableDatabaseName(databaseName, plan.databasePrefix, plan.sqliteRoot);
+            await client.connection.schema.dropDatabase(databaseName);
+          }
+        }
+        const databaseName = plan.create
+          ? await this.__createDatabase(client, plan.instanceName, plan.configInstanceBase)
+          : plan.databases[0];
+        assertDisposableDatabaseName(databaseName, plan.databasePrefix, plan.sqliteRoot);
+        await client.changeConfigConnectionAndReloadWorker(databaseName);
+        if (plan.create) preparation.createdInstances.add(plan.instanceName ?? '');
+        this.$logger.silly(chalk.cyan(`dialect: ${client.db.dialectName}`));
+        this.$logger.silly(chalk.cyan(`database: ${databaseName}, pid: ${process.pid}`));
+      }, plan.clientName);
+    }
+    preparation.prepared = true;
+    devDatabasePreparations.set(this.app, preparation);
+  }
+
   public async databaseInitStartup() {
     // database
     await this.__prepareDatabases(true);
@@ -97,22 +221,41 @@ export class ServiceDatabase extends BeanBase {
     return await client.connection.schema.createDatabase(databaseName);
   }
 
-  private async __prepareDatabases(versionStart: boolean) {
-    // default
-    await this.prepareDatabase('default', versionStart);
-    // isolate
+  private __databaseTargets(): IDevDatabaseTarget[] {
+    const targets: IDevDatabaseTarget[] = [{ clientName: 'default' }];
     for (const key in this.app.config.instance.instances) {
       const instanceName = key as keyof IInstanceRecord;
       const configInstanceBase = this.app.config.instance.instances[instanceName];
-      if (configInstanceBase === false) continue;
-      if (!configInstanceBase.isolate) continue;
-      if (!configInstanceBase.isolateClient)
+      if (configInstanceBase === false || !configInstanceBase.isolate) continue;
+      if (!configInstanceBase.isolateClient) {
         throw new Error(`should specify isolateClient for isolate instance: ${instanceName}`);
-      await this.prepareDatabase(
-        configInstanceBase.isolateClient,
-        versionStart,
+      }
+      targets.push({
+        clientName: configInstanceBase.isolateClient,
         instanceName,
         configInstanceBase,
+      });
+    }
+    return targets;
+  }
+
+  private __sqliteRoot(client: ServiceDatabaseClient) {
+    return client.db.dialectName === 'better-sqlite3'
+      ? resolveVonaLocalPaths(
+          this.app.projectPath,
+          this.app.meta.env.META_MODE,
+          this.app.meta.env.VONA_TEST_RUN_ID,
+        ).sqliteRoot
+      : undefined;
+  }
+
+  private async __prepareDatabases(versionStart: boolean) {
+    for (const target of this.__databaseTargets()) {
+      await this.prepareDatabase(
+        target.clientName,
+        versionStart,
+        target.instanceName,
+        target.configInstanceBase,
       );
     }
   }
@@ -122,14 +265,36 @@ export class ServiceDatabase extends BeanBase {
     instanceName?: keyof IInstanceRecord,
     configInstanceBase?: ConfigInstanceBase,
   ) {
-    await this.__prepareDatabaseInner(versionStart, instanceName, configInstanceBase);
+    await this.__prepareDatabaseInner(instanceName, configInstanceBase);
     if (versionStart) {
       await this.scope.service.version.__start();
     }
   }
 
+  private __missingDevDatabase(instanceName?: keyof IInstanceRecord): never {
+    // eslint-disable-next-line
+    console.error(
+      [
+        '',
+        chalk.bgRed.white.bold(' DEVELOPMENT DATABASE MISSING '),
+        chalk.yellow(`Instance: ${instanceName || 'default'}`),
+        '',
+        chalk.bold.yellow('Run this command before starting the development server:'),
+        '',
+        chalk.bold.cyan('  npm run db:reset'),
+        '',
+        chalk.yellow('Warning: db:reset deletes managed development data.'),
+        chalk.yellow('Stop processes using the same database and Redis namespace first.'),
+        '',
+      ].join('\n'),
+    );
+    throw new Error(
+      `Development database is missing for instance "${instanceName || 'default'}". ` +
+        'Run "npm run db:reset" before starting the development server.',
+    );
+  }
+
   private async __prepareDatabaseInner(
-    versionStart: boolean,
     instanceName?: keyof IInstanceRecord,
     configInstanceBase?: ConfigInstanceBase,
   ) {
@@ -137,6 +302,10 @@ export class ServiceDatabase extends BeanBase {
       // donothing
       return;
     }
+    if (this.app.meta.isDev) {
+      await this.prepareDevDatabases();
+      return;
+    }
     const databasePrefix = this.getDatabasePrefix(instanceName, configInstanceBase);
     if (this.app.meta.env.VONA_TEST_RUN_ID) {
       const paths = resolveVonaLocalPaths(
@@ -149,16 +318,7 @@ export class ServiceDatabase extends BeanBase {
     // client
     const client = this.bean.database.current.client;
     // get current database name
-    let databaseName = client.getDatabaseName();
-    // dev/debug db
-    if (this.app.meta.isDev) {
-      const reset = versionStart && process.env.VONA_DB_RESET === 'true';
-      // Never drop a configured, non-disposable development database.
-      if (reset && !this.configDatabase.testDatabase) {
-        throw new Error('db:reset requires database.testDatabase=true in the dev configuration');
-      }
-      if (!this.configDatabase.testDatabase) return;
-    }
+    const databaseName = client.getDatabaseName();
     const sqliteRoot =
       client.db.dialectName === 'better-sqlite3'
         ? resolveVonaLocalPaths(
@@ -180,34 +340,6 @@ export class ServiceDatabase extends BeanBase {
         `Isolated test database is outside its disposable namespace: ${databaseName}`,
       );
     }
-    // dev/debug db
-    if (this.app.meta.isDev) {
-      const reset = versionStart && process.env.VONA_DB_RESET === 'true';
-      // The database used to enumerate/drop databases must not itself be dropped.
-      if (isTestDatabase) {
-        if (reset)
-          throw new Error('db:reset requires a connection outside the disposable database');
-        return;
-      }
-      const dbs = await this.__fetchDatabases(client, instanceName, configInstanceBase);
-      for (const db of dbs) {
-        assertDisposableDatabaseName(db.name, databasePrefix, sqliteRoot);
-      }
-      if (reset) {
-        for (const db of dbs) {
-          await client.connection.schema.dropDatabase(db.name);
-        }
-      }
-      databaseName =
-        reset || dbs.length === 0
-          ? await this.__createDatabase(client, instanceName, configInstanceBase)
-          : dbs[0].name;
-      assertDisposableDatabaseName(databaseName, databasePrefix, sqliteRoot);
-      // set config and reload client
-      await client.changeConfigConnectionAndReloadWorker(databaseName);
-      this.$logger.silly(chalk.cyan(`dialect: ${client.db.dialectName}`));
-      this.$logger.silly(chalk.cyan(`database: ${databaseName}, pid: ${process.pid}`));
-    }
     // test db
     if (this.app.meta.isTest) {
       // check