@dockstat/sqlite-wrapper 1.3.5 → 1.3.6

package/README.md

@@ -22,7 +22,7 @@ Schema-first table helpers, an expressive chainable QueryBuilder, safe defaults
 ### Bug Fixes
 
 - **Fixed Boolean parsing** — Boolean columns now correctly convert SQLite's `0`/`1` to JavaScript `true`/`false`
-- **Fixed Wrong packing** — Before the `publish` script was added, workspace dependencies were not correctly propagated
+- **Fixed incorrect packaging** — Before the `publish` script was added, workspace dependencies were not correctly propagated
 
 ### Architecture Improvements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dockstat/sqlite-wrapper",
-  "version": "1.3.5",
+  "version": "1.3.6",
   "description": "A TypeScript wrapper around bun:sqlite with type-safe query building",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -18,9 +18,9 @@ import type {
   ColumnDefinition,
   IndexColumn,
   IndexMethod,
+  MigrationOptions,
   Parser,
   TableOptions,
-  MigrationOptions,
 } from "./types"
 import { createLogger, type SqliteLogger } from "./utils"
 
@@ -220,6 +220,23 @@ class DB {
     }
   }
 
+  private normalizeMigrationOptions(migrate: TableOptions<Record<string, unknown>>["migrate"]): {
+    enabled: boolean
+    options: MigrationOptions
+  } {
+    if (migrate === false) return { enabled: false, options: {} }
+    if (migrate && typeof migrate === "object") {
+      return { enabled: true, options: migrate }
+    }
+    return { enabled: true, options: {} }
+  }
+
+  private shouldCheckExistingTable<_T>(tableName: string, options?: TableOptions<_T>): boolean {
+    if (options?.temporary) return false
+    if (tableName === ":memory:") return false
+    return true
+  }
+
   /**
    * Create a table with comprehensive type safety and feature support.
    *
@@ -234,20 +251,15 @@ class DB {
     columns: Record<keyof _T, ColumnDefinition>,
     options?: TableOptions<_T>
   ): QueryBuilder<_T> {
-    // Handle migration if enabled (default: true)
-    const migrateOption = options?.migrate !== undefined ? options.migrate : true
+    const { enabled: migrateEnabled, options: migrationOptions } = this.normalizeMigrationOptions(
+      options?.migrate
+    )
 
-    // Check if table already exists
     const tableAlreadyExists =
-      !options?.temporary && tableName !== ":memory:" && tableExists(this.db, tableName)
+      this.shouldCheckExistingTable(tableName, options) && tableExists(this.db, tableName)
 
     if (tableAlreadyExists) {
-      if (migrateOption !== false) {
-        // Migration is enabled, check if we need to migrate
-        const migrationOptions: MigrationOptions =
-          typeof migrateOption === "object" ? migrateOption : {}
-
-        // Build table constraints to pass to migration
+      if (migrateEnabled) {
         let tableConstraints: string[] = []
         if (isTableSchema(columns) && options?.constraints) {
           tableConstraints = buildTableConstraints(options.constraints)
@@ -263,21 +275,16 @@ class DB {
         )
 
         if (migrated) {
-          // Table was migrated, skip creation and go directly to parser setup
           return this._setupTableParser(tableName, columns, options)
         }
       }
 
-      // Table exists and either:
-      // 1. Migration is disabled, or
-      // 2. Migration is enabled but no changes were needed
-      // In both cases, return the existing table without trying to create it
       if (!options?.ifNotExists) {
         return this._setupTableParser(tableName, columns, options)
       }
     }
 
-    const temp = options?.temporary ? "TEMPORARY " : tableName === ":memory" ? "TEMPORARY " : ""
+    const temp = options?.temporary ? "TEMPORARY " : tableName === ":memory:" ? "TEMPORARY " : ""
     const ifNot = options?.ifNotExists ? "IF NOT EXISTS " : ""
     const withoutRowId = options?.withoutRowId ? " WITHOUT ROWID" : ""
 

package/src/migration.ts

@@ -1,36 +1,15 @@
 import type { Database } from "bun:sqlite"
-import type { ColumnDefinition, MigrationOptions } from "./types"
 import { buildColumnSQL } from "./lib/table/buildColumnSQL"
+import type {
+  ColumnDefinition,
+  ForeignKeyInfo,
+  ForeignKeyStatus,
+  IndexInfo,
+  MigrationOptions,
+  TableColumn,
+} from "./types"
 import { SqliteLogger } from "./utils/logger"
 
-export interface TableColumn {
-  cid: number
-  name: string
-  type: string
-  notnull: number
-  dflt_value: string | number | null
-  pk: number
-}
-
-export interface IndexInfo {
-  name: string
-  sql: string | null
-  unique: boolean
-  origin: string
-  partial: number
-}
-
-export interface ForeignKeyInfo {
-  id: number
-  seq: number
-  table: string
-  from: string
-  to: string
-  on_update: string
-  on_delete: string
-  match: string
-}
-
 /**
  * Get the current schema of a table
  */
