@pikku/kysely-node-sqlite 0.12.7 → 0.12.9

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @pikku/kysely-node-sqlite
 
+## 0.12.9
+
+### Patch Changes
+
+- 1fe79bc: A standalone build of a SQLite app now ships its `db.sqliteExtensions` (sqlite-vec's vec0 by default) inside the artifact, so a migration or query that uses them works in production the way it does under `pikku dev`. The node bundle loads them from `sqlite-extensions/` beside itself; a compiled bun binary embeds them and writes them out under `$PIKKU_DATA_DIR/.pikku-sqlite-extensions/` on start. The libraries are the build machine's, so an extension that cannot be resolved there fails the build; `[]` builds without them.
+
+  `createNodeSqliteKysely` and `createBunSqliteKysely` take an `extensions` list of library paths to load into the connection.
+
+- Updated dependencies [1394385]
+- Updated dependencies [7740547]
+  - @pikku/core@0.12.124
+  - @pikku/kysely-sqlite@0.12.15
+
+## 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

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

@@ -16,5 +16,11 @@ export interface CreateNodeSqliteKyselyOptions {
      * register functions. Using it is a decision to stay on Node.
      */
     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.
+     */
+    extensions?: string[];
 }
 export declare function createNodeSqliteKysely<DB>(options: CreateNodeSqliteKyselyOptions): Kysely<DB>;

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

@@ -3,7 +3,17 @@ import { Kysely, SqliteDialect, CamelCasePlugin, } from 'kysely';
 import { NodeSqliteDatabase } from './node-sqlite-adapter.js';
 import { registerSqliteFunctions } from './register-functions.js';
 export function createNodeSqliteKysely(options) {
-    const db = new DatabaseSync(options.filename);
+    const extensions = options.extensions ?? [];
+    // node:sqlite refuses loadExtension on a connection not opened allowing it,
+    // so allow it only when there is something to load, and shut it again after.
+    const db = new DatabaseSync(options.filename, {
+        allowExtension: extensions.length > 0,
+    });
+    if (extensions.length > 0) {
+        for (const path of extensions)
+            db.loadExtension(path);
+        db.enableLoadExtension(false);
+    }
     if (options.functions)
         registerSqliteFunctions(db, options.functions);
     const plugins = [];

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.7",
+  "version": "0.12.9",
+  "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,26 +19,25 @@
     "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.18",
-    "@pikku/kysely-sqlite": "^0.12.13",
+    "@pikku/kysely": "^0.13.25",
+    "@pikku/kysely-sqlite": "^0.12.15",
     "kysely": "^0.29.5"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.86"
+    "@pikku/core": "^0.12.124"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.86",
+    "@pikku/core": "^0.12.124",
     "@types/node": "^22",
-    "tsx": "^4.23.12",
-    "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/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.test.ts

@@ -1,90 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createNodeSqliteKysely, 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('node-sqlite coercion plugin', () => {
-  test('resolves a colliding column against the queried table', async () => {
-    const db = createNodeSqliteKysely<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 = createNodeSqliteKysely<{
-      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-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,16 +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 CoercionMap,
-  type CreateCoercionPluginOptions,
-} from '@pikku/kysely'

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"]
-}