@pikku/kysely-bun-sqlite 0.12.8 → 0.12.10

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @pikku/kysely-bun-sqlite
 
+## 0.12.10
+
+### Patch Changes
+
+- 1fe79bc: A standalone build of a SQLite app now ships its `db.sqliteExtensions` (sqlite-vec's vec0 by default) inside the artifact, so a migration or query that uses them works in production the way it does under `pikku dev`. The node bundle loads them from `sqlite-extensions/` beside itself; a compiled bun binary embeds them and writes them out under `$PIKKU_DATA_DIR/.pikku-sqlite-extensions/` on start. The libraries are the build machine's, so an extension that cannot be resolved there fails the build; `[]` builds without them.
+
+  `createNodeSqliteKysely` and `createBunSqliteKysely` take an `extensions` list of library paths to load into the connection.
+
+- Updated dependencies [1394385]
+- Updated dependencies [7740547]
+  - @pikku/core@0.12.124
+  - @pikku/kysely-sqlite@0.12.15
+
+## 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/create-bun-sqlite-kysely.d.ts

@@ -18,5 +18,13 @@ export interface CreateBunSqliteKyselyOptions {
      * shows up as an error that explains itself.
      */
     functions?: SqliteFunctionMap;
+    /**
+     * Absolute paths of loadable SQLite extensions (sqlite-vec's `vec0`, say) to
+     * load before the database is handed to Kysely. Loaded through the C API;
+     * SQL's own `load_extension()` stays refused. On macOS this throws unless
+     * the process pointed bun at a SQLite that allows it first
+     * (`Database.setCustomSQLite`), since Apple's system one does not.
+     */
+    extensions?: string[];
 }
 export declare function createBunSqliteKysely<DB>(options: CreateBunSqliteKyselyOptions): Kysely<DB>;

package/dist/src/create-bun-sqlite-kysely.js

@@ -4,6 +4,8 @@ import { BunSqliteDatabase } from './bun-sqlite-adapter.js';
 import { registerSqliteFunctions } from './register-functions.js';
 export function createBunSqliteKysely(options) {
     const db = new Database(options.filename);
+    for (const path of options.extensions ?? [])
+        db.loadExtension(path);
     if (options.functions)
         registerSqliteFunctions(db, options.functions);
     const plugins = [];

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,11 @@
 {
   "name": "@pikku/kysely-bun-sqlite",
-  "version": "0.12.8",
+  "version": "0.12.10",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/services/kysely-bun-sqlite"
+  },
   "description": "Kysely driver for Pikku backed by the built-in bun:sqlite module",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -20,15 +25,14 @@
   },
   "dependencies": {
     "@pikku/kysely": "^0.13.18",
-    "@pikku/kysely-sqlite": "^0.12.13",
+    "@pikku/kysely-sqlite": "^0.12.15",
     "kysely": "^0.29.5"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.86"
+    "@pikku/core": "^0.12.124"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.86",
-    "@types/bun": "^1.4.0",
-    "typescript": "^6.0.3"
+    "@pikku/core": "^0.12.124",
+    "@types/bun": "^1.4.0"
   }
-}
+}

package/run-tests.sh

@@ -1,10 +1,13 @@
 #!/bin/bash
 
+# Enable nullglob to handle cases where no files match the pattern
 shopt -s nullglob
 
+# Initialize variables for options
 watch_mode=false
 coverage_mode=false
 
