@pikku/kysely-bun-sqlite 0.12.8 → 0.12.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @pikku/kysely-bun-sqlite
 
+## 0.12.9
+
+### Patch Changes
+
+- 1ab831e: Add `openBunSqliteDatabase`, which opens a `bun:sqlite` database as the `SqliteDatabase` Kysely's `SqliteDialect` binds to.
+
+  `createBunSqliteKysely` builds one Kysely over one database, so it cannot express several Kysely instances — differing only in their plugins — sharing a single underlying database. That combination is what lets a plugin-free instance (Better Auth needs unmangled column names) and a CamelCase one address the same tables, and until now an app that needed it had to reach for `better-sqlite3` instead.
+
+  Under Bun that fallback is not survivable: `better-sqlite3` ships a Node-ABI addon which Bun cannot load, and rather than throwing it aborts the process with `NAPI FATAL ERROR: Error::New napi_get_last_error_info`. In a `pikku dev --watch` this killed the dev server after codegen but before it ever listened, with no error naming the driver.
+
+- Updated dependencies [1ab831e]
+  - @pikku/core@0.12.105
+
 ## 0.12.8
 
 ### Patch Changes

package/dist/src/bun-sqlite-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { Database } from 'bun:sqlite';
+import { Database } from 'bun:sqlite';
 import type { SqliteDatabase, SqliteStatement } from 'kysely';
 export declare class BunSqliteDatabase implements SqliteDatabase {
     private readonly db;
@@ -6,3 +6,14 @@ export declare class BunSqliteDatabase implements SqliteDatabase {
     prepare(sql: string): SqliteStatement;
     close(): void;
 }
+/**
+ * Opens a `bun:sqlite` database as the `SqliteDatabase` Kysely's `SqliteDialect`
+ * binds to.
+ *
+ * `createBunSqliteKysely` covers the common case of one database behind one
+ * Kysely. This is for the case it cannot express: several Kysely instances —
+ * differing in their plugins — sharing a single underlying database, which is
+ * what lets a plugin-free instance (Better Auth needs unmangled column names)
+ * and a CamelCase one address the same tables.
+ */
+export declare const openBunSqliteDatabase: (filename: string) => SqliteDatabase;

package/dist/src/bun-sqlite-adapter.js

@@ -1,3 +1,4 @@
+import { Database } from 'bun:sqlite';
 function coerce(v) {
     if (v === null || v === undefined)
         return null;
@@ -45,3 +46,14 @@ export class BunSqliteDatabase {
         this.db.close();
     }
 }
+/**
+ * Opens a `bun:sqlite` database as the `SqliteDatabase` Kysely's `SqliteDialect`
+ * binds to.
+ *
+ * `createBunSqliteKysely` covers the common case of one database behind one
+ * Kysely. This is for the case it cannot express: several Kysely instances —
+ * differing in their plugins — sharing a single underlying database, which is
+ * what lets a plugin-free instance (Better Auth needs unmangled column names)
+ * and a CamelCase one address the same tables.
+ */
+export const openBunSqliteDatabase = (filename) => new BunSqliteDatabase(new Database(filename));

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-export { BunSqliteDatabase } from './bun-sqlite-adapter.js';
+export { BunSqliteDatabase, openBunSqliteDatabase, } from './bun-sqlite-adapter.js';
 export { createBunSqliteKysely, type CreateBunSqliteKyselyOptions, } from './create-bun-sqlite-kysely.js';
 export { registerSqliteFunctions } from './register-functions.js';
 export { SqliteFunctionsUnsupportedError, type SqliteFunctionMap, } from '@pikku/kysely-sqlite';

package/dist/src/index.js

@@ -1,4 +1,4 @@
-export { BunSqliteDatabase } from './bun-sqlite-adapter.js';
+export { BunSqliteDatabase, openBunSqliteDatabase, } from './bun-sqlite-adapter.js';
 export { createBunSqliteKysely, } from './create-bun-sqlite-kysely.js';
 export { registerSqliteFunctions } from './register-functions.js';
 export { SqliteFunctionsUnsupportedError, } from '@pikku/kysely-sqlite';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely-bun-sqlite",
-  "version": "0.12.8",
+  "version": "0.12.9",
   "description": "Kysely driver for Pikku backed by the built-in bun:sqlite module",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -24,10 +24,10 @@
     "kysely": "^0.29.5"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.86"
+    "@pikku/core": "^0.12.105"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.86",
+    "@pikku/core": "^0.12.105",
     "@types/bun": "^1.4.0",
     "typescript": "^6.0.3"
   }

