@pikku/kysely-bun-sqlite 0.12.4 → 0.12.7

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # @pikku/kysely-bun-sqlite
 
+## 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
+
+- 0686513: Declare `@pikku/core` as a peer dependency, matching `@pikku/kysely-sqlite`.
+
+  The package depends on `@pikku/kysely-sqlite`, which requires `@pikku/core` as a
+  peer, but never declared that requirement itself — so an install resolved
+  without complaint and the missing peer only surfaced at runtime. It is now
+  declared the same way its sibling declares it.
+
+- Updated dependencies [7406bfe]
+- Updated dependencies [6794681]
+- Updated dependencies [a7fcd2e]
+  - @pikku/core@0.12.84
+  - @pikku/kysely@0.13.16
+  - @pikku/kysely-sqlite@0.12.12
+
 ## 0.12.4
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -2,4 +2,4 @@ export { BunSqliteDatabase } from './bun-sqlite-adapter.js';
 export { createBunSqliteKysely, type CreateBunSqliteKyselyOptions, } from './create-bun-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 { BunSqliteDatabase } from './bun-sqlite-adapter.js';
 export { createBunSqliteKysely, } from './create-bun-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/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bun-sqlite-adapter.ts","../src/coercion-plugin.ts","../src/create-bun-sqlite-kysely.ts","../src/index.ts","../src/register-functions.ts"],"version":"6.0.3"}
+{"root":["../src/bun-sqlite-adapter.ts","../src/create-bun-sqlite-kysely.ts","../src/index.ts","../src/register-functions.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely-bun-sqlite",
-  "version": "0.12.4",
+  "version": "0.12.7",
   "description": "Kysely driver for Pikku backed by the built-in bun:sqlite module",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -19,12 +19,16 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.15",
-    "@pikku/kysely-sqlite": "^0.12.11",
-    "kysely": "^0.29.0"
+    "@pikku/kysely": "^0.13.18",
+    "@pikku/kysely-sqlite": "^0.12.13",
+    "kysely": "^0.29.5"
+  },
+  "peerDependencies": {
+    "@pikku/core": "^0.12.86"
   },
   "devDependencies": {
+    "@pikku/core": "^0.12.86",
     "@types/bun": "latest",
     "typescript": "^6.0.3"
   }
-}
+}

package/src/coercion-plugin.test.ts

@@ -1,95 +1,90 @@
 import { describe, test } from 'node:test'
 import assert from 'node:assert/strict'
-import type { QueryResult, UnknownRow } from 'kysely'
-import { createCoercionPlugin } from './coercion-plugin.js'
+import { createBunSqliteKysely, createCoercionPlugin } from './index.js'
+import type { CoercionMap } from './index.js'
+import { sql, type Kysely } from 'kysely'
 
