@pikku/kysely-sqlite 0.12.9 → 0.12.11

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @pikku/kysely-sqlite
 
+## 0.12.11
+
+### 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 [063f43a]
+- Updated dependencies [ce66bf8]
+- Updated dependencies [d0307a8]
+- Updated dependencies [ce66bf8]
+- Updated dependencies [3ad2131]
+- Updated dependencies [b930dca]
+- Updated dependencies [b95e77d]
+- Updated dependencies [fd9d834]
+- Updated dependencies [8978fbd]
+  - @pikku/core@0.12.82
+  - @pikku/kysely@0.13.15
+
+## 0.12.10
+
+### 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 [32277d5]
+- Updated dependencies [ea8aabf]
+- Updated dependencies [33e96ab]
+- Updated dependencies [fd72e58]
+- Updated dependencies [cabd9dc]
+- Updated dependencies [fd72e58]
+- Updated dependencies [fd72e58]
+- Updated dependencies [894b2f8]
+- Updated dependencies [dd19aa7]
+- Updated dependencies [50ec500]
+  - @pikku/core@0.12.75
+  - @pikku/kysely@0.13.8
+
 ## 0.12.9
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -7,9 +7,8 @@ export { SQLiteKyselyWorkflowRunService } from './sqlite-kysely-workflow-run-ser
 export { SQLiteKyselyChannelStore } from './sqlite-kysely-channel-store.js';
 export { SQLiteKyselyEventHubStore } from './sqlite-kysely-eventhub-store.js';
 export { SQLiteKyselySecretService } from './sqlite-kysely-secret-service.js';
+export { SqliteFunctionsUnsupportedError, type SqliteFunctionMap, } from './sqlite-functions.js';
 export { LibsqlWebDialect } from './libsql-web-dialect.js';
-export type { LibsqlWebDialectConfig } from './libsql-web-dialect.js';
 export type { KyselyPikkuDB } from '@pikku/kysely';
-export type { KyselySecretServiceConfig } from '@pikku/kysely';
 export type { WorkflowRunService } from '@pikku/core/workflow';
 export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent';

package/dist/src/index.js

@@ -7,4 +7,5 @@ export { SQLiteKyselyWorkflowRunService } from './sqlite-kysely-workflow-run-ser
 export { SQLiteKyselyChannelStore } from './sqlite-kysely-channel-store.js';
 export { SQLiteKyselyEventHubStore } from './sqlite-kysely-eventhub-store.js';
 export { SQLiteKyselySecretService } from './sqlite-kysely-secret-service.js';
+export { SqliteFunctionsUnsupportedError, } from './sqlite-functions.js';
 export { LibsqlWebDialect } from './libsql-web-dialect.js';

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

@@ -0,0 +1,32 @@
+/**
+ * User-defined SQL functions, shared between the runtime-specific SQLite
+ * drivers so that `functions: { … }` means the same thing whichever one an app
+ * is wired to.
+ *
+ * Only `@pikku/kysely-node-sqlite` can actually register them. bun:sqlite has
+ * no equivalent of `db.function()`, so `@pikku/kysely-bun-sqlite` rejects this
+ * option outright rather than accepting it and letting the queries fail. That
+ * asymmetry is the whole reason this type is declared once, in a package both
+ * depend on: an app that names its UDFs against this type finds out at wiring
+ * time — or at the type level — that it cannot move to bun, instead of finding
+ * out as `no such function: …` from whichever endpoint happens to use it.
+ */
+/**
+ * A scalar SQL function. Arguments arrive as the values SQLite stores — string,
+ * number, bigint, Uint8Array or null — and the return value must be one SQLite
+ * can store, so no Date, boolean or object.
+ */
+export type SqliteFunction = (...args: Array<string | number | bigint | Uint8Array | null>) => string | number | bigint | Uint8Array | null;
+/** Scalar SQL functions to register, keyed by the name SQL will call them by. */
+export type SqliteFunctionMap = Record<string, SqliteFunction>;
+/**
+ * Thrown when UDFs are requested on a runtime that cannot provide them.
+ *
+ * Its own class rather than a plain Error because the one sensible reaction —
+ * fall back to doing the work outside SQL — is worth being able to catch for.
+ */
+export declare class SqliteFunctionsUnsupportedError extends Error {
+    readonly runtime: string;
+    readonly functionNames: string[];
+    constructor(runtime: string, functionNames: string[]);
+}

package/dist/src/sqlite-functions.js

