@pikku/kysely-node-sqlite 0.12.5 → 0.12.8

package/CHANGELOG.md

@@ -1,5 +1,97 @@
 # @pikku/kysely-node-sqlite
 
+## 0.12.8
+
+### Patch Changes
+
+- 4c7a1b5: Run the monorepo's own scripts through bun instead of yarn. What moves is the
+  package manager each package's `prepublishOnly` and build scripts invoke, plus
+  the two manifest fixes bun needs to resolve the tree: `uWebSockets.js` is
+  declared with an explicit `github:` specifier, and `@pikku/uws-handler` marks
+  its `uWebSockets.js` peer optional so a bun install of a consumer that brings
+  its own uWS app does not try to fetch it from the registry.
+
+  Three published behaviours change, all of them cases where an isolated
+  `node_modules` or bun as the runtime had been papered over by yarn's hoisting:
+
+  - `@pikku/migrator-sql` turns foreign keys on when it opens a sqlite database
+    through bun. `node:sqlite` enforces them by default and `bun:sqlite` does not,
+    which silently turned every `ON DELETE CASCADE` into a no-op under
+    `bunx --bun pikku`.
+  - `@pikku/cli` resolves a deploy provider against the project being deployed
+    rather than against wherever the CLI itself is installed, which is what its
+    own "is not installed" error asks the user to arrange.
+  - `@pikku/cli` treats a specifier a runtime hands straight back — bun does this
+    for the modules it implements itself — as not resolved from the project, so
+    it falls back rather than loading the runtime's own copy.
+
+- Updated dependencies [4c7a1b5]
+  - @pikku/core@0.12.108
+  - @pikku/kysely@0.13.25
+  - @pikku/kysely-sqlite@0.12.14
+
+## 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

package/dist/src/index.d.ts

@@ -2,4 +2,4 @@ export { NodeSqliteDatabase } from './node-sqlite-adapter.js';
 export { createNodeSqliteKysely, type CreateNodeSqliteKyselyOptions, } from './create-node-sqlite-kysely.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';
+export { createCoercionPlugin, type ColumnKind, type CoercionMap, type CreateCoercionPluginOptions, } from '@pikku/kysely';

package/dist/src/index.js

@@ -2,4 +2,4 @@ export { NodeSqliteDatabase } from './node-sqlite-adapter.js';
 export { createNodeSqliteKysely, } from './create-node-sqlite-kysely.js';
 export { registerSqliteFunctions } from './register-functions.js';
 export { SqliteFunctionsUnsupportedError, } from '@pikku/kysely-sqlite';
-export { createCoercionPlugin, } from './coercion-plugin.js';
+export { createCoercionPlugin, } from '@pikku/kysely';

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

@@ -16,6 +16,22 @@ function coerce(v) {
         return JSON.stringify(v);
     return v;
 }
+/**
+ * Whether a statement returns rows. node:sqlite's StatementSync has no `reader`
+ * flag (better-sqlite3, which Kysely's SqliteDialect was written against, does),
+ * so the value has to come from the SQL: a writer is run through `.run()` for
+ * its `changes`/`lastInsertRowid`, a reader through `.all()` for its rows, and
+ * getting it wrong silently drops whichever half the caller wanted.
+ *
+ * The list is wider than SELECT because Kysely's own SQLite introspector asks
+ * for columns through a CTE over `pragma_table_info`, so a statement that opens
+ * with WITH is a reader too — treating it as a writer reports every table as
+ * having no columns.
+ */
+function isReaderSql(sql) {
+    return (/^\s*(select|with|pragma|values|explain)\b/i.test(sql) ||
+        /\breturning\b/i.test(sql));
+}
 /**
  * Wraps node:sqlite's DatabaseSync as Kysely's SqliteDatabase. The shapes
  * are close but not identical: node:sqlite's Statement methods take
@@ -24,9 +40,10 @@ function coerce(v) {
  */
 class NodeSqliteStatement {
     stmt;
-    reader = true;
-    constructor(stmt) {
+    reader;
+    constructor(stmt, reader) {
         this.stmt = stmt;
+        this.reader = reader;
     }
     all(parameters) {
         return this.stmt.all(...parameters.map(coerce));
@@ -50,7 +67,7 @@ export class NodeSqliteDatabase {
         this.db = db;
     }
     prepare(sql) {
-        return new NodeSqliteStatement(this.db.prepare(sql));
+        return new NodeSqliteStatement(this.db.prepare(sql), isReaderSql(sql));
     }
     close() {
         this.db.close();

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@pikku/kysely-node-sqlite",
-  "version": "0.12.5",
+  "version": "0.12.8",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/services/kysely-node-sqlite"
+  },
   "description": "Kysely driver for Pikku backed by the built-in node:sqlite module",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -14,24 +19,23 @@
     "test": "bash run-tests.sh",
     "test:watch": "bash run-tests.sh --watch",
     "test:coverage": "bash run-tests.sh --coverage",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "bun run build"
   },
   "engines": {
     "node": ">=22.10"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.15",
-    "@pikku/kysely-sqlite": "^0.12.11",
-    "kysely": "^0.29.0"
+    "@pikku/kysely": "^0.13.25",
+    "@pikku/kysely-sqlite": "^0.12.14",
+    "kysely": "^0.29.5"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.82"
+    "@pikku/core": "^0.12.108"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.82",
+    "@pikku/core": "^0.12.108",
     "@types/node": "^22",
-    "tsx": "^4.19.2",
-    "typescript": "^6.0.3"
+    "tsx": "^4.23.12"
   },
   "exports": {
     ".": "./dist/src/index.js"

package/run-tests.sh

@@ -1,33 +1,68 @@
 #!/bin/bash
 
-# Parse command line arguments
-WATCH_MODE=false
-COVERAGE_MODE=false
-
-for arg in "$@"
-do
-    case $arg in
-        --watch)
-        WATCH_MODE=true
-        shift
-        ;;
-        --coverage)
-        COVERAGE_MODE=true
-        shift
-        ;;
-    esac
+# 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)
+      watch_mode=true
+      shift
+      ;;
+    --coverage)
+      coverage_mode=true
+      shift
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
 done
 
