@pikku/kysely-bun-sqlite 0.12.2 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @pikku/kysely-bun-sqlite
 
+## 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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 - present Yasser Fadl and Pikku contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @pikku/kysely-bun-sqlite
+
+Kysely driver for Pikku backed by Bun's built-in `bun:sqlite` module — no
+native dependency to install or compile.
+
+Ships a coercion plugin that maps SQLite's storage classes back to the types
+your schema declares (booleans, dates, JSON).
+
+## Install
+
+```bash
+bun add @pikku/kysely-bun-sqlite
+```
+
+Bun only — for Node use `@pikku/kysely-node-sqlite`.
+
+## Usage
+
+```typescript
+import { createBunSqliteKysely } from '@pikku/kysely-bun-sqlite'
+import type { KyselyPikkuDB } from '@pikku/kysely'
+
+const db = createBunSqliteKysely<KyselyPikkuDB>({
+  filename: 'app.db',
+})
+```
+
+`camelCase` (default `true`) applies Kysely's `CamelCasePlugin`; pass extra
+`plugins` to layer more on top. Use `':memory:'` for an in-memory database.
+
+## User-defined SQL functions are not supported
+
+`bun:sqlite` has no equivalent of `node:sqlite`'s `db.function()`, so scalar
+UDFs cannot be registered on this driver. Passing `functions` — or calling
+`registerSqliteFunctions` — throws `SqliteFunctionsUnsupportedError` immediately,
+naming every function requested.
+
+That is deliberate. The alternative is code that registers its functions on Node
+and silently does not on bun, where the difference only appears as
+`no such function: …` from whichever query calls one.
+
+If you hit this, either run on Node with `@pikku/kysely-node-sqlite`, or move the
+computation out of SQL: precompute what the function was matching on into an
+indexed table, use that index to narrow to a candidate set, and run the real
+logic over those rows in TypeScript.
+
+## Docs
+
+https://pikku.dev/docs

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

@@ -1,4 +1,5 @@
 import { Kysely, type KyselyPlugin } from 'kysely';
+import type { SqliteFunctionMap } from '@pikku/kysely-sqlite';
 export interface CreateBunSqliteKyselyOptions {
     /** Path to the SQLite file. Use ':memory:' for an in-memory DB. */
     filename: string;
@@ -6,5 +7,16 @@ export interface CreateBunSqliteKyselyOptions {
     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 declare function createBunSqliteKysely<DB>(options: CreateBunSqliteKyselyOptions): Kysely<DB>;

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

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

package/dist/src/index.d.ts

@@ -1,3 +1,5 @@
 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';
+export { registerSqliteFunctions } from './register-functions.js';
+export { SqliteFunctionsUnsupportedError, type SqliteFunctionMap, } from '@pikku/kysely-sqlite';
+export { createCoercionPlugin, type ColumnKind, type CreateCoercionPluginOptions, } from './coercion-plugin.js';

package/dist/src/index.js

@@ -1,3 +1,5 @@
 export { BunSqliteDatabase } 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';
 export { createCoercionPlugin, } from './coercion-plugin.js';

package/dist/src/register-functions.d.ts

@@ -0,0 +1,18 @@
+import type { Database } from 'bun:sqlite';
+import { 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 declare function registerSqliteFunctions(_db: Database, functions: SqliteFunctionMap): never;

package/dist/src/register-functions.js

@@ -0,0 +1,19 @@
+import { SqliteFunctionsUnsupportedError, } 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, functions) {
+    throw new SqliteFunctionsUnsupportedError('bun:sqlite', Object.keys(functions));
+}

package/dist/tsconfig.tsbuildinfo

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

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@pikku/kysely-bun-sqlite",
-  "version": "0.12.2",
+  "version": "0.12.4",
+  "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",
@@ -18,8 +19,8 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.0",
-    "@pikku/kysely-sqlite": "^0.12.7",
+    "@pikku/kysely": "^0.13.15",
+    "@pikku/kysely-sqlite": "^0.12.11",
     "kysely": "^0.29.0"
   },
   "devDependencies": {

package/src/coercion-plugin.test.ts

@@ -27,10 +27,9 @@ describe('createCoercionPlugin', () => {
   })
 
   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' }]
-    )
+    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(),
@@ -39,10 +38,9 @@ describe('createCoercionPlugin', () => {
   })
 
   test('leaves unparseable date strings untouched', async () => {
-    const [row] = await runTransform(
-      { users: { created_at: 'date' } },
-      [{ created_at: 'not-a-date' }]
-    )
+    const [row] = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: 'not-a-date' },
+    ])
     assert.equal(row.created_at, 'not-a-date')
   })
 
@@ -65,19 +63,17 @@ describe('createCoercionPlugin', () => {
   })
 
   test('passes through null values and unmapped columns', async () => {
-    const rows = await runTransform(
-      { users: { created_at: 'date' } },
-      [{ created_at: null, name: 'leave me' }]
-    )
+    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' }]
-    )
+    const rows = await runTransform({ users: { created_at: 'date' } }, [
+      { createdAt: '2026-06-26T00:00:00.000Z' },
+    ])
     assert.ok(rows[0].createdAt instanceof Date)
   })
 

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

@@ -5,7 +5,9 @@ import {
   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. */
@@ -14,12 +16,24 @@ export interface CreateBunSqliteKyselyOptions {
   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)

package/src/index.ts

@@ -3,9 +3,13 @@ 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 CoercionMap,
   type ColumnKind,
   type CreateCoercionPluginOptions,
 } from './coercion-plugin.js'

package/src/register-functions.test.ts

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

@@ -0,0 +1,30 @@
+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)
+  )
+}