+# Parse command-line options
 while [[ $# -gt 0 ]]; do
   case $1 in
     --watch)
@@ -22,33 +25,44 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-files=()
-while IFS= read -r -d '' file; do
-  files+=("$file")
-done < <(find src -type f -name "*.test.ts" -print0)
+# Define the pattern to match your test files
+pattern="src/*.test.ts"
 
+# Expand the pattern into an array of files
+files=($(find src -type f -name "*.test.ts"))
+
+# Check if any files matched the pattern
 if [ ${#files[@]} -eq 0 ]; then
-  echo "No test files found"
+  echo "No test files found matching pattern: $pattern"
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ]; then
+    exit 1
+  fi
   exit 0
 fi
 
-if [ "$coverage_mode" = true ]; then
-  # Bun writes coverage/lcov.info and instruments imported dist files too.
-  # Re-emit a package-root lcov.info containing only src/ records so the
-  # repo-wide unit-coverage merge — which expects <pkg>/lcov.info and prefixes
-  # its SF paths — maps them correctly, exactly like the node packages'
-  # --test-reporter=lcov output.
-  bun test --coverage --coverage-reporter=lcov "${files[@]}"
-  status=$?
-  awk '/^SF:/{keep=/^SF:src\//} keep' coverage/lcov.info > lcov.info 2>/dev/null || true
-  rm -rf coverage
-  exit $status
-fi
-
-bun_cmd="bun test"
+# Construct the bun command
+#
+# --parallel gives every test file its own worker process, which is what node's
+# `--test` did. Several suites keep module-level caches (a TypeScript program, a
+# temp fixture directory) that a shared process would leak between files.
+#
+# --timeout because bun caps a test at 5s by default where node had no cap, and
+# the suites that build real TypeScript programs run well past that.
+bun_cmd=(bun test --parallel --timeout 120000)
 
+# Append options based on flags
 if [ "$watch_mode" = true ]; then
-  bun_cmd="$bun_cmd --watch"
+  # --watch reruns in one process; parallel workers have nothing to watch.
+  bun_cmd=(bun test --watch --timeout 120000)
+fi
+
+if [ "$coverage_mode" = true ]; then
+  # --coverage-dir=. keeps lcov.info at the package root: CI merges every
+  # package's report by prefixing its SF paths with the file's own directory,
+  # so a nested coverage/ directory would re-root them one level too deep.
+  bun_cmd+=(--coverage --coverage-reporter=lcov --coverage-reporter=text --coverage-dir=.)
+  export PIKKU_TEST_COVERAGE=1
 fi
 
-$bun_cmd "${files[@]}"
+# Execute the bun command with the expanded list of files
+"${bun_cmd[@]}" "${files[@]}"

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 };
-        },
-    };
-}

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/bun-sqlite-adapter.ts","../src/create-bun-sqlite-kysely.ts","../src/index.ts","../src/register-functions.ts"],"version":"6.0.3"}

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

@@ -1,176 +0,0 @@
-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'
-
-interface TestDB {
-  items: { id: number; name: string; active: number; score: number | null }
-}
-
-describe('BunSqliteDatabase', () => {
-  let db: Database
-  let kysely: Kysely<TestDB>
-
-  beforeEach(() => {
-    db = new Database(':memory:')
-    kysely = new Kysely<TestDB>({
-      dialect: new SqliteDialect({ database: new BunSqliteDatabase(db) }),
-    })
-  })
-
-  afterEach(async () => {
-    await kysely.destroy()
-  })
-
-  test('create table and insert a row', async () => {
-    await kysely.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 kysely
-      .insertInto('items')
-      .values({ name: 'alpha', active: 1, score: 3.14 })
-      .execute()
-
-    const rows = await kysely.selectFrom('items').selectAll().execute()
-    assert.equal(rows.length, 1)
-    assert.equal(rows[0].name, 'alpha')
-    assert.equal(rows[0].active, 1)
-    assert.equal(rows[0].score, 3.14)
-  })
-
-  test('update and delete', async () => {
-    await kysely.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 kysely
-      .insertInto('items')
-      .values([
-        { name: 'a', active: 1, score: null },
-        { name: 'b', active: 0, score: null },
-      ])
-      .execute()
-
-    await kysely
-      .updateTable('items')
-      .set({ active: 1 })
-      .where('name', '=', 'b')
-      .execute()
-    const updated = await kysely
-      .selectFrom('items')
-      .where('name', '=', 'b')
-      .selectAll()
-      .executeTakeFirstOrThrow()
-    assert.equal(updated.active, 1)
-
-    await kysely.deleteFrom('items').where('name', '=', 'a').execute()
-    const remaining = await kysely.selectFrom('items').selectAll().execute()
-    assert.equal(remaining.length, 1)
-    assert.equal(remaining[0].name, 'b')
-  })
-
-  test('boolean coercion via coerce function', async () => {
-    await kysely.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 kysely
-      .insertInto('items')
-      .values({
-        name: 'bool-test',
-        active: true as unknown as number,
-        score: null,
-      })
-      .execute()
-    const row = await kysely
-      .selectFrom('items')
-      .selectAll()
-      .executeTakeFirstOrThrow()
-    assert.equal(row.active, 1)
-  })
-
-  test('null values round-trip', async () => {
-    await kysely.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 kysely
-      .insertInto('items')
-      .values({ name: 'nullable', active: 0, score: null })
-      .execute()
-    const row = await kysely
-      .selectFrom('items')
-      .selectAll()
-      .executeTakeFirstOrThrow()
-    assert.equal(row.score, null)
-  })
-
-  test('iterate returns rows lazily', async () => {
-    await kysely.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 kysely
-      .insertInto('items')
-      .values([
-        { name: 'x', active: 1, score: null },
-        { name: 'y', active: 1, score: null },
-        { name: 'z', active: 1, score: null },
-      ])
-      .execute()
-
-    const collected: string[] = []
-    const stmt = new BunSqliteDatabase(db).prepare(
-      'SELECT name FROM items ORDER BY id'
-    )
-    for (const row of stmt.iterate([])) {
-      collected.push((row as any).name)
-    }
-    assert.deepEqual(collected, ['x', 'y', 'z'])
-  })
-
-  test('reader is false for writes so run() returns mutation metadata', async () => {
-    await kysely.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()
-
-    const inserted = await kysely
-      .insertInto('items')
-      .values({ name: 'meta', active: 1, score: null })
-      .executeTakeFirstOrThrow()
-    assert.equal(inserted.insertId, 1n)
-
-    const updated = await kysely
-      .updateTable('items')
-      .set({ active: 0 })
-      .where('name', '=', 'meta')
-      .executeTakeFirstOrThrow()
-    assert.equal(updated.numUpdatedRows, 1n)
-  })
-})