-# Build the command
-CMD="node --import tsx --test --test-force-exit src/**/*.test.ts"
+# 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 matching pattern: $pattern"
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ]; then
+    exit 1
+  fi
+  exit 0
+fi
+
+# 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)
 
-if [ "$WATCH_MODE" = true ]; then
-    CMD="$CMD --watch"
+# Append options based on flags
+if [ "$watch_mode" = true ]; then
+  # --watch reruns in one process; parallel workers have nothing to watch.
+  bun_cmd=(bun test --watch --timeout 120000)
 fi
 
-if [ "$COVERAGE_MODE" = true ]; then
-    CMD="$CMD --experimental-test-coverage"
+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
 
-# Execute the command
-eval $CMD
+# 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,77 +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.
- */
-function buildGlobalMap(map) {
-    const out = {};
-    for (const tbl of Object.values(map)) {
-        for (const [col, kind] of Object.entries(tbl)) {
-            out[col] = kind;
-            out[snakeToCamel(col)] = kind;
-        }
-    }
-    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/coercion-plugin.ts","../src/create-node-sqlite-kysely.ts","../src/index.ts","../src/node-sqlite-adapter.ts","../src/register-functions.ts"],"version":"6.0.3"}

package/src/coercion-plugin.ts

@@ -1,92 +0,0 @@
-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.
- */
-function buildGlobalMap(map: CoercionMap): Record<string, ColumnKind> {
-  const out: Record<string, ColumnKind> = {}
-  for (const tbl of Object.values(map)) {
-    for (const [col, kind] of Object.entries(tbl)) {
-      out[col] = kind
-      out[snakeToCamel(col)] = kind
-    }
-  }
-  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-node-sqlite-kysely.ts

@@ -1,43 +0,0 @@
-import { DatabaseSync } from 'node:sqlite'
-import {
-  Kysely,
-  SqliteDialect,
-  CamelCasePlugin,
-  type KyselyPlugin,
-} from 'kysely'
-import type { SqliteFunctionMap } from '@pikku/kysely-sqlite'
-import { NodeSqliteDatabase } from './node-sqlite-adapter.js'
-import { registerSqliteFunctions } from './register-functions.js'
-
-export interface CreateNodeSqliteKyselyOptions {
-  /** 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[]
-  /**
-   * Scalar user-defined SQL functions to register, keyed by the name SQL calls
-   * them by. Registered as deterministic.
-   *
-   * Note that this is the one option with no bun equivalent:
-   * `createBunSqliteKysely` throws if it is set, because bun:sqlite cannot
-   * register functions. Using it is a decision to stay on Node.
-   */
-  functions?: SqliteFunctionMap
-}
-
-export function createNodeSqliteKysely<DB>(
-  options: CreateNodeSqliteKyselyOptions
-): Kysely<DB> {
-  const db = new DatabaseSync(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 NodeSqliteDatabase(db) }),
-    plugins,
-  })
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-export { NodeSqliteDatabase } from './node-sqlite-adapter.js'
-export {
-  createNodeSqliteKysely,
-  type CreateNodeSqliteKyselyOptions,
-} from './create-node-sqlite-kysely.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/src/node-sqlite-adapter.ts