@@ -0,0 +1,33 @@
+/**
+ * User-defined SQL functions, shared between the runtime-specific SQLite
+ * drivers so that `functions: { … }` means the same thing whichever one an app
+ * is wired to.
+ *
+ * Only `@pikku/kysely-node-sqlite` can actually register them. bun:sqlite has
+ * no equivalent of `db.function()`, so `@pikku/kysely-bun-sqlite` rejects this
+ * option outright rather than accepting it and letting the queries fail. That
+ * asymmetry is the whole reason this type is declared once, in a package both
+ * depend on: an app that names its UDFs against this type finds out at wiring
+ * time — or at the type level — that it cannot move to bun, instead of finding
+ * out as `no such function: …` from whichever endpoint happens to use it.
+ */
+/**
+ * Thrown when UDFs are requested on a runtime that cannot provide them.
+ *
+ * Its own class rather than a plain Error because the one sensible reaction —
+ * fall back to doing the work outside SQL — is worth being able to catch for.
+ */
+export class SqliteFunctionsUnsupportedError extends Error {
+    runtime;
+    functionNames;
+    constructor(runtime, functionNames) {
+        super(`${runtime} cannot register user-defined SQL functions, but ${functionNames.length} were requested: ${functionNames.join(', ')}.\n\n` +
+            `Every query calling them would fail with "no such function". Options:\n` +
+            `  - run on Node with @pikku/kysely-node-sqlite, which supports them; or\n` +
+            `  - do the work outside SQL, narrowing rows with an index first so the\n` +
+            `    computation runs over a candidate set rather than the whole table.`);
+        this.runtime = runtime;
+        this.functionNames = functionNames;
+        this.name = 'SqliteFunctionsUnsupportedError';
+    }
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/create-sqlite-kysely.ts","../src/index.ts","../src/libsql-web-dialect.ts","../src/sqlite-kysely-agent-run-service.ts","../src/sqlite-kysely-ai-storage-service.ts","../src/sqlite-kysely-channel-store.ts","../src/sqlite-kysely-deployment-service.ts","../src/sqlite-kysely-eventhub-store.ts","../src/sqlite-kysely-secret-service.ts","../src/sqlite-kysely-workflow-run-service.ts","../src/sqlite-kysely-workflow-service.ts"],"version":"6.0.3"}
+{"root":["../src/create-sqlite-kysely.ts","../src/index.ts","../src/libsql-web-dialect.ts","../src/sqlite-functions.ts","../src/sqlite-kysely-agent-run-service.ts","../src/sqlite-kysely-ai-storage-service.ts","../src/sqlite-kysely-channel-store.ts","../src/sqlite-kysely-deployment-service.ts","../src/sqlite-kysely-eventhub-store.ts","../src/sqlite-kysely-secret-service.ts","../src/sqlite-kysely-workflow-run-service.ts","../src/sqlite-kysely-workflow-service.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely-sqlite",
-  "version": "0.12.9",
+  "version": "0.12.11",
   "description": "SQLite dialect services and libSQL web dialect for Pikku, backed by Kysely",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -17,14 +17,14 @@
     "prepublishOnly": "yarn build"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.6",
+    "@pikku/kysely": "^0.13.15",
     "kysely": "^0.29.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.71"
+    "@pikku/core": "^0.12.82"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.71",
+    "@pikku/core": "^0.12.82",
     "typescript": "^6.0.3"
   },
   "exports": {

package/src/index.ts

@@ -7,10 +7,12 @@ export { SQLiteKyselyWorkflowRunService } from './sqlite-kysely-workflow-run-ser
 export { SQLiteKyselyChannelStore } from './sqlite-kysely-channel-store.js'
 export { SQLiteKyselyEventHubStore } from './sqlite-kysely-eventhub-store.js'
 export { SQLiteKyselySecretService } from './sqlite-kysely-secret-service.js'
+export {
+  SqliteFunctionsUnsupportedError,
+  type SqliteFunctionMap,
+} from './sqlite-functions.js'
 export { LibsqlWebDialect } from './libsql-web-dialect.js'
-export type { LibsqlWebDialectConfig } from './libsql-web-dialect.js'
 
 export type { KyselyPikkuDB } from '@pikku/kysely'
-export type { KyselySecretServiceConfig } from '@pikku/kysely'
 export type { WorkflowRunService } from '@pikku/core/workflow'
 export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent'

package/src/sqlite-functions.ts

@@ -0,0 +1,47 @@
+/**
+ * User-defined SQL functions, shared between the runtime-specific SQLite
+ * drivers so that `functions: { … }` means the same thing whichever one an app
+ * is wired to.
+ *
+ * Only `@pikku/kysely-node-sqlite` can actually register them. bun:sqlite has
+ * no equivalent of `db.function()`, so `@pikku/kysely-bun-sqlite` rejects this
+ * option outright rather than accepting it and letting the queries fail. That
+ * asymmetry is the whole reason this type is declared once, in a package both
+ * depend on: an app that names its UDFs against this type finds out at wiring
+ * time — or at the type level — that it cannot move to bun, instead of finding
+ * out as `no such function: …` from whichever endpoint happens to use it.
+ */
+
+/**
+ * A scalar SQL function. Arguments arrive as the values SQLite stores — string,
+ * number, bigint, Uint8Array or null — and the return value must be one SQLite
+ * can store, so no Date, boolean or object.
+ */
+export type SqliteFunction = (
+  ...args: Array<string | number | bigint | Uint8Array | null>
+) => string | number | bigint | Uint8Array | null
+
+/** Scalar SQL functions to register, keyed by the name SQL will call them by. */
+export type SqliteFunctionMap = Record<string, SqliteFunction>
+
+/**
+ * Thrown when UDFs are requested on a runtime that cannot provide them.
+ *
+ * Its own class rather than a plain Error because the one sensible reaction —
+ * fall back to doing the work outside SQL — is worth being able to catch for.
+ */
+export class SqliteFunctionsUnsupportedError extends Error {
+  constructor(
+    readonly runtime: string,
+    readonly functionNames: string[]
+  ) {
+    super(
+      `${runtime} cannot register user-defined SQL functions, but ${functionNames.length} were requested: ${functionNames.join(', ')}.\n\n` +
+        `Every query calling them would fail with "no such function". Options:\n` +
+        `  - run on Node with @pikku/kysely-node-sqlite, which supports them; or\n` +
+        `  - do the work outside SQL, narrowing rows with an index first so the\n` +
+        `    computation runs over a candidate set rather than the whole table.`
+    )
+    this.name = 'SqliteFunctionsUnsupportedError'
+  }
+}