package/src/bun-sqlite-adapter.ts

@@ -1,51 +0,0 @@
-import type { Database, Statement } from 'bun:sqlite'
-import type { SqliteDatabase, SqliteStatement } from 'kysely'
-
-function coerce(v: unknown): unknown {
-  if (v === null || v === undefined) return null
-  if (typeof v === 'boolean') return v ? 1 : 0
-  if (v instanceof Date) return v.toISOString()
-  if (typeof v === 'object') return JSON.stringify(v)
-  return v
-}
-
-class BunSqliteStatement implements SqliteStatement {
-  constructor(private readonly stmt: Statement) {}
-
-  get reader(): boolean {
-    return this.stmt.columnNames.length > 0
-  }
-
-  all(parameters: ReadonlyArray<unknown>): unknown[] {
-    return this.stmt.all(...(parameters.map(coerce) as any))
-  }
-
-  *iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown> {
-    for (const row of this.stmt.iterate(...(parameters.map(coerce) as any))) {
-      yield row
-    }
-  }
-
-  run(parameters: ReadonlyArray<unknown>): {
-    changes: number | bigint
-    lastInsertRowid: number | bigint
-  } {
-    const result = this.stmt.run(...(parameters.map(coerce) as any))
-    return {
-      changes: result.changes,
-      lastInsertRowid: result.lastInsertRowid,
-    }
-  }
-}
-
-export class BunSqliteDatabase implements SqliteDatabase {
-  constructor(private readonly db: Database) {}
-
-  prepare(sql: string): SqliteStatement {
-    return new BunSqliteStatement(this.db.prepare(sql))
-  }
-
-  close(): void {
-    this.db.close()
-  }
-}

package/src/coercion-plugin.test.ts