@@ -1,62 +0,0 @@
-import type { DatabaseSync, StatementSync, SQLInputValue } from 'node:sqlite'
-import type { SqliteDatabase, SqliteStatement } from 'kysely'
-
-/**
- * Always-on write-side coercion: converts JS values that SQLite's node:sqlite
- * binding cannot accept into their storable equivalents.
- *   boolean  → 0 | 1
- *   Date     → ISO 8601 string
- *   object   → JSON string  (covers arrays and plain objects)
- */
-function coerce(v: unknown): SQLInputValue {
-  if (v === null || v === undefined) return null as unknown as SQLInputValue
-  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 as SQLInputValue
-}
-
-/**
- * Wraps node:sqlite's DatabaseSync as Kysely's SqliteDatabase. The shapes
- * are close but not identical: node:sqlite's Statement methods take
- * variadic positional params and always return bigint counters; Kysely's
- * dialect passes parameters as a ReadonlyArray and expects number|bigint.
- */
-class NodeSqliteStatement implements SqliteStatement {
-  readonly reader = true
-
-  constructor(private readonly stmt: StatementSync) {}
-
-  all(parameters: ReadonlyArray<unknown>): unknown[] {
-    return this.stmt.all(...parameters.map(coerce)) as unknown[]
-  }
-
-  *iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown> {
-    for (const row of this.stmt.iterate(...parameters.map(coerce))) {
-      yield row
-    }
-  }
-
-  run(parameters: ReadonlyArray<unknown>): {
-    changes: number | bigint
-    lastInsertRowid: number | bigint
-  } {
-    const result = this.stmt.run(...parameters.map(coerce))
-    return {
-      changes: result.changes,
-      lastInsertRowid: result.lastInsertRowid,
-    }
-  }
-}
-
-export class NodeSqliteDatabase implements SqliteDatabase {
-  constructor(private readonly db: DatabaseSync) {}
-
-  prepare(sql: string): SqliteStatement {
-    return new NodeSqliteStatement(this.db.prepare(sql))
-  }
-
-  close(): void {
-    this.db.close()
-  }
-}

package/src/register-functions.test.ts

@@ -1,52 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { DatabaseSync } from 'node:sqlite'
-import { sql } from 'kysely'
-import { registerSqliteFunctions } from './register-functions.js'
-import { createNodeSqliteKysely } from './create-node-sqlite-kysely.js'
-
-describe('registerSqliteFunctions', () => {
-  test('makes the function callable from SQL', () => {
-    const db = new DatabaseSync(':memory:')
-    registerSqliteFunctions(db, {
-      shout: (value) => `${String(value).toUpperCase()}!`,
-    })
-
-    const row = db.prepare(`SELECT shout('hello') AS v`).get() as { v: string }
-    assert.equal(row.v, 'HELLO!')
-    db.close()
-  })
-
-  test('registers as deterministic, so it is usable in an index', () => {
-    const db = new DatabaseSync(':memory:')
-    registerSqliteFunctions(db, { half: (n) => Number(n) / 2 })
-
-    db.exec('CREATE TABLE t (n INTEGER)')
-    // SQLite rejects non-deterministic functions in an index outright, so this
-    // statement succeeding IS the assertion about how they were registered.
-    db.exec('CREATE INDEX t_half ON t (half(n))')
-    db.close()
-  })
-
-  test('registers every entry in the map', () => {
-    const db = new DatabaseSync(':memory:')
-    registerSqliteFunctions(db, { a: () => 1, b: () => 2 })
-
-    const row = db.prepare('SELECT a() + b() AS v').get() as { v: number }
-    assert.equal(row.v, 3)
-    db.close()
-  })
-
-  test('createNodeSqliteKysely registers them on the connection it builds', async () => {
-    const db = createNodeSqliteKysely<{ t: { id: number } }>({
-      filename: ':memory:',
-      functions: { double: (n) => Number(n) * 2 },
-    })
-
-    const result = await sql<{
-      v: number
-    }>`SELECT double(21) AS v`.execute(db)
-    assert.equal(result.rows[0]!.v, 42)
-    await db.destroy()
-  })
-})

package/src/register-functions.ts

@@ -1,27 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite'
-import type { SqliteFunctionMap } from '@pikku/kysely-sqlite'
-
-/**
- * Registers scalar user-defined SQL functions on a node:sqlite connection.
- *
- * Exported separately from `createNodeSqliteKysely` because an app that needs
- * pragmas — WAL, `foreign_keys`, `busy_timeout` — has to build the connection
- * itself, and would otherwise have no supported way to add UDFs to it.
- *
- * Registered as `deterministic`, which is what makes them usable in indexes and
- * lets SQLite cache repeated calls with the same arguments. That is a promise
- * about the function, not a hint: one whose output depends on the clock, a
- * random source or anything mutable must not go through here.
- *
- * There is no bun counterpart. `@pikku/kysely-bun-sqlite` exports the same name
- * so the import resolves either way, but it throws — see
- * SqliteFunctionsUnsupportedError.
- */
-export function registerSqliteFunctions(
-  db: DatabaseSync,
-  functions: SqliteFunctionMap
-): void {
-  for (const [name, fn] of Object.entries(functions)) {
-    db.function(name, { deterministic: true }, fn as never)
-  }
-}

package/tsconfig.json

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