@@ -59,10 +38,6 @@ export function getTableIndexes(db: Database, tableName: string): IndexInfo[] {
   const indexes = stmt.all() as PragmaIndex[]
 
   return indexes.map((idx) => {
-    const infoStmt = db.prepare(`PRAGMA index_info("${idx.name}")`)
-    infoStmt.all() // Execute but don't need the result for this use case
-
-    // Get the CREATE INDEX statement if available
     const sqlStmt = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?`)
     const sqlResult = sqlStmt.get(idx.name) as SqliteMasterRow | null
 
@@ -120,7 +95,9 @@ export function schemasAreDifferent(
 
   // Check if column count differs
   if (currentColumnNames.size !== newColumnNames.size) {
-    logger.info("Column count differs")
+    logger.info(
+      `Column count differs (current: ${currentColumnNames.size} [${Array.from(currentColumnNames).join(", ")}], new: ${newColumnNames.size} [${Array.from(newColumnNames).join(", ")}])`
+    )
     return true
   }
 
@@ -229,26 +206,31 @@ export function migrateTable(
   newColumns: Record<string, ColumnDefinition>,
   options: MigrationOptions = {},
   tableConstraints: string[] = [],
-  migrationLog: SqliteLogger
+  migrationLog: SqliteLogger,
+  currentSchema?: TableColumn[]
 ): void {
   const { preserveData = true, onConflict = "fail", tempTableSuffix = "_migration_temp" } = options
 
   migrationLog.info(`Starting migration for table: ${tableName}`)
 
   // Get current table info
-  const currentSchema = getTableColumns(db, tableName)
+  const effectiveSchema = currentSchema ?? getTableColumns(db, tableName)
   const indexes = getTableIndexes(db, tableName)
   const triggers = getTableTriggers(db, tableName)
 
   // Check if migration is needed
-  if (!schemasAreDifferent(currentSchema, newColumns, migrationLog)) {
+  if (!schemasAreDifferent(effectiveSchema, newColumns, migrationLog)) {
     migrationLog.info(`No migration needed for table: ${tableName}`)
     return
   }
 
   const tempTableName = `${tableName}${tempTableSuffix}`
 
-  // Start transaction for atomic migration
+  const fkStatus = db.prepare("PRAGMA foreign_keys").get() as ForeignKeyStatus | null
+  if (fkStatus && fkStatus.foreign_keys === 1) {
+    db.run("PRAGMA foreign_keys = OFF")
+  }
+
   db.transaction(() => {
     try {
       // Step 1: Create temporary table with new schema
@@ -270,8 +252,8 @@ export function migrateTable(
       db.run(createTempTableSql)
 
       // Step 2: Copy data if requested
-      if (preserveData && currentSchema.length > 0) {
-        const { selectColumns, insertColumns } = generateColumnMapping(currentSchema, newColumns)
+      if (preserveData && effectiveSchema.length > 0) {
+        const { selectColumns, insertColumns } = generateColumnMapping(effectiveSchema, newColumns)
 
         if (selectColumns.length > 0) {
           migrationLog.debug(`Copying data from ${tableName} to ${tempTableName}`)
@@ -297,15 +279,6 @@ export function migrateTable(
       // Step 3: Drop the original table
       migrationLog.debug(`Dropping original table: ${tableName}`)
 
-      // Temporarily disable foreign key constraints
-      interface ForeignKeyStatus {
-        foreign_keys: number
-      }
-      const fkStatus = db.prepare("PRAGMA foreign_keys").get() as ForeignKeyStatus | null
-      if (fkStatus && fkStatus.foreign_keys === 1) {
-        db.run("PRAGMA foreign_keys = OFF")
-      }
-
       db.run(`DROP TABLE "${tableName}"`)
 
       // Step 4: Rename temporary table to original name
@@ -335,9 +308,6 @@ export function migrateTable(
       }
 
       // Re-enable foreign key constraints if they were enabled
-      if (fkStatus && fkStatus.foreign_keys === 1) {
-        db.run("PRAGMA foreign_keys = ON")
-      }
 
       migrationLog.info(`Successfully migrated table: ${tableName}`)
     } catch (error) {
@@ -345,6 +315,10 @@ export function migrateTable(
       throw error
     }
   })()
+
+  if (fkStatus && fkStatus.foreign_keys === 1) {
+    db.run("PRAGMA foreign_keys = ON")
+  }
 }
 
 /**
@@ -361,13 +335,13 @@ export function checkAndMigrate(
   const logger = new SqliteLogger(tableName, migrationLog.getBaseLogger())
 
   if (!tableExists(db, tableName)) {
-    return false // No existing table, no migration needed
+    return false
   }
 
   const currentSchema = getTableColumns(db, tableName)
 
   if (schemasAreDifferent(currentSchema, newColumns, logger)) {
-    migrateTable(db, tableName, newColumns, options, tableConstraints, migrationLog)
+    migrateTable(db, tableName, newColumns, options, tableConstraints, migrationLog, currentSchema)
     return true
   }
 

package/src/types.ts

@@ -240,8 +240,6 @@ export interface TableConstraints<T> {
 export interface MigrationOptions {
   /** Whether to preserve data during migration (default: true) */
   preserveData?: boolean
-  /** Whether to drop columns not in new schema (default: true) */
-  dropMissingColumns?: boolean
   /** How to handle constraint violations during data copy */
   onConflict?: "fail" | "ignore" | "replace"
   /** Suffix for temporary table during migration (default: '_migration_temp') */
@@ -630,3 +628,35 @@ export type SqlParameter = SQLQueryBindings
  * Database row with unknown structure
  */
 export type DatabaseRowData = Record<string, SQLQueryBindings>
+
+export interface TableColumn {
+  cid: number
+  name: string
+  type: string
+  notnull: number
+  dflt_value: string | number | null
+  pk: number
+}
+
+export interface IndexInfo {
+  name: string
+  sql: string | null
+  unique: boolean
+  origin: string
+  partial: number
+}
+
+export interface ForeignKeyInfo {
+  id: number
+  seq: number
+  table: string
+  from: string
+  to: string
+  on_update: string
+  on_delete: string
+  match: string
+}
+
+export interface ForeignKeyStatus {
+  foreign_keys: number
+}