@pikku/kysely-bun-sqlite 0.12.9 → 0.12.11

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/package.json

@@ -1,34 +1,43 @@
 {
   "name": "@pikku/kysely-bun-sqlite",
-  "version": "0.12.9",
+  "version": "0.12.11",
+  "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",
   "module": "dist/src/index.js",
   "main": "dist/src/index.js",
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
   "type": "module",
   "scripts": {
     "tsc": "tsc",
     "ncu": "npx npm-check-updates",
-    "build": "tsc -b",
+    "build": "bun run clean && tsc -b",
     "test": "bash run-tests.sh",
     "test:coverage": "bash run-tests.sh --coverage",
-    "prepublishOnly": "bun run build"
+    "prepublishOnly": "bun run build",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "engines": {
     "bun": ">=1.4.0"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.18",
-    "@pikku/kysely-sqlite": "^0.12.13",
-    "kysely": "^0.29.5"
+    "@pikku/kysely": "^0.13.39",
+    "@pikku/kysely-sqlite": "^0.12.18",
+    "kysely": "^0.29.6"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.105"
+    "@pikku/core": "^0.12.144"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.105",
-    "@types/bun": "^1.4.0",
-    "typescript": "^6.0.3"
+    "@pikku/core": "^0.12.144",
+    "@types/bun": "^1.4.3"
   }
-}
+}

package/CHANGELOG.md

