@pikku/kysely-sqlite 0.12.8 → 0.12.9

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @pikku/kysely-sqlite
 
+## 0.12.9
+
+### Patch Changes
+
+- c335f73: `LibsqlWebDialect` now encodes a `Date` bind parameter as an ISO-8601 string and an array or plain record as JSON, instead of throwing `libsql: unsupported argument type object`.
+
+  This closes a dev/prod split that broke every write in a deployed libsql app. The CLI's `node:sqlite` dev runtime already coerced dates and objects before binding them, so a query that stamps a `createdAt` or writes a JSON column passed under `pikku dev` — and then threw on the same code path once the app was deployed to a Worker, where this dialect is the one in use. Reads were unaffected, so the symptom was an app whose every insert and update failed while every list and get worked.
+
+  Both runtimes also stop accepting objects JSON cannot faithfully represent. A `Map`, a `RegExp` or a class instance stringifies to `"{}"` or to a partial view of itself, so binding one used to persist an empty JSON blob where the caller meant something; it now throws. Only arrays and plain records (including null-prototype ones) are JSON-encoded. The two coercions are deliberately identical — a value that binds under `pikku dev` binds the same way once deployed, which is the property whose absence caused the original bug.
+
+  Unsupported values now name their constructor — `unsupported argument type Map` rather than `unsupported argument type object`.
+
+- Updated dependencies [8a2c993]
+- Updated dependencies [a261006]
+- Updated dependencies [09973b9]
+  - @pikku/core@0.12.71
+  - @pikku/kysely@0.13.6
+
 ## 0.12.8
 
 ### 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,32 @@
+# @pikku/kysely-sqlite
+
+SQLite dialect services for Pikku — workflow state, secrets, channel and
+event-hub stores — plus `LibsqlWebDialect` for libSQL/Turso over HTTP.
+
+Takes a `SqliteDatabase` rather than opening one, so it works with any SQLite
+driver. For the runtime built-ins use `@pikku/kysely-node-sqlite` or
+`@pikku/kysely-bun-sqlite`.
+
+## Install
+
+```bash
+npm install @pikku/kysely-sqlite
+```
+
+## Usage
+
+```typescript
+import {
+  createSQLiteKysely,
+  SQLiteKyselyWorkflowService,
+} from '@pikku/kysely-sqlite'
+import Database from 'better-sqlite3'
+
+const db = createSQLiteKysely(new Database('app.db'))
+
+const workflowService = new SQLiteKyselyWorkflowService(db)
+```
+
+## Docs
+
+https://pikku.dev/docs

package/dist/src/libsql-web-dialect.js

@@ -111,6 +111,32 @@ class LibsqlWebConnection {
         return json;
     }
 }