package/src/bun-sqlite-adapter.test.ts

@@ -1,8 +1,11 @@
 import { describe, test, beforeEach, afterEach } from 'node:test'
 import assert from 'node:assert/strict'
 import { Database } from 'bun:sqlite'
-import { Kysely, SqliteDialect } from 'kysely'
-import { BunSqliteDatabase } from './bun-sqlite-adapter.js'
+import { Kysely, SqliteDialect, CamelCasePlugin } from 'kysely'
+import {
+  BunSqliteDatabase,
+  openBunSqliteDatabase,
+} from './bun-sqlite-adapter.js'
 
 interface TestDB {
   items: { id: number; name: string; active: number; score: number | null }
@@ -174,3 +177,36 @@ describe('BunSqliteDatabase', () => {
     assert.equal(updated.numUpdatedRows, 1n)
   })
 })
+
+describe('openBunSqliteDatabase', () => {
+  test('opens a database two Kysely instances can share', async () => {
+    const database = openBunSqliteDatabase(':memory:')
+    const plain = new Kysely<TestDB>({ dialect: new SqliteDialect({ database }) })
+    const camelCase = new Kysely<TestDB>({
+      dialect: new SqliteDialect({ database }),
+      plugins: [new CamelCasePlugin()],
+    })
+
+    await plain.schema
+      .createTable('items')
+      .addColumn('id', 'integer', (c) => c.primaryKey().autoIncrement())
+      .addColumn('name', 'text', (c) => c.notNull())
+      .addColumn('active', 'integer', (c) => c.notNull())
+      .addColumn('score', 'real')
+      .execute()
+    await plain
+      .insertInto('items')
+      .values({ name: 'shared', active: 1, score: null })
+      .execute()
+
+    // The second instance addresses the same underlying database, which is the
+    // only reason a plugin-free and a CamelCase Kysely can span one schema.
+    const row = await camelCase
+      .selectFrom('items')
+      .selectAll()
+      .executeTakeFirstOrThrow()
+    assert.equal(row.name, 'shared')
+
+    await plain.destroy()
+  })
+})

package/src/bun-sqlite-adapter.ts

@@ -1,4 +1,4 @@
-import type { Database, Statement } from 'bun:sqlite'
+import { Database, type Statement } from 'bun:sqlite'
 import type { SqliteDatabase, SqliteStatement } from 'kysely'
 
 function coerce(v: unknown): unknown {
@@ -49,3 +49,16 @@ export class BunSqliteDatabase implements SqliteDatabase {
     this.db.close()
   }
 }
+
+/**
+ * Opens a `bun:sqlite` database as the `SqliteDatabase` Kysely's `SqliteDialect`
+ * binds to.
+ *
+ * `createBunSqliteKysely` covers the common case of one database behind one
+ * Kysely. This is for the case it cannot express: several Kysely instances —
+ * differing in their plugins — sharing a single underlying database, which is
+ * what lets a plugin-free instance (Better Auth needs unmangled column names)
+ * and a CamelCase one address the same tables.
+ */
+export const openBunSqliteDatabase = (filename: string): SqliteDatabase =>
+  new BunSqliteDatabase(new Database(filename))

package/src/index.ts

