@pikku/kysely-sqlite 0.12.13 → 0.12.14

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @pikku/kysely-sqlite
 
+## 0.12.14
+
+### 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
+
 ## 0.12.13
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@pikku/kysely-sqlite",
-  "version": "0.12.13",
+  "version": "0.12.14",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/services/kysely-sqlite"
+  },
   "description": "SQLite dialect services and libSQL web dialect for Pikku, backed by Kysely",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -14,20 +19,19 @@
     "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"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.17",
+    "@pikku/kysely": "^0.13.25",
     "kysely": "^0.29.5"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.85"
+    "@pikku/core": "^0.12.108"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.85",
-    "typescript": "^6.0.3"
+    "@pikku/core": "^0.12.108"
   },
   "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/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"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-agent-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/src/create-sqlite-kysely.ts

@@ -1,12 +0,0 @@
-import { Kysely, SqliteDialect, type SqliteDatabase } from 'kysely'
-import { SerializePlugin } from '@pikku/kysely'
-import type { KyselyPikkuDB } from '@pikku/kysely'
-
-export function createSQLiteKysely(
-  database: SqliteDatabase | (() => Promise<SqliteDatabase>)
-): Kysely<KyselyPikkuDB> {
-  return new Kysely<KyselyPikkuDB>({
-    dialect: new SqliteDialect({ database }),
-    plugins: [new SerializePlugin()],
-  })
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-export { createSQLiteKysely } from './create-sqlite-kysely.js'
-export { SQLiteKyselyWorkflowService } from './sqlite-kysely-workflow-service.js'
-export { SQLiteKyselyDeploymentService } from './sqlite-kysely-deployment-service.js'
-export { SQLiteKyselyAgentStorageService } from './sqlite-kysely-agent-storage-service.js'
-export { SQLiteKyselyAgentRunService } from './sqlite-kysely-agent-run-service.js'
-export { SQLiteKyselyWorkflowRunService } from './sqlite-kysely-workflow-run-service.js'
-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 { KyselyPikkuDB } from '@pikku/kysely'
-export type { WorkflowRunService } from '@pikku/core/workflow'
-export type { AgentRunService, AgentRunRow } from '@pikku/core/agent'

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

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

@@ -1,282 +0,0 @@
-import {
-  SqliteAdapter,
-  SqliteIntrospector,
-  SqliteQueryCompiler,
-  type DatabaseConnection,
-  type Dialect,
-  type Driver,
-  type CompiledQuery,
-  type QueryResult,
-  type Kysely,
-  type DatabaseIntrospector,
-  type DialectAdapter,
-  type QueryCompiler,
-} from 'kysely'
-
-/**
- * Kysely dialect for libsql over the *HTTP pipeline* transport (v2/pipeline).
- *
- * Why this file exists at all:
- *   - @libsql/kysely-libsql imports @libsql/client (Node), which uses node:http.
- *     CF Workers nodejs_compat_v2 doesn't ship node:http -> upload error 10021.
- *   - @libsql/client/web imports both ./http.js and ./ws.js at module top, and
- *     ./ws.js pulls in `ws` which does `require('node:events')` at load time.
- *     CF Workers also doesn't ship node:events -> upload error 10021.
- *   - @libsql/client/http re-uses @libsql/hrana-client's index which still
- *     imports ws transitively for the same reason.
- *
- * So we talk to the libsql/Turso HTTP pipeline directly with fetch. Single
- * endpoint, single round-trip per execute. Transactions use the `baton`
- * mechanism: every response returns a baton, and resending it on the next
- * request keeps the same server-side stream (== same SQL connection ==
- * same transaction).
- *
- * Pipeline reference: https://github.com/tursodatabase/libsql/blob/main/docs/HTTP_V2_SPEC.md
- */
-export interface LibsqlWebDialectConfig {
-  url: string
-  authToken?: string
-}
-
-export class LibsqlWebDialect implements Dialect {
-  constructor(private readonly config: LibsqlWebDialectConfig) {}
-  createAdapter(): DialectAdapter {
-    return new SqliteAdapter()
-  }
-  createDriver(): Driver {
-    return new LibsqlWebDriver(this.config)
-  }
-  createQueryCompiler(): QueryCompiler {
-    return new SqliteQueryCompiler()
-  }
-  createIntrospector(db: Kysely<unknown>): DatabaseIntrospector {
-    return new SqliteIntrospector(db)
-  }
-}
-
-type HranaValue =
-  | { type: 'null' }
-  | { type: 'integer'; value: string }
-  | { type: 'float'; value: number }
-  | { type: 'text'; value: string }
-  | { type: 'blob'; base64: string }
-
-interface HranaStmtResult {
-  cols: Array<{ name: string | null; decltype: string | null }>
-  rows: HranaValue[][]
-  affected_row_count: number
-  last_insert_rowid: string | null
-}
-
-interface PipelineResponse {
-  baton: string | null
-  base_url: string | null
-  results: Array<
-    | {
-        type: 'ok'
-        response:
-          { type: 'execute'; result: HranaStmtResult } | { type: 'close' }
-      }
-    | { type: 'error'; error: { message: string; code?: string } }
-  >
-}
-
-class LibsqlWebDriver implements Driver {
-  private readonly endpoint: string
-  private readonly authHeader: string | undefined
-  constructor(config: LibsqlWebDialectConfig) {
-    // Accept libsql://, https://, http://. The pipeline is HTTP only.
-    // Turso embeds the JWT in the URL as ?authToken=... — honor that, but let
-    // an explicit config.authToken win.
-    const u = new URL(config.url)
-    const scheme = u.protocol === 'libsql:' ? 'https:' : u.protocol
-    const tokenFromUrl = u.searchParams.get('authToken') ?? undefined
-    this.endpoint = `${scheme}//${u.host}/v2/pipeline`
-    const token = config.authToken ?? tokenFromUrl
-    this.authHeader = token ? `Bearer ${token}` : undefined
-  }
-  async init(): Promise<void> {}
-  async acquireConnection(): Promise<DatabaseConnection> {
-    return new LibsqlWebConnection(this.endpoint, this.authHeader)
-  }
-  async beginTransaction(conn: DatabaseConnection): Promise<void> {
-    await (conn as LibsqlWebConnection).executeRaw('BEGIN')
-  }
-  async commitTransaction(conn: DatabaseConnection): Promise<void> {
-    await (conn as LibsqlWebConnection).executeRaw('COMMIT')
-  }
-  async rollbackTransaction(conn: DatabaseConnection): Promise<void> {
-    await (conn as LibsqlWebConnection).executeRaw('ROLLBACK')
-  }
-  async releaseConnection(conn: DatabaseConnection): Promise<void> {
-    await (conn as LibsqlWebConnection).close()
-  }
-  async destroy(): Promise<void> {}
-}
-
-class LibsqlWebConnection implements DatabaseConnection {
-  private baton: string | null = null
-  private endpoint: string
-  constructor(
-    initialEndpoint: string,
-    private readonly authHeader: string | undefined
-  ) {
-    this.endpoint = initialEndpoint
-  }
-
-  async executeQuery<R>(query: CompiledQuery): Promise<QueryResult<R>> {
-    const result = await this.runStmt(query.sql, query.parameters)
-    return decodeResult<R>(result)
-  }
-
-  async *streamQuery<R>(
-    query: CompiledQuery
-  ): AsyncIterableIterator<QueryResult<R>> {
-    yield this.executeQuery<R>(query)
-  }
-
-  async executeRaw(sql: string): Promise<void> {
-    await this.runStmt(sql, [])
-  }
-
-  async close(): Promise<void> {
-    if (this.baton === null) return
-    await this.send([{ type: 'close' }])
-    this.baton = null
-  }
-
-  private async runStmt(
-    sql: string,
-    args: readonly unknown[]
-  ): Promise<HranaStmtResult> {
-    const resp = await this.send([
-      {
-        type: 'execute',
-        stmt: { sql, args: args.map(encodeArg) },
-      },
-    ])
-    const r = resp.results[0]
-    if (!r) throw new Error('libsql: empty pipeline response')
-    if (r.type === 'error')
-      throw new Error(
-        `libsql: ${r.error.message}${r.error.code ? ` (${r.error.code})` : ''}`
-      )
-    if (r.response.type !== 'execute')
-      throw new Error(`libsql: unexpected response type ${r.response.type}`)
-    return r.response.result
-  }
-
-  private async send(requests: unknown[]): Promise<PipelineResponse> {
-    const headers: Record<string, string> = {
-      'content-type': 'application/json',
-    }
-    if (this.authHeader) headers.authorization = this.authHeader
-    const res = await fetch(this.endpoint, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ baton: this.baton, requests }),
-    })
-    if (!res.ok) {
-      const body = await res.text().catch(() => '')
-      throw new Error(`libsql HTTP ${res.status}: ${body}`)
-    }
-    const json = (await res.json()) as PipelineResponse
-    this.baton = json.baton
-    if (json.base_url)
-      this.endpoint = `${json.base_url.replace(/\/$/, '')}/v2/pipeline`
-    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: 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 }
-  if (typeof v === 'number')
-    return Number.isInteger(v)
-      ? { type: 'integer', value: String(v) }
-      : { type: 'float', value: v }
-  if (typeof v === 'bigint') return { type: 'integer', value: v.toString() }
-  if (typeof v === 'boolean') return { type: 'integer', value: v ? '1' : '0' }
-  if (v instanceof ArrayBuffer)
-    return { type: 'blob', base64: bytesToBase64(new Uint8Array(v)) }
-  if (v instanceof Uint8Array) return { type: 'blob', base64: bytesToBase64(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 {
-  switch (v.type) {
-    case 'null':
-      return null
-    case 'integer': {
-      const n = Number(v.value)
-      return Number.isSafeInteger(n) ? n : BigInt(v.value)
-    }
-    case 'float':
-      return v.value
-    case 'text':
-      return v.value
-    case 'blob':
-      return base64ToBytes(v.base64)
-  }
-}
-
-function decodeResult<R>(r: HranaStmtResult): QueryResult<R> {
-  const colNames = r.cols.map((c, i) => c.name ?? `c${i}`)
-  const rows = r.rows.map((row) => {
-    const o: Record<string, unknown> = {}
-    for (let i = 0; i < colNames.length; i++)
-      o[colNames[i]!] = decodeValue(row[i]!)
-    return o as R
-  })
-  return {
-    rows,
-    numAffectedRows: BigInt(r.affected_row_count),
-    insertId:
-      r.last_insert_rowid !== null ? BigInt(r.last_insert_rowid) : undefined,
-  }
-}
-
-function bytesToBase64(b: Uint8Array): string {
-  let s = ''
-  for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i]!)
-  return btoa(s)
-}
-function base64ToBytes(s: string): Uint8Array {
-  const bin = atob(s)
-  const out = new Uint8Array(bin.length)
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
-  return out
-}