+/**
+ * Whether a value is a JSON column's worth of data rather than some other
+ * object that merely happens to be one.
+ *
+ * A `Map`, a `RegExp` or a class instance all stringify to `"{}"` or to a
+ * partial view of themselves, so accepting every object would silently persist
+ * an empty JSON blob where the caller meant something. Those fall through to
+ * the unsupported-type error instead. Kept in lockstep with the `coerce()` in
+ * the CLI's node:sqlite dev runtime (`db/sqlite/sqlite-kysely.ts`).
+ */
+function isJsonEncodable(v) {
+    if (Array.isArray(v))
+        return true;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Encodes one Kysely bind parameter as a Hrana value.
+ *
+ * The Date and plain-object branches exist for parity with the `coerce()` in
+ * the CLI's node:sqlite dev runtime (`db/sqlite/sqlite-kysely.ts`). Without
+ * them a query that binds a timestamp or a JSON column passes under
+ * `pikku dev` and throws `unsupported argument type object` once deployed to
+ * a Worker — so every write in a deployed libsql app fails while the same
+ * code works locally.
+ */
 function encodeArg(v) {
     if (v === null || v === undefined)
         return { type: 'null' };
@@ -128,7 +154,14 @@ function encodeArg(v) {
         return { type: 'blob', base64: bytesToBase64(new Uint8Array(v)) };
     if (v instanceof Uint8Array)
         return { type: 'blob', base64: bytesToBase64(v) };
-    throw new Error(`libsql: unsupported argument type ${typeof v}`);
+    if (v instanceof Date)
+        return { type: 'text', value: v.toISOString() };
+    if (typeof v === 'object' && isJsonEncodable(v))
+        return { type: 'text', value: JSON.stringify(v) };
+    // Name the constructor for objects: "unsupported argument type object" is
+    // what made the missing Date branch so hard to place in the first place.
+    const kind = typeof v === 'object' ? (v.constructor?.name ?? 'object') : typeof v;
+    throw new Error(`libsql: unsupported argument type ${kind}`);
 }
 function decodeValue(v) {
     switch (v.type) {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@pikku/kysely-sqlite",
-  "version": "0.12.8",
+  "version": "0.12.9",
+  "description": "SQLite dialect services and libSQL web dialect for Pikku, backed by Kysely",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/src/index.js",
@@ -10,17 +11,20 @@
     "tsc": "tsc",
     "ncu": "npx npm-check-updates",
     "build": "tsc -b",
+    "test": "bash run-tests.sh",
+    "test:watch": "bash run-tests.sh --watch",
+    "test:coverage": "bash run-tests.sh --coverage",
     "prepublishOnly": "yarn build"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.0",
+    "@pikku/kysely": "^0.13.6",
     "kysely": "^0.29.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.54"
+    "@pikku/core": "^0.12.71"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.54",
+    "@pikku/core": "^0.12.71",
     "typescript": "^6.0.3"
   },
   "exports": {

package/run-tests.sh

@@ -0,0 +1,33 @@
+#!/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
+done
+
+# Build the command
+CMD="node --import tsx --test --test-force-exit src/**/*.test.ts"
+
+if [ "$WATCH_MODE" = true ]; then
+    CMD="$CMD --watch"
+fi
+
+if [ "$COVERAGE_MODE" = true ]; then
+    CMD="$CMD --experimental-test-coverage"
+fi
+
+# Execute the command
+eval $CMD

package/src/libsql-web-dialect.test.ts

@@ -0,0 +1,151 @@
+import { describe, test, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { Kysely } from 'kysely'
+import { LibsqlWebDialect } from './libsql-web-dialect.js'
+
+interface TestDB {
+  entry: {
+    id: string
+    createdAt: string
+    payload: string
+    archived: number
+  }
+}
+
+/** Args of the last `execute` request the dialect put on the wire. */
+let sentArgs: Array<Record<string, unknown>>
+let realFetch: typeof globalThis.fetch
+
+const okResponse = () =>
+  new Response(
+    JSON.stringify({
+      baton: null,
+      base_url: null,
+      results: [
+        {
+          type: 'ok',
+          response: {
+            type: 'execute',
+            result: {
+              cols: [],
+              rows: [],
+              affected_row_count: 1,
+              last_insert_rowid: '1',
+            },
+          },
+        },
+      ],
+    }),
+    { status: 200, headers: { 'content-type': 'application/json' } }
+  )
+
+const db = () =>
+  new Kysely<TestDB>({
+    dialect: new LibsqlWebDialect({ url: 'https://example.turso.io' }),
+  })
+
+describe('LibsqlWebDialect bind-parameter encoding', () => {
+  beforeEach(() => {
+    sentArgs = []
+    realFetch = globalThis.fetch
+    globalThis.fetch = (async (_url: string, init: RequestInit) => {
+      const body = JSON.parse(init.body as string)
+      for (const req of body.requests) {
+        if (req.type === 'execute') sentArgs = req.stmt.args
+      }
+      return okResponse()
+    }) as unknown as typeof globalThis.fetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = realFetch
+  })
+
+  test('encodes a Date as an ISO-8601 text value', async () => {
+    const createdAt = new Date('2026-07-29T21:00:00.000Z')
+    await db()
+      .insertInto('entry')
+      .values({ id: 'a', createdAt: createdAt as never } as never)
+      .execute()
+
+    assert.deepEqual(sentArgs[1], {
+      type: 'text',
+      value: '2026-07-29T21:00:00.000Z',
+    })
+  })
+
+  test('encodes a plain object as JSON text', async () => {
+    await db()
+      .insertInto('entry')
+      .values({ id: 'a', payload: { tags: [1, 2] } as never } as never)
+      .execute()
+
+    assert.deepEqual(sentArgs[1], {
+      type: 'text',
+      value: '{"tags":[1,2]}',
+    })
+  })
+
+  test('encodes an array bound directly as JSON text', async () => {
+    await db()
+      .insertInto('entry')
+      .values({ id: 'a', payload: [1, 2] as never } as never)
+      .execute()
+
+    assert.deepEqual(sentArgs[1], { type: 'text', value: '[1,2]' })
+  })
+
+  test('encodes a null-prototype record as JSON text', async () => {
+    const payload = Object.assign(Object.create(null), { tags: [1] })
+    await db()
+      .insertInto('entry')
+      .values({ id: 'a', payload: payload as never } as never)
+      .execute()
+
+    assert.deepEqual(sentArgs[1], { type: 'text', value: '{"tags":[1]}' })
+  })
+
+  test('keeps the primitive encodings intact', async () => {
+    await db()
+      .insertInto('entry')
+      .values({ id: 'a', archived: true as never } as never)
+      .execute()
+
+    assert.deepEqual(sentArgs, [
+      { type: 'text', value: 'a' },
+      { type: 'integer', value: '1' },
+    ])
+  })
+
+  test('still rejects a value it cannot represent', async () => {
+    await assert.rejects(
+      db()
+        .insertInto('entry')
+        .values({ id: 'a', payload: Symbol('nope') as never } as never)
+        .execute(),
+      /unsupported argument type symbol/
+    )
+  })
+
+  // A Map or a class instance stringifies to "{}" or to a partial view of
+  // itself, so it must fail loudly rather than persist an empty JSON blob.
+  test('rejects an object JSON cannot faithfully represent', async () => {
+    class Money {
+      constructor(public cents: number) {}
+    }
+
+    for (const [value, expected] of [
+      [new Map([['a', 1]]), /unsupported argument type Map/],
+      [/abc/i, /unsupported argument type RegExp/],
+      [new Money(100), /unsupported argument type Money/],
+    ] as const) {
+      await assert.rejects(
+        db()
+          .insertInto('entry')
+          .values({ id: 'a', payload: value as never } as never)
+          .execute(),
+        expected
+      )
+    }
+  })
+})

package/src/libsql-web-dialect.ts

@@ -189,6 +189,32 @@ class LibsqlWebConnection implements DatabaseConnection {
   }
 }
 
+/**
+ * Whether a value is a JSON column's worth of data rather than some other
+ * object that merely happens to be one.
+ *
+ * A `Map`, a `RegExp` or a class instance all stringify to `"{}"` or to a
+ * partial view of themselves, so accepting every object would silently persist
+ * an empty JSON blob where the caller meant something. Those fall through to
+ * the unsupported-type error instead. Kept in lockstep with the `coerce()` in
+ * the CLI's node:sqlite dev runtime (`db/sqlite/sqlite-kysely.ts`).
+ */
+function isJsonEncodable(v: object): boolean {
+  if (Array.isArray(v)) return true
+  const proto = Object.getPrototypeOf(v)
+  return proto === Object.prototype || proto === null
+}
+
+/**
+ * Encodes one Kysely bind parameter as a Hrana value.
+ *
+ * The Date and plain-object branches exist for parity with the `coerce()` in
+ * the CLI's node:sqlite dev runtime (`db/sqlite/sqlite-kysely.ts`). Without
+ * them a query that binds a timestamp or a JSON column passes under
+ * `pikku dev` and throws `unsupported argument type object` once deployed to
+ * a Worker — so every write in a deployed libsql app fails while the same
+ * code works locally.
+ */
 function encodeArg(v: unknown): HranaValue {
   if (v === null || v === undefined) return { type: 'null' }
   if (typeof v === 'string') return { type: 'text', value: v }
@@ -201,7 +227,14 @@ function encodeArg(v: unknown): HranaValue {
   if (v instanceof ArrayBuffer)
     return { type: 'blob', base64: bytesToBase64(new Uint8Array(v)) }
   if (v instanceof Uint8Array) return { type: 'blob', base64: bytesToBase64(v) }
-  throw new Error(`libsql: unsupported argument type ${typeof v}`)
+  if (v instanceof Date) return { type: 'text', value: v.toISOString() }
+  if (typeof v === 'object' && isJsonEncodable(v))
+    return { type: 'text', value: JSON.stringify(v) }
+  // Name the constructor for objects: "unsupported argument type object" is
+  // what made the missing Date branch so hard to place in the first place.
+  const kind =
+    typeof v === 'object' ? (v.constructor?.name ?? 'object') : typeof v
+  throw new Error(`libsql: unsupported argument type ${kind}`)
 }
 
 function decodeValue(v: HranaValue): unknown {