@hozon/db 0.4.0 → 0.5.0

package/lib/db.js

@@ -2,9 +2,9 @@ import { getLogger } from '@sozai/log';
 import { Kysely, sql } from 'kysely';
 import { Migrator } from 'kysely/migration';
 import { withTransactionalDDL } from './dialect.js';
-import { HozonDBClosedError, InvalidTablePrefixError, SavepointOverlapError, SavepointReleasedError } from './errors.js';
+import { HozonDBClosedError, InvalidTablePrefixError, SavepointOverlapError, SavepointReleasedError, StoreAlreadyRegisteredError } from './errors.js';
 import { LoaderRegistry } from './loader-registry.js';
-import { checkStore } from './preflight.js';
+import { checkStore, readAppliedMigrations } from './preflight.js';
 import { bindSyncProvider, compareWrite, settleSyncProvider } from './sync.js';
 import { TablePrefixPlugin } from './table-prefix.js';
 // biome-ignore lint/complexity/noBannedTypes: The default adds no context fields.
@@ -60,9 +60,7 @@ export class HozonDB {
         const existing = this.#stores.get(store.name);
         if (existing != null) {
             if (existing !== store) {
-                this.#logger.warn('store "{name}" registered with different definition, ignoring', {
-                    name: store.name
-                });
+                throw new StoreAlreadyRegisteredError(store.name);
             }
             return;
         }
@@ -448,6 +446,15 @@ export class HozonDB {
         if (Object.keys(migrations).length === 0) {
             return;
         }
+        // Kysely's migrator opens a transaction even when nothing is pending, which fails while
+        // another database instance holds the same single SQLite connection in a transaction.
+        const applied = await readAppliedMigrations(this.#db, this.#tablePrefix, name);
+        if (applied != null && Object.keys(migrations).every((key)=>applied.has(key))) {
+            this.#logger.debug('store {name} migrations already applied', {
+                name
+            });
+            return;
+        }
         const migrator = new Migrator({
             db: this.#db,
             provider: {

package/lib/errors.d.ts

@@ -16,6 +16,9 @@ export declare class InvalidTablePrefixError extends Error {
 export declare class HozonDBClosedError extends Error {
     constructor();
 }
+export declare class StoreAlreadyRegisteredError extends Error {
+    constructor(store: string);
+}
 export declare class BatchLimitError extends Error {
     constructor(size: number, limit: number);
 }

package/lib/errors.js

@@ -34,6 +34,12 @@ export class HozonDBClosedError extends Error {
         this.name = 'HozonDBClosedError';
     }
 }
+export class StoreAlreadyRegisteredError extends Error {
+    constructor(store){
+        super(`Store "${store}" is already registered with a different definition`);
+        this.name = 'StoreAlreadyRegisteredError';
+    }
+}
 export class BatchLimitError extends Error {
     constructor(size, limit){
         super(`Batch of ${size} keys exceeds limit ${limit}`);

package/lib/index.d.ts

@@ -5,7 +5,7 @@ export { assertBatchSize, type BatchReadOptions, type IterateBatchesOptions, ite
 export { type BatchLoader, type BatchLoaderParams, createBatchLoader, } from './batch-loader.js';
 export type { BaseStoreContext, ContextFactory, HozonDBParams, MigrationContext, StoreContext, StoreDefinition, StoreProvider, } from './db.js';
 export { HozonDB } from './db.js';
-export { BatchLimitError, HozonDBClosedError, InvalidTablePrefixError, KeyLockScopeError, SavepointOverlapError, SavepointReleasedError, SchemaVersionError, } from './errors.js';
+export { BatchLimitError, HozonDBClosedError, InvalidTablePrefixError, KeyLockScopeError, SavepointOverlapError, SavepointReleasedError, SchemaVersionError, StoreAlreadyRegisteredError, } from './errors.js';
 export { chunk, IN_LIST_CHUNK, withKeepSet } from './keep-set.js';
 export { withStoreTransaction } from './store-transaction.js';
 export { type CompareDefinition, compareText, withKeyLock, withKeyLocks } from './sync.js';

package/lib/index.js

@@ -2,7 +2,7 @@ export { Kysely, sql } from 'kysely';
 export { assertBatchSize, iterateBatches } from './batch.js';
 export { createBatchLoader } from './batch-loader.js';
 export { HozonDB } from './db.js';
-export { BatchLimitError, HozonDBClosedError, InvalidTablePrefixError, KeyLockScopeError, SavepointOverlapError, SavepointReleasedError, SchemaVersionError } from './errors.js';
+export { BatchLimitError, HozonDBClosedError, InvalidTablePrefixError, KeyLockScopeError, SavepointOverlapError, SavepointReleasedError, SchemaVersionError, StoreAlreadyRegisteredError } from './errors.js';
 export { chunk, IN_LIST_CHUNK, withKeepSet } from './keep-set.js';
 export { withStoreTransaction } from './store-transaction.js';
 export { compareText, withKeyLock, withKeyLocks } from './sync.js';

package/lib/preflight.d.ts

@@ -1,2 +1,4 @@
 import type { Kysely } from 'kysely';
+/** Names of the migrations recorded for a store, or `null` when its migration table is absent. */
+export declare function readAppliedMigrations<DB>(db: Kysely<DB>, prefix: string, name: string): Promise<Set<string> | null>;
 export declare function checkStore<DB>(db: Kysely<DB>, prefix: string, name: string, keys: Array<string>): Promise<void>;

package/lib/preflight.js

@@ -1,18 +1,23 @@
 import { sql } from 'kysely';
 import { SchemaVersionError } from './errors.js';
-export async function checkStore(db, prefix, name, keys) {
-    let rows;
+/** Names of the migrations recorded for a store, or `null` when its migration table is absent. */ export async function readAppliedMigrations(db, prefix, name) {
     try {
         const result = await sql`SELECT name FROM ${sql.table(`${prefix}_${name}_migration`)}`.execute(db);
-        rows = result.rows;
+        return new Set(result.rows.map((row)=>row.name));
     } catch (error) {
         // Only a missing table is a fresh schema. Connection and permission errors must surface.
         if (error instanceof Error && ('code' in error && error.code === '42P01' || /no such table:/i.test(error.message))) {
-            return;
+            return null;
         }
         throw error;
     }
+}
+export async function checkStore(db, prefix, name, keys) {
+    const applied = await readAppliedMigrations(db, prefix, name);
+    if (applied == null) return;
     const known = new Set(keys);
-    const unknown = rows.map((row)=>row.name).filter((key)=>!known.has(key)).sort();
+    const unknown = [
+        ...applied
+    ].filter((key)=>!known.has(key)).sort();
     if (unknown.length > 0) throw new SchemaVersionError(name, unknown);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hozon/db",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Database registry, migrations and transactions for Hozon",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
     "lib/*"
   ],
   "dependencies": {
-    "@hozon/adapter": "^0.2.0",
+    "@hozon/adapter": "^0.2.1",
     "@sozai/async": "^0.4.1",
     "@sozai/log": "^0.4.0",
     "kysely": "^0.29.7"