-const runTransform = async (
-  map: Parameters<typeof createCoercionPlugin>[0]['map'],
-  rows: UnknownRow[]
-): Promise<UnknownRow[]> => {
-  const plugin = createCoercionPlugin({ map })
-  const result = { rows } as QueryResult<UnknownRow>
-  const out = await plugin.transformResult({
-    result,
-    queryId: { queryId: 'test' },
-  } as Parameters<NonNullable<typeof plugin.transformResult>>[0])
-  return out.rows as UnknownRow[]
+interface TestDB {
+  users: { id: number; settings: unknown }
+  posts: { id: number; settings: unknown }
 }
 
-describe('createCoercionPlugin', () => {
-  test('transformQuery passes the node through untouched', () => {
-    const plugin = createCoercionPlugin({ map: {} })
-    const node = { kind: 'SelectQueryNode' } as any
-    assert.equal(
-      plugin.transformQuery({ node, queryId: { queryId: 'x' } } as any),
-      node
-    )
-  })
+/**
+ * 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' },
+}
 
-  test('coerces date columns from ISO strings to Date', async () => {
-    const [row] = await runTransform({ users: { created_at: 'date' } }, [
-      { created_at: '2026-06-26T00:00:00.000Z' },
-    ])
-    assert.ok(row.created_at instanceof Date)
-    assert.equal(
-      (row.created_at as Date).toISOString(),
-      '2026-06-26T00:00:00.000Z'
-    )
-  })
+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)
+}
 
-  test('leaves unparseable date strings untouched', async () => {
-    const [row] = await runTransform({ users: { created_at: 'date' } }, [
-      { created_at: 'not-a-date' },
-    ])
-    assert.equal(row.created_at, 'not-a-date')
-  })
+describe('bun-sqlite coercion plugin', () => {
+  test('resolves a colliding column against the queried table', async () => {
+    const db = createBunSqliteKysely<TestDB>({
+      filename: ':memory:',
+      plugins: [createCoercionPlugin({ map })],
+    })
+    await seed(db)
 
-  test('coerces bool columns from 0/1 numbers and bigints', async () => {
-    const rows = await runTransform(
-      { users: { is_active: 'bool', has_pets: 'bool' } },
-      [{ is_active: 1, has_pets: 0n }]
-    )
-    assert.equal(rows[0].is_active, true)
-    assert.equal(rows[0].has_pets, false)
-  })
+    const user = await db
+      .selectFrom('users')
+      .select('settings')
+      .executeTakeFirstOrThrow()
+    assert.deepEqual(user.settings, { theme: 'dark' })
 
-  test('parses json columns and tolerates invalid json', async () => {
-    const rows = await runTransform(
-      { users: { meta: 'json', broken: 'json' } },
-      [{ meta: '{"a":1}', broken: '{bad' }]
-    )
-    assert.deepEqual(rows[0].meta, { a: 1 })
-    assert.equal(rows[0].broken, '{bad')
-  })
+    const post = await db
+      .selectFrom('posts')
+      .select('settings')
+      .executeTakeFirstOrThrow()
+    assert.equal(post.settings, true)
 
-  test('passes through null values and unmapped columns', async () => {
-    const rows = await runTransform({ users: { created_at: 'date' } }, [
-      { created_at: null, name: 'leave me' },
-    ])
-    assert.equal(rows[0].created_at, null)
-    assert.equal(rows[0].name, 'leave me')
+    await db.destroy()
   })
 
-  test('matches both snake_case and camelCase column names', async () => {
-    const rows = await runTransform({ users: { created_at: 'date' } }, [
-      { createdAt: '2026-06-26T00:00:00.000Z' },
-    ])
-    assert.ok(rows[0].createdAt instanceof Date)
-  })
-
-  test('leaves columns ambiguous across tables uncoerced', async () => {
-    const rows = await runTransform(
-      { users: { value: 'json' }, events: { value: 'bool' } },
-      [{ value: '{"a":1}' }]
+  test('coerces date, bool and json columns read back from SQLite', async () => {
+    const db = createBunSqliteKysely<{
+      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
     )
-    assert.equal(rows[0].value, '{"a":1}')
-  })
-
-  test('still coerces columns that agree across tables', async () => {
-    const rows = await runTransform(
-      { users: { active: 'bool' }, events: { active: 'bool' } },
-      [{ active: 1 }]
+    await sql`insert into rows values ('2026-06-26T00:00:00.000Z', 0, '{"a":1}')`.execute(
+      db
     )
-    assert.equal(rows[0].active, true)
+
+    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/index.ts

@@ -11,5 +11,6 @@ export {
 export {
   createCoercionPlugin,
   type ColumnKind,
+  type CoercionMap,
   type CreateCoercionPluginOptions,
-} from './coercion-plugin.js'
+} from '@pikku/kysely'

package/src/coercion-plugin.ts

@@ -1,106 +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.
- *
- * When two tables disagree on the kind for the same column name, the column
- * is ambiguous (a joined/aliased query could carry either) and is left
- * uncoerced rather than letting whichever table was processed last win.
- */
-function buildGlobalMap(map: CoercionMap): Record<string, ColumnKind> {
-  const out: Record<string, ColumnKind> = {}
-  const ambiguous = new Set<string>()
-  const assign = (key: string, kind: ColumnKind) => {
-    const existing = out[key]
-    if (existing !== undefined && existing !== kind) {
-      ambiguous.add(key)
-      return
-    }
-    out[key] = kind
-  }
-  for (const tbl of Object.values(map)) {
-    for (const [col, kind] of Object.entries(tbl)) {
-      assign(col, kind)
-      assign(snakeToCamel(col), kind)
-    }
-  }
-  for (const key of ambiguous) delete out[key]
-  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 }
-    },
-  }
-}