@pikku/kysely-bun-sqlite 0.12.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @pikku/kysely-bun-sqlite
+
+## 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/src/bun-sqlite-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { Database } from 'bun:sqlite';
+import type { SqliteDatabase, SqliteStatement } from 'kysely';
+export declare class BunSqliteDatabase implements SqliteDatabase {
+    private readonly db;
+    constructor(db: Database);
+    prepare(sql: string): SqliteStatement;
+    close(): void;
+}

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

@@ -0,0 +1,47 @@
+function coerce(v) {
+    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 {
+    stmt;
+    constructor(stmt) {
+        this.stmt = stmt;
+    }
+    get reader() {
+        return this.stmt.columnNames.length > 0;
+    }
+    all(parameters) {
+        return this.stmt.all(...parameters.map(coerce));
+    }
+    *iterate(parameters) {
+        for (const row of this.stmt.iterate(...parameters.map(coerce))) {
+            yield row;
+        }
+    }
+    run(parameters) {
+        const result = this.stmt.run(...parameters.map(coerce));
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+export class BunSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    prepare(sql) {
+        return new BunSqliteStatement(this.db.prepare(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,92 @@
+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/src/create-bun-sqlite-kysely.d.ts

@@ -0,0 +1,10 @@
+import { Kysely, type KyselyPlugin } from 'kysely';
+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[];
+}
+export declare function createBunSqliteKysely<DB>(options: CreateBunSqliteKyselyOptions): Kysely<DB>;

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

@@ -0,0 +1,15 @@
+import { Database } from 'bun:sqlite';
+import { Kysely, SqliteDialect, CamelCasePlugin, } from 'kysely';
+import { BunSqliteDatabase } from './bun-sqlite-adapter.js';
+export function createBunSqliteKysely(options) {
+    const db = new Database(options.filename);
+    const plugins = [];
+    if (options.camelCase ?? true)
+        plugins.push(new CamelCasePlugin());
+    if (options.plugins)
+        plugins.push(...options.plugins);
+    return new Kysely({
+        dialect: new SqliteDialect({ database: new BunSqliteDatabase(db) }),
+        plugins,
+    });
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export { BunSqliteDatabase } from './bun-sqlite-adapter.js';
+export { createBunSqliteKysely, type CreateBunSqliteKyselyOptions, } from './create-bun-sqlite-kysely.js';
+export { createCoercionPlugin, type CoercionMap, type ColumnKind, type CreateCoercionPluginOptions, } from './coercion-plugin.js';

package/dist/src/index.js

@@ -0,0 +1,3 @@
+export { BunSqliteDatabase } from './bun-sqlite-adapter.js';
+export { createBunSqliteKysely, } from './create-bun-sqlite-kysely.js';
+export { createCoercionPlugin, } from './coercion-plugin.js';

package/dist/tsconfig.tsbuildinfo

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

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@pikku/kysely-bun-sqlite",
+  "version": "0.12.1",
+  "author": "yasser.fadl@gmail.com",
+  "license": "MIT",
+  "module": "dist/src/index.js",
+  "main": "dist/src/index.js",
+  "type": "module",
+  "scripts": {
+    "tsc": "tsc",
+    "ncu": "npx npm-check-updates",
+    "build": "tsc -b",
+    "test": "bash run-tests.sh",
+    "test:coverage": "bash run-tests.sh --coverage",
+    "prepublishOnly": "bun run build"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@pikku/kysely": "^0.12.17",
+    "@pikku/kysely-sqlite": "^0.12.0",
+    "kysely": "^0.29.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.9"
+  }
+}

package/run-tests.sh

@@ -0,0 +1,54 @@
+#!/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

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,99 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import type { QueryResult, UnknownRow } from 'kysely'
+import { createCoercionPlugin } from './coercion-plugin.js'
+
+const runTransform = async (
+  map: Parameters<typeof createCoercionPlugin>[0]['map'],
+  rows: UnknownRow[]
+): Promise<UnknownRow[]> => {
+  const plugin = createCoercionPlugin({ map })
+  const result = { rows } as QueryResult<UnknownRow>
+  const out = await plugin.transformResult({
+    result,
+    queryId: { queryId: 'test' },
+  } as Parameters<NonNullable<typeof plugin.transformResult>>[0])
+  return out.rows as UnknownRow[]
+}
+
+describe('createCoercionPlugin', () => {
+  test('transformQuery passes the node through untouched', () => {
+    const plugin = createCoercionPlugin({ map: {} })
+    const node = { kind: 'SelectQueryNode' } as any
+    assert.equal(
+      plugin.transformQuery({ node, queryId: { queryId: 'x' } } as any),
+      node
+    )
+  })
+
+  test('coerces date columns from ISO strings to Date', async () => {
+    const [row] = await runTransform(
+      { users: { created_at: 'date' } },
+      [{ created_at: '2026-06-26T00:00:00.000Z' }]
+    )
+    assert.ok(row.created_at instanceof Date)
+    assert.equal(
+      (row.created_at as Date).toISOString(),
+      '2026-06-26T00:00:00.000Z'
+    )
+  })
+
+  test('leaves unparseable date strings untouched', async () => {
+    const [row] = await runTransform(
+      { users: { created_at: 'date' } },
+      [{ created_at: 'not-a-date' }]
+    )
+    assert.equal(row.created_at, 'not-a-date')
+  })
+
+  test('coerces bool columns from 0/1 numbers and bigints', async () => {
+    const rows = await runTransform(
+      { users: { is_active: 'bool', has_pets: 'bool' } },
+      [{ is_active: 1, has_pets: 0n }]
+    )
+    assert.equal(rows[0].is_active, true)
+    assert.equal(rows[0].has_pets, false)
+  })
+
+  test('parses json columns and tolerates invalid json', async () => {
+    const rows = await runTransform(
+      { users: { meta: 'json', broken: 'json' } },
+      [{ meta: '{"a":1}', broken: '{bad' }]
+    )
+    assert.deepEqual(rows[0].meta, { a: 1 })
+    assert.equal(rows[0].broken, '{bad')
+  })
+
+  test('passes through null values and unmapped columns', async () => {
+    const rows = await runTransform(
+      { users: { created_at: 'date' } },
+      [{ created_at: null, name: 'leave me' }]
+    )
+    assert.equal(rows[0].created_at, null)
+    assert.equal(rows[0].name, 'leave me')
+  })
+
+  test('matches both snake_case and camelCase column names', async () => {
+    const rows = await runTransform(
+      { users: { created_at: 'date' } },
+      [{ createdAt: '2026-06-26T00:00:00.000Z' }]
+    )
+    assert.ok(rows[0].createdAt instanceof Date)
+  })
+
+  test('leaves columns ambiguous across tables uncoerced', async () => {
+    const rows = await runTransform(
+      { users: { value: 'json' }, events: { value: 'bool' } },
+      [{ value: '{"a":1}' }]
+    )
+    assert.equal(rows[0].value, '{"a":1}')
+  })
+
+  test('still coerces columns that agree across tables', async () => {
+    const rows = await runTransform(
+      { users: { active: 'bool' }, events: { active: 'bool' } },
+      [{ active: 1 }]
+    )
+    assert.equal(rows[0].active, true)
+  })
+})

package/src/coercion-plugin.ts

@@ -0,0 +1,106 @@
+import type { KyselyPlugin, UnknownRow } 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
+}
+
+function fromDb(value: unknown, kind: ColumnKind): unknown {
+  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: string): string {
+  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: CoercionMap): Record<string, ColumnKind> {
+  const out: Record<string, ColumnKind> = {}
+  const ambiguous = new Set<string>()
+  const assign = (key: string, kind: ColumnKind) => {
+    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: CreateCoercionPluginOptions
+): KyselyPlugin {
+  const globalMap = buildGlobalMap(options.map)
+  return {
+    transformQuery(args) {
+      return args.node
+    },
+    async transformResult(args) {
+      const out: UnknownRow[] = []
+      for (const row of args.result.rows as UnknownRow[]) {
+        const next: UnknownRow = { ...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/src/create-bun-sqlite-kysely.test.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,31 @@
+import { Database } from 'bun:sqlite'
+import {
+  Kysely,
+  SqliteDialect,
+  CamelCasePlugin,
+  type KyselyPlugin,
+} from 'kysely'
+import { BunSqliteDatabase } from './bun-sqlite-adapter.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[]
+}
+
+export function createBunSqliteKysely<DB>(
+  options: CreateBunSqliteKyselyOptions
+): Kysely<DB> {
+  const db = new Database(options.filename)
+  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

@@ -0,0 +1,11 @@
+export { BunSqliteDatabase } from './bun-sqlite-adapter.js'
+export {
+  createBunSqliteKysely,
+  type CreateBunSqliteKyselyOptions,
+} from './create-bun-sqlite-kysely.js'
+export {
+  createCoercionPlugin,
+  type CoercionMap,
+  type ColumnKind,
+  type CreateCoercionPluginOptions,
+} from './coercion-plugin.js'

package/tsconfig.json

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