@@ -1,90 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createBunSqliteKysely, createCoercionPlugin } from './index.js'
-import type { CoercionMap } from './index.js'
-import { sql, type Kysely } from 'kysely'
-
-interface TestDB {
-  users: { id: number; settings: unknown }
-  posts: { id: number; settings: unknown }
-}
-
-/**
- * The same map the CLI's local database builds from `coercion.gen.ts`: two
- * tables that disagree on the kind of a same-named column. Resolving it needs
- * the query's tables, which is what kept the CLI's copy and the runtime copies
- * from behaving identically.
- */
-const map: CoercionMap = {
-  users: { settings: 'json' },
-  posts: { settings: 'bool' },
-}
-
-const seed = async (db: Kysely<TestDB>) => {
-  await sql`create table users (id integer primary key, settings text)`.execute(
-    db
-  )
-  await sql`create table posts (id integer primary key, settings integer)`.execute(
-    db
-  )
-  await sql`insert into users (id, settings) values (1, '{"theme":"dark"}')`.execute(
-    db
-  )
-  await sql`insert into posts (id, settings) values (1, 1)`.execute(db)
-}
-
-describe('bun-sqlite coercion plugin', () => {
-  test('resolves a colliding column against the queried table', async () => {
-    const db = createBunSqliteKysely<TestDB>({
-      filename: ':memory:',
-      plugins: [createCoercionPlugin({ map })],
-    })
-    await seed(db)
-
-    const user = await db
-      .selectFrom('users')
-      .select('settings')
-      .executeTakeFirstOrThrow()
-    assert.deepEqual(user.settings, { theme: 'dark' })
-
-    const post = await db
-      .selectFrom('posts')
-      .select('settings')
-      .executeTakeFirstOrThrow()
-    assert.equal(post.settings, true)
-
-    await db.destroy()
-  })
-
-  test('coerces date, bool and json columns read back from SQLite', async () => {
-    const db = createBunSqliteKysely<{
-      rows: { created_at: unknown; is_active: unknown; meta: unknown }
-    }>({
-      filename: ':memory:',
-      camelCase: false,
-      plugins: [
-        createCoercionPlugin({
-          map: {
-            rows: { created_at: 'date', is_active: 'bool', meta: 'json' },
-          },
-        }),
-      ],
-    })
-    await sql`create table rows (created_at text, is_active integer, meta text)`.execute(
-      db
-    )
-    await sql`insert into rows values ('2026-06-26T00:00:00.000Z', 0, '{"a":1}')`.execute(
-      db
-    )
-
-    const row = await db
-      .selectFrom('rows')
-      .selectAll()
-      .executeTakeFirstOrThrow()
-    assert.ok(row.created_at instanceof Date)
-    assert.equal(row.is_active, false)
-    assert.deepEqual(row.meta, { a: 1 })
-
-    await db.destroy()
-  })
-})

package/src/create-bun-sqlite-kysely.test.ts

@@ -1,45 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { sql } from 'kysely'
-import { createBunSqliteKysely } from './create-bun-sqlite-kysely.js'
-
-interface TestDB {
-  widgets: { id: number; displayName: string }
-}
-
-describe('createBunSqliteKysely', () => {
-  test('creates a working in-memory Kysely with camelCase mapping by default', async () => {
-    const db = createBunSqliteKysely<TestDB>({ filename: ':memory:' })
-
-    await sql`CREATE TABLE widgets (id INTEGER PRIMARY KEY, display_name TEXT)`.execute(
-      db
-    )
-    await db
-      .insertInto('widgets')
-      .values({ id: 1, displayName: 'hello' })
-      .execute()
-
-    const row = await db
-      .selectFrom('widgets')
-      .selectAll()
-      .executeTakeFirstOrThrow()
-
-    assert.equal(row.displayName, 'hello')
-    await db.destroy()
-  })
-
-  test('can disable camelCase and layer extra plugins', async () => {
-    const db = createBunSqliteKysely<{ t: { snake_col: string } }>({
-      filename: ':memory:',
-      camelCase: false,
-      plugins: [],
-    })
-
-    await sql`CREATE TABLE t (snake_col TEXT)`.execute(db)
-    await db.insertInto('t').values({ snake_col: 'raw' }).execute()
-    const row = await db.selectFrom('t').selectAll().executeTakeFirstOrThrow()
-
-    assert.equal(row.snake_col, 'raw')
-    await db.destroy()
-  })
-})

package/src/create-bun-sqlite-kysely.ts