package/src/sqlite-functions.ts

@@ -1,47 +0,0 @@
-/**
- * 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'
-  }
-}

package/src/sqlite-kysely-agent-run-service.ts

@@ -1,3 +0,0 @@
-import { KyselyAgentRunService } from '@pikku/kysely'
-
-export class SQLiteKyselyAgentRunService extends KyselyAgentRunService {}

package/src/sqlite-kysely-agent-storage-service.ts

@@ -1,3 +0,0 @@
-import { KyselyAgentStorageService } from '@pikku/kysely'
-
-export class SQLiteKyselyAgentStorageService extends KyselyAgentStorageService {}

package/src/sqlite-kysely-channel-store.ts

@@ -1,3 +0,0 @@
-import { KyselyChannelStore } from '@pikku/kysely'
-
-export class SQLiteKyselyChannelStore extends KyselyChannelStore {}

package/src/sqlite-kysely-deployment-service.ts

@@ -1,3 +0,0 @@
-import { KyselyDeploymentService } from '@pikku/kysely'
-
-export class SQLiteKyselyDeploymentService extends KyselyDeploymentService {}

package/src/sqlite-kysely-eventhub-store.ts

@@ -1,3 +0,0 @@
-import { KyselyEventHubStore } from '@pikku/kysely'
-
-export class SQLiteKyselyEventHubStore extends KyselyEventHubStore {}

package/src/sqlite-kysely-secret-service.ts

@@ -1,3 +0,0 @@
-import { KyselySecretService } from '@pikku/kysely'
-
-export class SQLiteKyselySecretService extends KyselySecretService {}

package/src/sqlite-kysely-workflow-run-service.ts

@@ -1,3 +0,0 @@
-import { KyselyWorkflowRunService } from '@pikku/kysely'
-
-export class SQLiteKyselyWorkflowRunService extends KyselyWorkflowRunService {}

package/src/sqlite-kysely-workflow-service.ts

@@ -1,3 +0,0 @@
-import { KyselyWorkflowService } from '@pikku/kysely'
-
-export class SQLiteKyselyWorkflowService extends KyselyWorkflowService {}

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