cabloy 5.1.205 → 5.1.207

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

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

@@ -0,0 +1,221 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { ServiceDatabase } from '../src/service/database.ts';
+
+const databaseName = 'vona-test-preparation-s-20261014-120000';
+const isolateName = 'vona-test-preparation-i-isolateTest-20261014-120000';
+
+function fixture(existing: string[] = [], isolate?: string[]) {
+  const calls: string[] = [];
+  const app = {
+    name: 'preparation',
+    meta: { isDev: true, isTest: false, env: { META_MODE: 'dev' } },
+    config: {
+      database: { testDatabase: true, defaultClient: 'main', clients: { main: {}, isolated: {} } },
+      instance: {
+        instances: isolate
+          ? { isolateTest: { id: 2, isolate: true, isolateClient: 'isolated' } }
+          : {},
+      },
+    },
+  };
+  const names = { main: existing, isolated: isolate ?? [] };
+  const clients = Object.fromEntries(
+    Object.entries(names).map(([key, databases]) => [
+      key,
+      {
+        db: { dialectName: 'pg' },
+        getDatabaseName: (): string => 'postgres',
+        connection: {
+          schema: {
+            fetchDatabases: async () => databases.map(name => ({ name })),
+            dropDatabase: async (name: string) => {
+              calls.push(`drop:${name}`);
+              databases.splice(databases.indexOf(name), 1);
+            },
+            createDatabase: async (name: string) => {
+              calls.push(`create:${key}`);
+              databases.push(name);
+              return name;
+            },
+          },
+        },
+        changeConfigConnectionAndReloadWorker: async (name: string) => calls.push(`reload:${name}`),
+      },
+    ]),
+  );
+  const database = {
+    current: { client: clients.main },
+    switchDb: async (fn: () => Promise<unknown>, clientName: string) => {
+      const previous = database.current;
+      database.current = { client: clients[clientName === 'default' ? 'main' : clientName] };
+      try {
+        return await fn();
+      } finally {
+        database.current = previous;
+      }
+    },
+  };
+  const service = Object.create(ServiceDatabase.prototype) as ServiceDatabase;
+  Object.defineProperties(service, {
+    app: { value: app },
+    bean: { value: { database, worker: { setAlive: async () => calls.push('alive') } } },
+    $scope: {
+      value: {
+        orm: {
+          service: {
+            database: {
+              prepareClientNameReal: (name: string) => (name === 'default' ? 'main' : name),
+            },
+          },
+        },
+        redis: { service: { redis: { clearAllData: async () => calls.push('clear') } } },
+        version: { service: { version: { __start: async () => calls.push('migrate') } } },
+      },
+    },
+    scope: { value: { service: { version: { __start: async () => calls.push('migrate') } } } },
+    $logger: { value: { silly() {} } },
+  });
+  return { service, app, calls, clients };
+}
+
+describe('dev database preparation', { concurrency: false }, () => {
+  it('clears all resources before reset creation and records only actual creations', async () => {
+    const { service, calls } = fixture();
+    await service.prepareDevDatabases(true);
+    assert.deepEqual(calls.slice(0, 3), ['clear', 'alive', 'create:main']);
+    assert.deepEqual(service.createdInstanceNames, ['']);
+    await service.prepareDevDatabases();
+    await service.databaseInitStartup();
+    assert.equal(calls.filter(call => call === 'clear').length, 1);
+    assert.equal(calls.filter(call => call === 'create:main').length, 1);
+    assert.equal(calls.at(-1), 'migrate');
+    service.consumeCreatedInstance('');
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+
+  it('reuses an existing database without clearing or requesting seeds', async () => {
+    const { service, calls } = fixture([databaseName]);
+    await service.prepareDevDatabases();
+    assert.deepEqual(calls, [`reload:${databaseName}`]);
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+
+  it('rejects a missing isolate before reloading or changing the existing shared database', async () => {
+    const { service, calls } = fixture([databaseName], []);
+    await assert.rejects(service.prepareDevDatabases(false), /isolateTest.*npm run db:reset/);
+    assert.deepEqual(calls, []);
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+
+  it('rejects a missing shared database without any preparation side effects', async () => {
+    const { service, calls } = fixture();
+    await assert.rejects(service.prepareDevDatabases(false), /default.*npm run db:reset/);
+    assert.deepEqual(calls, []);
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+
+  it('prints a prominent reset command and destructive-data warning before rejecting', async t => {
+    const { service, calls } = fixture();
+    const output: string[] = [];
+    t.mock.method(console, 'error', (message: string) => output.push(message));
+    await assert.rejects(service.prepareDevDatabases(false), /default.*npm run db:reset/);
+    assert.equal(output.length, 1);
+    assert.match(output[0], /DEVELOPMENT DATABASE MISSING/);
+    assert.match(output[0], /Instance: default/);
+    assert.match(output[0], /npm run db:reset/);
+    assert.match(output[0], /deletes managed development data/);
+    assert.match(output[0], /Stop processes using the same database and Redis namespace first/);
+    assert.deepEqual(calls, []);
+  });
+
+  it('rejects missing targets through legacy startup entrypoints before migration', async () => {
+    for (const versionStart of [false, true]) {
+      const { service, calls } = fixture();
+      await assert.rejects(
+        service.prepareDatabase('main' as never, versionStart),
+        /npm run db:reset/,
+      );
+      assert.deepEqual(calls, []);
+    }
+  });
+
+  it('preflights every target before any deletion', async () => {
+    const { service, calls } = fixture([databaseName], ['unowned-database']);
+    await assert.rejects(service.prepareDevDatabases());
+    assert.deepEqual(calls, []);
+  });
+
+  it('stops if full resource cleanup fails', async () => {
+    const { service, calls } = fixture();
+    (service as any).$scope.redis.service.redis.clearAllData = async () => {
+      throw new Error('cleanup failed');
+    };
+    await assert.rejects(service.prepareDevDatabases(true), /cleanup failed/);
+    assert.deepEqual(calls, []);
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+
+  it('clears once and recreates all reset targets before migration', async () => {
+    const { service, calls } = fixture([databaseName], [isolateName]);
+    await service.prepareDevDatabases(true);
+    assert.equal(calls.filter(call => call === 'clear').length, 1);
+    assert.ok(calls.indexOf('clear') < calls.indexOf(`drop:${databaseName}`));
+    assert.ok(calls.includes(`drop:${isolateName}`));
+    assert.deepEqual(service.createdInstanceNames, ['', 'isolateTest']);
+    await service.databaseInitStartup();
+    assert.equal(calls.filter(call => call.startsWith('drop:')).length, 2);
+    assert.equal(calls.filter(call => call.startsWith('create:')).length, 2);
+    assert.equal(calls.filter(call => call === 'migrate').length, 2);
+  });
+
+  it('rejects non-disposable reset without clearing anything', async () => {
+    const { service, app, calls } = fixture([databaseName]);
+    app.config.database.testDatabase = false;
+    await assert.rejects(service.prepareDevDatabases(true), /testDatabase=true/);
+    assert.deepEqual(calls, []);
+    await service.prepareDevDatabases(false);
+    assert.deepEqual(calls, []);
+  });
+
+  it('refuses to reset through a connection inside the target namespace', async () => {
+    const { service, clients, calls } = fixture([databaseName]);
+    clients.main.getDatabaseName = () => databaseName;
+    await assert.rejects(service.prepareDevDatabases(true), /connection outside/);
+    assert.deepEqual(calls, []);
+  });
+
+  it('checks actual existence even if the configured name belongs to the managed namespace', async () => {
+    const { service, clients, calls } = fixture();
+    clients.main.getDatabaseName = () => databaseName;
+    await assert.rejects(service.prepareDevDatabases(false), /npm run db:reset/);
+    assert.deepEqual(calls, []);
+  });
+
+  it('propagates discovery failures without treating them as missing databases', async () => {
+    const { service, clients, calls } = fixture([databaseName]);
+    clients.main.connection.schema.fetchDatabases = async () => {
+      throw new Error('discovery failed');
+    };
+    await assert.rejects(service.prepareDevDatabases(false), /discovery failed/);
+    assert.deepEqual(calls, []);
+  });
+
+  it('propagates reset creation failure without migrating or requesting seeds', async () => {
+    const { service, clients, calls } = fixture([databaseName]);
+    clients.main.connection.schema.createDatabase = async () => {
+      throw new Error('creation failed');
+    };
+    await assert.rejects(service.prepareDevDatabases(true), /creation failed/);
+    assert.deepEqual(calls, ['clear', 'alive', `drop:${databaseName}`]);
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+
+  it('preserves both existing targets on reuse', async () => {
+    const { service, calls } = fixture([databaseName], [isolateName]);
+    await service.prepareDevDatabases();
+    assert.deepEqual(calls, [`reload:${databaseName}`, `reload:${isolateName}`]);
+    assert.deepEqual(service.createdInstanceNames, []);
+  });
+});

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

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