@@ -1,160 +0,0 @@
-# @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
-
-- 6ff72d3: Raise the supported Bun version to 1.4.
-
-  `@pikku/bun-server` and `@pikku/kysely-bun-sqlite` now declare `engines.bun: >=1.4.0`
-  and build against `@types/bun@^1.4.0`. `create-pikku` scaffolds
-  `"packageManager": "bun@1.4.0"`, and the fabric `smoke`/`validate` commands default to
-  and recommend the same version. CI pins `oven-sh/setup-bun` to 1.4.0 instead of
-  tracking `latest`.
-
-## 0.12.7
-
-### Patch Changes
-
-- 746ed6a: fix: one coercion plugin, not three
-
-  The Kysely coercion plugin existed in three copies — the CLI's local database,
-  `@pikku/kysely-node-sqlite` and `@pikku/kysely-bun-sqlite` — and all three had
-  drifted apart. Only the CLI's resolved a column against the tables the query
-  actually named, so two tables that disagree on the kind of a same-named column
-  coerced correctly in local development and silently did not at runtime; only
-  bun's dropped a genuinely ambiguous column instead of letting the last table
-  processed win.
-
-  The single implementation now lives in `@pikku/kysely`, which all three already
-  depended on, and keeps both behaviours: table-qualified resolution first, an
-  ambiguity-safe bare-name fallback second.
-
-  `ColumnKind` — the value type of the generated `coercion.gen.ts` — is
-  `'date' | 'bool' | 'json'`. The CLI's fourth member, `uuid`, was never a
-  coercion kind: the codegen excludes it from the map by construction, because a
-  UUID is a string in both Postgres and SQLite. It is now `AnnotationKind` in the
-  CLI, the union a column may declare in `db/annotations.ts`, of which
-  `ColumnKind` is the coercible subset.
-
-  `@pikku/cli` also drops its unused dependency on the Node-only
-  `@pikku/kysely-node-sqlite`.
-
-- Updated dependencies [5a1a962]
-- Updated dependencies [746ed6a]
-  - @pikku/core@0.12.86
-  - @pikku/kysely@0.13.18
-
-## 0.12.6
-
-### Patch Changes
-
-- 6eef0a0: Bump every dependency to its latest compatible minor/patch across the monorepo.
-- Updated dependencies [7722ceb]
-- Updated dependencies [375c1ff]
-- Updated dependencies [02a70cd]
-- Updated dependencies [aeef159]
-- Updated dependencies [a281de6]
-- Updated dependencies [266e3bc]
-- Updated dependencies [02a70cd]
-- Updated dependencies [786dae5]
-- Updated dependencies [6eef0a0]
-- Updated dependencies [3561d67]
-- Updated dependencies [a91c433]
-- Updated dependencies [02a70cd]
-- Updated dependencies [9537f74]
-- Updated dependencies [2b57ca8]
-- Updated dependencies [266e3bc]
-- Updated dependencies [9fce0f1]
-- Updated dependencies [83683a0]
-- Updated dependencies [456c88b]
-- Updated dependencies [456c88b]
-- Updated dependencies [c127273]
-  - @pikku/core@0.12.85
-  - @pikku/kysely@0.13.17
-  - @pikku/kysely-sqlite@0.12.13
-
-## 0.12.5
-
-### Patch Changes
-
-- 0686513: Declare `@pikku/core` as a peer dependency, matching `@pikku/kysely-sqlite`.
-
-  The package depends on `@pikku/kysely-sqlite`, which requires `@pikku/core` as a
-  peer, but never declared that requirement itself — so an install resolved
-  without complaint and the missing peer only surfaced at runtime. It is now
-  declared the same way its sibling declares it.
-
-- Updated dependencies [7406bfe]
-- Updated dependencies [6794681]
-- Updated dependencies [a7fcd2e]
-  - @pikku/core@0.12.84
-  - @pikku/kysely@0.13.16
-  - @pikku/kysely-sqlite@0.12.12
-
-## 0.12.4
-
-### Patch Changes
-
-- fd9d834: Stop publishing internals that only their own package or file used. The declarations stay; only the entrypoint re-export is removed, so nothing that imported a name from where it is declared is affected.
-- Updated dependencies [fd9d834]
-  - @pikku/kysely@0.13.15
-  - @pikku/kysely-sqlite@0.12.11
-
-## 0.12.3
-
-### Patch Changes
-
-- 9d62571: Make user-defined SQL functions an explicit, checked capability of the SQLite drivers.
-
-  `node:sqlite` can register scalar UDFs (`db.function()`); `bun:sqlite` cannot. Until now
-  neither driver mentioned that, so an app that registered a UDF by reaching for the raw
-  connection worked on Node and, on bun, failed as `no such function: …` from whichever
-  query used it — typically one endpoint breaking in production while everything else
-  looked healthy.
-
-  Both drivers now export `registerSqliteFunctions(db, functions)` and accept a
-  `functions` option on `createNodeSqliteKysely` / `createBunSqliteKysely`. The Node
-  implementation registers them as deterministic; the bun implementation throws
-  `SqliteFunctionsUnsupportedError` — exported from `@pikku/kysely-sqlite`, and naming
-  every function requested — so the incompatibility surfaces at wiring time with a message
-  saying what to do about it.
-
-- Updated dependencies [cabd9dc]
-- Updated dependencies [9d62571]
-  - @pikku/kysely@0.13.8
-  - @pikku/kysely-sqlite@0.12.10
-
-## 0.12.2
-
-### Patch Changes
-
-- 41ce2cb: Upgrade to TypeScript 6 and raise the minimum Node.js version to 22.
-
-  All packages now build against `typescript@^6.0.3` and declare `engines.node >= 22`. Internal tooling (`ts-json-schema-generator`, `zod-to-ts`) was bumped to TypeScript 6-compatible releases.
-
-- Updated dependencies [241e6cf]
-- Updated dependencies [41ce2cb]
-  - @pikku/kysely@0.13.0
-  - @pikku/kysely-sqlite@0.12.7
-
-## 0.12.1
-
-### Patch Changes
-
-- d5c3c85: feat: bun first-class support — new `@pikku/bun-server` runtime and `@pikku/kysely-bun-sqlite` dialect, bun template, CI matrix with `package-manager: [yarn, bun]`, and bun verifier.
-- Updated dependencies [92cd5b1]
-  - @pikku/kysely@0.12.17

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/run-tests.sh

@@ -1,54 +0,0 @@
-#!/bin/bash
-
-shopt -s nullglob
-
-watch_mode=false
-coverage_mode=false
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --watch)
-      watch_mode=true
-      shift
-      ;;
-    --coverage)
-      coverage_mode=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-files=()
-while IFS= read -r -d '' file; do
-  files+=("$file")
-done < <(find src -type f -name "*.test.ts" -print0)
-
-if [ ${#files[@]} -eq 0 ]; then
-  echo "No test files found"
-  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"
-
-if [ "$watch_mode" = true ]; then
-  bun_cmd="$bun_cmd --watch"
-fi
-
-$bun_cmd "${files[@]}"

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

@@ -1,212 +0,0 @@
-import { describe, test, beforeEach, afterEach } from 'node:test'
-import assert from 'node:assert/strict'
-import { Database } from 'bun:sqlite'
-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 }
-}
-
-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)
-  })
-})
-
-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,64 +0,0 @@
-import { Database, type 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()
-  }
-}
-
-/**
- * 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/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,19 +0,0 @@
-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'
-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"]
-}