@@ -1,4 +1,7 @@
-export { BunSqliteDatabase } from './bun-sqlite-adapter.js'
+export {
+  BunSqliteDatabase,
+  openBunSqliteDatabase,
+} from './bun-sqlite-adapter.js'
 export {
   createBunSqliteKysely,
   type CreateBunSqliteKyselyOptions,

package/dist/src/coercion-plugin.d.ts

@@ -1,24 +0,0 @@
-import type { KyselyPlugin } from 'kysely';
-export type ColumnKind = 'date' | 'bool' | 'json';
-/**
- * Per-table column kind map. Keys are snake_case table names matching the
- * physical SQLite tables; inner keys are snake_case column names.
- * Generated by `pikku db migrate` from `-- @date|@bool|@json` annotations
- * and naming conventions (col ends in _at/_on → date; starts with is_/has_/can_ → bool).
- */
-export type CoercionMap = Record<string, Record<string, ColumnKind>>;
-export interface CreateCoercionPluginOptions {
-    map: CoercionMap;
-}
-/**
- * Convert SQLite-stored values (TEXT/INTEGER) back into the logical types
- * app code expects (Date / boolean / parsed JSON).
- *
- * Write-side coercion (Date → ISO string, boolean → 0/1, object → JSON) is
- * handled in the NodeSqliteDatabase adapter (always-on), so this plugin is
- * read-only.
- *
- * Place AFTER CamelCasePlugin in the plugin array (or it handles both
- * orderings via the dual-keyed global map).
- */
-export declare function createCoercionPlugin(options: CreateCoercionPluginOptions): KyselyPlugin;

package/dist/src/coercion-plugin.js

@@ -1,92 +0,0 @@
-function fromDb(value, kind) {
-    if (value == null)
-        return value;
-    switch (kind) {
-        case 'date':
-            if (typeof value === 'string') {
-                const d = new Date(value);
-                return Number.isNaN(d.getTime()) ? value : d;
-            }
-            return value;
-        case 'bool':
-            if (typeof value === 'number')
-                return value !== 0;
-            if (typeof value === 'bigint')
-                return value !== 0n;
-            return value;
-        case 'json':
-            if (typeof value !== 'string')
-                return value;
-            try {
-                return JSON.parse(value);
-            }
-            catch {
-                return value;
-            }
-    }
-}
-function snakeToCamel(name) {
-    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}
-/**
- * Flatten the per-table map into a single column-name → kind lookup.
- * Indexed by BOTH snake_case and camelCase so it works regardless of
- * CamelCasePlugin ordering in the plugin array.
- *
- * When two tables disagree on the kind for the same column name, the column
- * is ambiguous (a joined/aliased query could carry either) and is left
- * uncoerced rather than letting whichever table was processed last win.
- */
-function buildGlobalMap(map) {
-    const out = {};
-    const ambiguous = new Set();
-    const assign = (key, kind) => {
-        const existing = out[key];
-        if (existing !== undefined && existing !== kind) {
-            ambiguous.add(key);
-            return;
-        }
-        out[key] = kind;
-    };
-    for (const tbl of Object.values(map)) {
-        for (const [col, kind] of Object.entries(tbl)) {
-            assign(col, kind);
-            assign(snakeToCamel(col), kind);
-        }
-    }
-    for (const key of ambiguous)
-        delete out[key];
-    return out;
-}
-/**
- * Convert SQLite-stored values (TEXT/INTEGER) back into the logical types
- * app code expects (Date / boolean / parsed JSON).
- *
- * Write-side coercion (Date → ISO string, boolean → 0/1, object → JSON) is
- * handled in the NodeSqliteDatabase adapter (always-on), so this plugin is
- * read-only.
- *
- * Place AFTER CamelCasePlugin in the plugin array (or it handles both
- * orderings via the dual-keyed global map).
- */
-export function createCoercionPlugin(options) {
-    const globalMap = buildGlobalMap(options.map);
-    return {
-        transformQuery(args) {
-            return args.node;
-        },
-        async transformResult(args) {
-            const out = [];
-            for (const row of args.result.rows) {
-                const next = { ...row };
-                for (const [col, val] of Object.entries(row)) {
-                    const kind = globalMap[col];
-                    if (kind)
-                        next[col] = fromDb(val, kind);
-                }
-                out.push(next);
-            }
-            return { ...args.result, rows: out };
-        },
-    };
-}