@kubun/db 0.10.0 → 0.12.0

package/lib/db.d.ts

@@ -14,7 +14,24 @@ export type StoreDefinition<Tables, API> = {
 };
 export type StoreProvider<Stores extends Record<string, unknown> = Record<string, unknown>> = {
     getStore<S extends keyof Stores & string>(name: S): Promise<Stores[S]>;
+    /**
+     * Returns whether a store definition is registered, synchronously and
+     * WITHOUT triggering migration. This distinguishes "plugin not installed"
+     * (registration absent) from "plugin installed but its store currently
+     * errors" — callers can fail closed on the latter instead of mistaking a
+     * transient store error for an uninstalled plugin.
+     */
+    hasStore(name: string): boolean;
     onCommit(fn: () => void): void;
+    /**
+     * Register a hook to run after the transaction rolls back. By the time the
+     * hook fires the DB is already reverted, so it is the correct place to drop
+     * any in-memory state that was eagerly advanced in anticipation of a commit
+     * (e.g. cache invalidation). Like `onCommit`, hooks are isolated and their
+     * errors logged, never re-thrown. On the non-transactional provider it is a
+     * no-op (each standalone op auto-commits; nothing to roll back).
+     */
+    onRollback(fn: () => void): void;
     /**
      * Run `fn` against a `StoreProvider` that scopes its writes to a transaction.
      *
@@ -40,7 +57,9 @@ export declare class KubunDB implements StoreProvider {
     get adapter(): Adapter;
     register<Tables, API>(store: StoreDefinition<Tables, API>): void;
     getStore<T>(name: string): Promise<T>;
+    hasStore(name: string): boolean;
     onCommit(fn: () => void): void;
+    onRollback(_fn: () => void): void;
     /**
      * Runs `fn` inside a DB transaction and provides a scoped `StoreProvider`.
      * Concurrent calls on the same `KubunDB` instance are supported — the

package/lib/db.js

@@ -1 +1,186 @@
-import{getKubunLogger as t}from"@kubun/logger";import{Kysely as e,ParseJSONResultsPlugin as r}from"kysely";import{Migrator as i}from"kysely/migration";export class KubunDB{#t;#e;#r;#i=new Map;#s=new Map;#a=new Map;constructor(i){this.#t=i.adapter,this.#e=new e({dialect:this.#t.dialect,plugins:[new r]}),this.#r=i.logger??t("db")}get adapter(){return this.#t}register(t){let e=this.#a.get(t.name);if(null!=e){e!==t&&this.#r.warn('store "{name}" registered with different definition, ignoring',{name:t.name});return}this.#a.set(t.name,t)}async getStore(t){if(await this.#o(t),!this.#s.has(t)){let e=this.#a.get(t);if(null==e)throw Error(`Store "${t}" is not registered`);this.#s.set(t,e.createAPI(this.#e,this.#t))}return this.#s.get(t)}onCommit(t){t()}async withTransaction(t){await Promise.all(Array.from(this.#a.keys()).map(t=>this.#o(t)));let e=[],r=await this.#e.transaction().execute(async r=>{let i=new Map,s={getStore:async t=>{if(!i.has(t)){let e=this.#a.get(t);if(null==e)throw Error(`Store "${t}" is not registered`);i.set(t,e.createAPI(r,this.#t))}return i.get(t)},onCommit:t=>{e.push(t)},withTransaction:async t=>await t(s)};return await t(s)});for(let t of e)t();return r}async close(){await this.#e.destroy(),this.#r.info("closed")}async #o(t){let e=this.#i.get(t);return null==e&&(e=this.#n(t).catch(e=>{throw this.#i.delete(t),e}),this.#i.set(t,e)),e}async #n(t){let e=this.#a.get(t);if(null==e)throw Error(`Store "${t}" is not registered`);for(let t of e.dependsOn??[])await this.#o(t);let r="function"==typeof e.migrations?e.migrations({types:this.#t.types,functions:this.#t.functions}):e.migrations;if(0===Object.keys(r).length)return;let s=new i({db:this.#e,provider:{getMigrations:()=>Promise.resolve(r)},migrationTableName:`kubun_${t}_migration`,migrationLockTableName:`kubun_${t}_migration_lock`}),a=await s.migrateToLatest();if(null!=a.error)throw a.error;this.#r.info("store {name} migrations complete",{name:t})}}
+import { getKubunLogger } from '@kubun/logger';
+import { Kysely, ParseJSONResultsPlugin } from 'kysely';
+import { Migrator } from 'kysely/migration';
+export class KubunDB {
+    #adapter;
+    #db;
+    #logger;
+    #migrated = new Map();
+    #storeAPIs = new Map();
+    #stores = new Map();
+    constructor(params){
+        this.#adapter = params.adapter;
+        this.#db = new Kysely({
+            dialect: this.#adapter.dialect,
+            plugins: [
+                new ParseJSONResultsPlugin()
+            ]
+        });
+        this.#logger = params.logger ?? getKubunLogger('db');
+    }
+    get adapter() {
+        return this.#adapter;
+    }
+    register(store) {
+        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
+                });
+            }
+            return;
+        }
+        this.#stores.set(store.name, store);
+    }
+    async getStore(name) {
+        await this.#ensureMigrated(name);
+        if (!this.#storeAPIs.has(name)) {
+            const store = this.#stores.get(name);
+            if (store == null) {
+                throw new Error(`Store "${name}" is not registered`);
+            }
+            this.#storeAPIs.set(name, store.createAPI(this.#db, this.#adapter));
+        }
+        return this.#storeAPIs.get(name);
+    }
+    hasStore(name) {
+        return this.#stores.has(name);
+    }
+    onCommit(fn) {
+        fn();
+    }
+    // Each standalone op auto-commits, so there is nothing to roll back — no-op.
+    onRollback(_fn) {}
+    /**
+   * Runs `fn` inside a DB transaction and provides a scoped `StoreProvider`.
+   * Concurrent calls on the same `KubunDB` instance are supported — the
+   * underlying driver serializes them.
+   *
+   * Callers MUST use the provided `tx` inside the callback. Calling
+   * `db.withTransaction` on the same instance inside the callback opens a
+   * new independent transaction (no atomic nesting) and is a bug.
+   */ async withTransaction(fn) {
+        // Migrate every registered store before opening the transaction. Stores
+        // are internal and known up front, so a broken migration should fail fast
+        // at startup rather than leave a runtime partition where one store's
+        // failure silently blocks transactions that never touch it.
+        await Promise.all(Array.from(this.#stores.keys()).map((name)=>this.#ensureMigrated(name)));
+        const commitHooks = [];
+        const rollbackHooks = [];
+        let result;
+        try {
+            result = await this.#db.transaction().execute(async (trx)=>{
+                const txKysely = trx;
+                const txStoreAPIs = new Map();
+                const provider = {
+                    getStore: async (name)=>{
+                        if (!txStoreAPIs.has(name)) {
+                            const store = this.#stores.get(name);
+                            if (store == null) {
+                                throw new Error(`Store "${name}" is not registered`);
+                            }
+                            txStoreAPIs.set(name, store.createAPI(txKysely, this.#adapter));
+                        }
+                        return txStoreAPIs.get(name);
+                    },
+                    hasStore: (name)=>this.#stores.has(name),
+                    onCommit: (hook)=>{
+                        commitHooks.push(hook);
+                    },
+                    onRollback: (hook)=>{
+                        rollbackHooks.push(hook);
+                    },
+                    withTransaction: async (nestedFn)=>{
+                        // Already inside a transaction — Kysely does not nest.
+                        // Run `nestedFn` inline with the same provider so a throw rolls
+                        // the outer transaction back.
+                        return await nestedFn(provider);
+                    }
+                };
+                return await fn(provider);
+            });
+        } catch (err) {
+            // Kysely issues ROLLBACK and rejects `execute()` when the callback
+            // throws, so the DB is already reverted here. Run the rollback hooks to
+            // drop any in-memory state that was eagerly advanced expecting a commit
+            // (revert first, then drop the stale cache). Hooks are isolated/logged,
+            // never re-thrown; the original error is preserved so callers (e.g. the
+            // engine's `MutateGraphWriteRollback` sentinel) still observe it.
+            for(let index = 0; index < rollbackHooks.length; index++){
+                try {
+                    rollbackHooks[index]();
+                } catch (error) {
+                    this.#logger.error('rollback hook {index}/{count} failed', {
+                        index,
+                        count: rollbackHooks.length,
+                        error
+                    });
+                }
+            }
+            throw err;
+        }
+        // The transaction has committed; post-commit hooks are best-effort side
+        // effects (event emission, cache invalidation). A throwing hook must not
+        // skip the remaining hooks or make the caller observe a durable write as a
+        // failure, so each hook is isolated and its error logged, never re-thrown.
+        for(let index = 0; index < commitHooks.length; index++){
+            try {
+                commitHooks[index]();
+            } catch (error) {
+                this.#logger.error('commit hook {index}/{count} failed', {
+                    index,
+                    count: commitHooks.length,
+                    error
+                });
+            }
+        }
+        return result;
+    }
+    async close() {
+        await this.#db.destroy();
+        this.#logger.info('closed');
+    }
+    async #ensureMigrated(name) {
+        let pending = this.#migrated.get(name);
+        if (pending == null) {
+            pending = this.#runStoreMigrations(name).catch((err)=>{
+                this.#migrated.delete(name);
+                throw err;
+            });
+            this.#migrated.set(name, pending);
+        }
+        return pending;
+    }
+    async #runStoreMigrations(name) {
+        const store = this.#stores.get(name);
+        if (store == null) {
+            throw new Error(`Store "${name}" is not registered`);
+        }
+        for (const dep of store.dependsOn ?? []){
+            await this.#ensureMigrated(dep);
+        }
+        const migrations = typeof store.migrations === 'function' ? store.migrations({
+            types: this.#adapter.types,
+            functions: this.#adapter.functions
+        }) : store.migrations;
+        if (Object.keys(migrations).length === 0) {
+            return;
+        }
+        const migrator = new Migrator({
+            db: this.#db,
+            provider: {
+                getMigrations: ()=>Promise.resolve(migrations)
+            },
+            migrationTableName: `kubun_${name}_migration`,
+            migrationLockTableName: `kubun_${name}_migration_lock`
+        });
+        const result = await migrator.migrateToLatest();
+        if (result.error != null) {
+            throw result.error;
+        }
+        this.#logger.info('store {name} migrations complete', {
+            name
+        });
+    }
+}

package/lib/index.js

@@ -1 +1 @@
-export{KubunDB}from"./db.js";
+export { KubunDB } from './db.js';

package/package.json

@@ -1,35 +1,35 @@
 {
   "name": "@kubun/db",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "kysely": "^0.29.2",
-    "@kubun/db-adapter": "^0.10.0",
-    "@kubun/logger": "^0.10.0"
+    "kysely": "^0.29.4",
+    "@kubun/logger": "^0.12.0",
+    "@kubun/db-adapter": "^0.12.0"
   },
   "devDependencies": {
-    "@kubun/db-better-sqlite": "^0.10.0"
+    "@kubun/db-better-sqlite": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }