@pikku/migrator-sql 0.12.2 → 0.12.4

package/src/sqlite/sqlite-runtime-node.ts

@@ -0,0 +1,118 @@
+import type {
+  SqliteRuntime,
+  SyncSqliteChanges,
+  SyncSqliteDatabase,
+  SyncSqliteStatement,
+} from './sqlite-runtime.js'
+
+interface NodeSqliteStatementShape {
+  reader?: boolean
+  all(...parameters: unknown[]): unknown[]
+  get(...parameters: unknown[]): unknown
+  iterate(...parameters: unknown[]): IterableIterator<unknown>
+  run(...parameters: unknown[]): {
+    changes: number | bigint
+    lastInsertRowid: number | bigint
+  }
+}
+
+interface NodeSqliteDatabaseShape {
+  exec(sql: string): void
+  prepare(sql: string): NodeSqliteStatementShape
+  close(): void
+}
+
+interface NodeSqliteModule {
+  DatabaseSync: new (filename?: string) => NodeSqliteDatabaseShape
+}
+
+class NodeSqliteStatement implements SyncSqliteStatement {
+  readonly reader: boolean
+
+  constructor(
+    private readonly stmt: NodeSqliteStatementShape,
+    sql: string
+  ) {
+    // node:sqlite StatementSync does not have a .reader property
+    // (that's a better-sqlite3 API). Fall back to SQL inspection when absent.
+    if (stmt.reader !== undefined) {
+      this.reader = Boolean(stmt.reader)
+    } else {
+      const upper = sql.trimStart().toUpperCase()
+      this.reader =
+        upper.startsWith('SELECT') ||
+        upper.startsWith('WITH') ||
+        upper.startsWith('PRAGMA') ||
+        upper.startsWith('EXPLAIN') ||
+        upper.startsWith('VALUES') ||
+        /\bRETURNING\b/.test(upper)
+    }
+  }
+
+  all(...parameters: unknown[]): unknown[] {
+    return this.stmt.all(...parameters) as unknown[]
+  }
+
+  get(...parameters: unknown[]): unknown | null {
+    return (this.stmt.get(...parameters) as unknown) ?? null
+  }
+
+  iterate(...parameters: unknown[]): IterableIterator<unknown> {
+    return this.stmt.iterate(...parameters) as IterableIterator<unknown>
+  }
+
+  run(...parameters: unknown[]): SyncSqliteChanges {
+    const result = this.stmt.run(...parameters)
+    return {
+      changes: result.changes,
+      lastInsertRowid: result.lastInsertRowid,
+    }
+  }
+}
+
+class NodeSqliteDatabase implements SyncSqliteDatabase {
+  constructor(private readonly db: NodeSqliteDatabaseShape) {}
+
+  exec(sql: string): void {
+    this.db.exec(sql)
+  }
+
+  prepare(sql: string): SyncSqliteStatement {
+    return new NodeSqliteStatement(this.db.prepare(sql), sql)
+  }
+
+  close(): void {
+    this.db.close()
+  }
+}
+
+async function importNodeSqlite(): Promise<NodeSqliteModule> {
+  const dynamicImport = new Function(
+    'return import("node:sqlite")'
+  ) as () => Promise<NodeSqliteModule>
+  try {
+    return await dynamicImport()
+  } catch (error: any) {
+    // node ships node:sqlite unflagged only from 24. The raw failure is
+    // ERR_UNKNOWN_BUILTIN_MODULE, which reads like a broken install rather than
+    // a runtime that is simply too old — so say which it is and how to get past it.
+    if (error?.code === 'ERR_UNKNOWN_BUILTIN_MODULE') {
+      throw new Error(
+        `This needs node:sqlite, which Node ${process.versions.node} does not provide ` +
+          `(it is unflagged from Node 24). Either upgrade Node, or run the CLI on bun, ` +
+          `which has it: \`bunx --bun pikku <command>\`.`,
+        { cause: error }
+      )
+    }
+    throw error
+  }
+}
+
+export async function createNodeSqliteRuntime(): Promise<SqliteRuntime> {
+  const { DatabaseSync } = await importNodeSqlite()
+  return {
+    open(filename) {
+      return new NodeSqliteDatabase(new DatabaseSync(filename))
+    },
+  }
+}

package/src/sqlite/sqlite-runtime.ts

@@ -0,0 +1,41 @@
+export interface SyncSqliteChanges {
+  changes: number | bigint
+  lastInsertRowid: number | bigint
+}
+
+export interface SyncSqliteStatement {
+  reader: boolean
+  all(...parameters: unknown[]): unknown[]
+  get(...parameters: unknown[]): unknown | null
+  iterate(...parameters: unknown[]): IterableIterator<unknown>
+  run(...parameters: unknown[]): SyncSqliteChanges
+}
+
+export interface SyncSqliteDatabase {
+  exec(sql: string): void
+  prepare(sql: string): SyncSqliteStatement
+  close(): void
+}
+
+export interface SqliteRuntime {
+  open(filename: string): SyncSqliteDatabase
+}
+
+let runtimePromise: Promise<SqliteRuntime> | undefined
+
+export async function loadSqliteRuntime(): Promise<SqliteRuntime> {
+  runtimePromise ??= (async () => {
+    const isBunRuntime =
+      typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'
+
+    if (isBunRuntime) {
+      const { bunSqliteRuntime } = await import('./sqlite-runtime-bun.js')
+      return bunSqliteRuntime
+    }
+
+    const { createNodeSqliteRuntime } = await import('./sqlite-runtime-node.js')
+    return createNodeSqliteRuntime()
+  })()
+
+  return runtimePromise
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "types": ["node", "bun"],
+    "module": "Node18",
+    "outDir": "dist",
+    "target": "esnext",
+    "declaration": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "node_modules"]
+}