@meck93/kysely-bun-sqlite

A Kysely dialect for Bun's native SQLite with opt-in worker thread support.

Install

bun add @meck93/kysely-bun-sqlite kysely

Usage

In-Process (Default)

import { Kysely } from "kysely";
import { BunSqliteDialect } from "@meck93/kysely-bun-sqlite";
import Database from "bun:sqlite";

interface DB {
  person: { id: Generated<number>; name: string; age: number };
}

const db = new Kysely<DB>({
  dialect: new BunSqliteDialect({
    database: new Database("./app.sqlite"),
  }),
});

await db.insertInto("person").values({ name: "John", age: 30 }).execute();
const people = await db.selectFrom("person").selectAll().where("age", ">", 25).execute();

await db.destroy();

Worker Mode (Opt-In)

Runs all queries in a dedicated Bun Worker — keeps the main thread free.

Main thread:

import { Kysely } from "kysely";
import { BunWorkerDialect } from "@meck93/kysely-bun-sqlite";

const worker = new Worker(new URL("./db-worker.ts", import.meta.url), {
  type: "module",
});

const db = new Kysely<DB>({
  dialect: new BunWorkerDialect({
    worker,
    url: "./app.sqlite",
    requestTimeoutMs: 10_000,
  }),
});

Worker file (db-worker.ts):

import { createBunWorkerOnMessageCallback } from "@meck93/kysely-bun-sqlite";

createBunWorkerOnMessageCallback();

API

BunSqliteDialect

new BunSqliteDialect({
  database: Database,                    // Required — Bun SQLite instance
  onCreateConnection?: (conn) => void,   // Optional — called once on connection init
})

• Synchronous, single-connection (serialized via internal mutex)
• Supports streamQuery() via stmt.iterate() (Bun 1.1.31+)
• Full transaction and savepoint support

BunWorkerDialect

new BunWorkerDialect({
  worker: Worker,                        // Required — Bun Worker instance
  url?: string,                          // Default: ":memory:"
  dbOptions?: DBOptions,                 // Default: { create: true }
  cacheStatements?: boolean,             // Default: false
  requestTimeoutMs?: number,             // Default: 5000
  terminateWorkerOnDestroy?: boolean,    // Default: true
  onCreateConnection?: (conn) => void,   // Optional
})

• All queries dispatched via postMessage to the worker
• Configurable timeout per query (rejects on expiry)
• Worker terminated on db.destroy() by default
• Full transaction and savepoint support

createBunWorkerOnMessageCallback

Sets up the worker-side message handler. Optionally accepts a custom database factory:

createBunWorkerOnMessageCallback((url, dbOptions) => {
  return new Database(url, dbOptions);
});

Requirements

• Bun runtime
• Kysely ^0.28.11

License

MIT