@pikku/kysely-node-sqlite 0.12.4 → 0.12.7

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # @pikku/kysely-node-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
+
+- 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
+  - @pikku/kysely-sqlite@0.12.11
+
 ## 0.12.4
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 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 SqliteFunction, type SqliteFunctionMap, } from '@pikku/kysely-sqlite';
-export { createCoercionPlugin, type CoercionMap, type ColumnKind, type CreateCoercionPluginOptions, } from './coercion-plugin.js';
+export { SqliteFunctionsUnsupportedError, type SqliteFunctionMap, } from '@pikku/kysely-sqlite';
+export { createCoercionPlugin, type ColumnKind, type CoercionMap, type CreateCoercionPluginOptions, } from '@pikku/kysely';

package/dist/src/index.js

@@ -2,4 +2,4 @@ export { NodeSqliteDatabase } from './node-sqlite-adapter.js';
 export { createNodeSqliteKysely, } from './create-node-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/coercion-plugin.ts","../src/create-node-sqlite-kysely.ts","../src/index.ts","../src/node-sqlite-adapter.ts","../src/register-functions.ts"],"version":"6.0.3"}
+{"root":["../src/create-node-sqlite-kysely.ts","../src/index.ts","../src/node-sqlite-adapter.ts","../src/register-functions.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely-node-sqlite",
-  "version": "0.12.4",
+  "version": "0.12.7",
   "description": "Kysely driver for Pikku backed by the built-in node:sqlite module",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -20,20 +20,20 @@
     "node": ">=22.10"
   },
   "dependencies": {
-    "@pikku/kysely": "^0.13.8",
-    "@pikku/kysely-sqlite": "^0.12.10",
-    "kysely": "^0.29.0"
+    "@pikku/kysely": "^0.13.18",
+    "@pikku/kysely-sqlite": "^0.12.13",
+    "kysely": "^0.29.5"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.75"
+    "@pikku/core": "^0.12.86"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.75",
+    "@pikku/core": "^0.12.86",
     "@types/node": "^22",
-    "tsx": "^4.19.2",
+    "tsx": "^4.23.12",
     "typescript": "^6.0.3"
   },
   "exports": {
     ".": "./dist/src/index.js"
   }
-}
+}

package/src/coercion-plugin.test.ts

@@ -0,0 +1,90 @@
+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/index.ts

@@ -6,12 +6,11 @@ export {
 export { registerSqliteFunctions } from './register-functions.js'
 export {
   SqliteFunctionsUnsupportedError,
-  type SqliteFunction,
   type SqliteFunctionMap,
 } from '@pikku/kysely-sqlite'
 export {
   createCoercionPlugin,
-  type CoercionMap,
   type ColumnKind,
+  type CoercionMap,
   type CreateCoercionPluginOptions,
-} from './coercion-plugin.js'
+} from '@pikku/kysely'

package/src/coercion-plugin.ts

@@ -1,92 +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.
- */
-function buildGlobalMap(map: CoercionMap): Record<string, ColumnKind> {
-  const out: Record<string, ColumnKind> = {}
-  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: 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 }
-    },
-  }
-}