@@ -1,45 +0,0 @@
-import { Database } from 'bun:sqlite'
-import {
-  Kysely,
-  SqliteDialect,
-  CamelCasePlugin,
-  type KyselyPlugin,
-} from 'kysely'
-import type { SqliteFunctionMap } from '@pikku/kysely-sqlite'
-import { BunSqliteDatabase } from './bun-sqlite-adapter.js'
-import { registerSqliteFunctions } from './register-functions.js'
-
-export interface CreateBunSqliteKyselyOptions {
-  /** Path to the SQLite file. Use ':memory:' for an in-memory DB. */
-  filename: string
-  /** Apply CamelCasePlugin so DB columns map to camelCase TS fields. Default true. */
-  camelCase?: boolean
-  /** Extra plugins to layer on top. */
-  plugins?: KyselyPlugin[]
-  /**
-   * Accepted only so that setting it fails loudly. bun:sqlite cannot register
-   * user-defined SQL functions, so passing any throws
-   * SqliteFunctionsUnsupportedError here rather than leaving the queries that
-   * call them to fail with "no such function" later.
-   *
-   * The option is declared — instead of simply absent — so that code shared
-   * with `createNodeSqliteKysely` still type-checks and the incompatibility
-   * shows up as an error that explains itself.
-   */
-  functions?: SqliteFunctionMap
-}
-
-export function createBunSqliteKysely<DB>(
-  options: CreateBunSqliteKyselyOptions
-): Kysely<DB> {
-  const db = new Database(options.filename)
-  if (options.functions) registerSqliteFunctions(db, options.functions)
-  const plugins: KyselyPlugin[] = []
-  if (options.camelCase ?? true) plugins.push(new CamelCasePlugin())
-  if (options.plugins) plugins.push(...options.plugins)
-
-  return new Kysely<DB>({
-    dialect: new SqliteDialect({ database: new BunSqliteDatabase(db) }),
-    plugins,
-  })
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-export { BunSqliteDatabase } 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'
-export {
-  createCoercionPlugin,
-  type ColumnKind,
-  type CoercionMap,
-  type CreateCoercionPluginOptions,
-} from '@pikku/kysely'

package/src/register-functions.test.ts

@@ -1,54 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { Database } from 'bun:sqlite'
-import { SqliteFunctionsUnsupportedError } from '@pikku/kysely-sqlite'
-import { registerSqliteFunctions } from './register-functions.js'
-import { createBunSqliteKysely } from './create-bun-sqlite-kysely.js'
-
-describe('registerSqliteFunctions', () => {
-  test('throws rather than silently skipping registration', () => {
-    const db = new Database(':memory:')
-    assert.throws(
-      () => registerSqliteFunctions(db, { similarity: () => 0 }),
-      SqliteFunctionsUnsupportedError
-    )
-    db.close()
-  })
-
-  test('names every requested function, so the error says what to port', () => {
-    const db = new Database(':memory:')
-    try {
-      registerSqliteFunctions(db, {
-        similarity: () => 0,
-        levenshtein: () => 0,
-      })
-      assert.fail('expected a throw')
-    } catch (error) {
-      assert.ok(error instanceof SqliteFunctionsUnsupportedError)
-      assert.deepEqual(error.functionNames, ['similarity', 'levenshtein'])
-      assert.match(error.message, /similarity, levenshtein/)
-      assert.match(error.message, /kysely-node-sqlite/)
-    }
-    db.close()
-  })
-
-  // The point of the whole change: the failure has to happen while the app is
-  // wiring itself up, not on the first request that reaches a query using one.
-  test('createBunSqliteKysely rejects `functions` at construction', () => {
-    assert.throws(
-      () =>
-        createBunSqliteKysely({
-          filename: ':memory:',
-          functions: { similarity: () => 0 },
-        }),
-      SqliteFunctionsUnsupportedError
-    )
-  })
-
-  test('omitting `functions` is unaffected', async () => {
-    const db = createBunSqliteKysely<{ t: { id: number } }>({
-      filename: ':memory:',
-    })
-    await db.destroy()
-  })
-})

package/src/register-functions.ts

@@ -1,30 +0,0 @@
-import type { Database } from 'bun:sqlite'
-import {
-  SqliteFunctionsUnsupportedError,
-  type SqliteFunctionMap,
-} from '@pikku/kysely-sqlite'
-
-/**
- * The bun counterpart to `@pikku/kysely-node-sqlite`'s function of the same
- * name. It always throws: bun:sqlite exposes `loadExtension` but nothing
- * equivalent to node:sqlite's `db.function()`, so scalar UDFs cannot be
- * registered at all.
- *
- * It exists precisely so that the failure happens here. Without it the two
- * drivers differ silently — code written against node registers its functions,
- * the same code on bun does not, and the difference only surfaces as
- * `no such function: …` from whichever query calls one, which in practice means
- * one endpoint failing in production while the rest of the app looks healthy.
- *
- * Throwing at wiring time turns that into a startup error naming every function
- * involved.
- */
-export function registerSqliteFunctions(
-  _db: Database,
-  functions: SqliteFunctionMap
-): never {
-  throw new SqliteFunctionsUnsupportedError(
-    'bun:sqlite',
-    Object.keys(functions)
-  )
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "module": "Node18",
-    "outDir": "dist",
-    "target": "esnext",
-    "declaration": true,
-    "types": ["bun"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["**/*.test.ts", "node_modules"]
-}