@omg-dev/server 0.4.24

package/src/migrator.ts

@@ -0,0 +1,167 @@
+import type { Database } from "bun:sqlite"
+import { schemaDiff, schemaToSQL, type Schema, type CollectionConfig } from "@omg-dev/schema"
+import { markScoped } from "./db.ts"
+
+// ── migrate ───────────────────────────────────────────────────────────────────
+
+/**
+ * Register which tables are user-scoped so db.ts filters by _owner.
+ * MUST be called at runtime even when migrations are skipped — otherwise
+ * scoped collections silently leak data across users.
+ */
+export function registerScopes(schema: Schema): void {
+  for (const [tableName, col] of Object.entries(schema.collections)) {
+    if ((col as CollectionConfig).scope === "user") {
+      markScoped(tableName)
+    }
+  }
+}
+
+export function migrate(bunDb: Database, schema: Schema): void {
+  console.log("[vibes:migrator] Running migrations...")
+
+  registerScopes(schema)
+
+  // Read existing tables from sqlite_master
+  const existingTablesResult = bunDb
+    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+    .all() as { name: string }[]
+
+  const existingTableNames = new Set(existingTablesResult.map(r => r.name))
+
+  // Build old schema from existing DB structure
+  const oldCollections: Record<string, {
+    fields: Record<string, { type: "string" }>
+    scope: "global"
+    indexes: never[]
+    uniqueIndexes: never[]
+  }> = {}
+  for (const tableName of existingTableNames) {
+    const columns = bunDb
+      .prepare(`PRAGMA table_info(${tableName})`)
+      .all() as { name: string; type: string }[]
+
+    const userFields: Record<string, { type: "string" }> = {}
+    for (const col of columns) {
+      if (["id", "created_at", "updated_at", "_owner"].includes(col.name)) continue
+      userFields[col.name] = { type: "string" }
+    }
+    oldCollections[tableName] = {
+      fields: userFields,
+      scope: "global",
+      indexes: [],
+      uniqueIndexes: [],
+    }
+  }
+
+  const oldSchema: Schema = { collections: oldCollections }
+
+  // If no existing tables, just run the full CREATE TABLE statements
+  if (existingTableNames.size === 0) {
+    const sqls = schemaToSQL(schema)
+    for (const sql of sqls) {
+      console.log(`[vibes:migrator] Executing: ${sql.split("\n")[0]}...`)
+      bunDb.exec(sql)
+    }
+    console.log("[vibes:migrator] Initial migration complete.")
+    return
+  }
+
+  // Ensure the implicit `_owner` column exists on any pre-existing table that
+  // is now scope:"user". `_owner` is NOT a declared field, so schemaDiff never
+  // emits an add_column for it — yet schemaToSQL adds it on fresh CREATEs. A
+  // table first created while global (no _owner) that later becomes scoped
+  // would otherwise (a) crash any `.index("_owner", …)` add_index below with
+  // "no such column: _owner", and (b) silently lose WS owner-filtering when no
+  // other diff exists (the migrations.length === 0 early-return). Add it up
+  // front so both the index pass and runtime filtering work. This is the
+  // global→user transition path the default-private flip (schema 0.3.0) made
+  // reachable for any collection scoped after its table already existed.
+  for (const [tableName, col] of Object.entries(schema.collections)) {
+    if ((col as CollectionConfig).scope !== "user") continue
+    if (!existingTableNames.has(tableName)) continue
+    const cols = bunDb
+      .prepare(`PRAGMA table_info(${tableName})`)
+      .all() as { name: string }[]
+    if (cols.some(c => c.name === "_owner")) continue
+    console.log(`[vibes:migrator] ADD COLUMN ${tableName}._owner (scope→user)`)
+    bunDb.exec(`ALTER TABLE ${tableName} ADD COLUMN _owner TEXT`)
+  }
+
+  // Compute diff and apply safe migrations
+  const migrations = schemaDiff(oldSchema, schema)
+
+  if (migrations.length === 0) {
+    console.log("[vibes:migrator] Schema is up to date.")
+    return
+  }
+
+  for (const migration of migrations) {
+    switch (migration.type) {
+      case "create_table": {
+        // Use schemaToSQL for this table only
+        const partial: Schema = {
+          collections: { [migration.table]: schema.collections[migration.table] },
+        }
+        const sqls = schemaToSQL(partial)
+        for (const sql of sqls) {
+          console.log(`[vibes:migrator] CREATE TABLE ${migration.table}`)
+          bunDb.exec(sql)
+        }
+        break
+      }
+
+      case "add_column": {
+        // SQLite supports ADD COLUMN
+        const colType = fieldTypeToSQL(migration.field.type)
+        const sql = `ALTER TABLE ${migration.table} ADD COLUMN ${migration.column} ${colType}`
+        console.log(`[vibes:migrator] ADD COLUMN ${migration.table}.${migration.column}`)
+        bunDb.exec(sql)
+        break
+      }
+
+      case "drop_table": {
+        // Safety: we log but skip destructive drops in automatic migrations
+        console.warn(
+          `[vibes:migrator] SKIP drop_table ${migration.table} — run manually if intended`
+        )
+        break
+      }
+
+      case "drop_column": {
+        // SQLite doesn't support DROP COLUMN in older versions — skip
+        console.warn(
+          `[vibes:migrator] SKIP drop_column ${migration.table}.${migration.column} — run manually if intended`
+        )
+        break
+      }
+
+      case "add_index": {
+        const indexName = `idx_${migration.table}_${migration.columns.join("_")}`
+        const sql = `CREATE INDEX IF NOT EXISTS ${indexName} ON ${migration.table} (${migration.columns.join(", ")})`
+        console.log(`[vibes:migrator] ADD INDEX ${indexName}`)
+        bunDb.exec(sql)
+        break
+      }
+
+      case "add_unique_index": {
+        const indexName = `uidx_${migration.table}_${migration.columns.join("_")}`
+        const sql = `CREATE UNIQUE INDEX IF NOT EXISTS ${indexName} ON ${migration.table} (${migration.columns.join(", ")})`
+        console.log(`[vibes:migrator] ADD UNIQUE INDEX ${indexName}`)
+        bunDb.exec(sql)
+        break
+      }
+    }
+  }
+
+  console.log(`[vibes:migrator] Applied ${migrations.length} migration(s).`)
+}
+
+function fieldTypeToSQL(type: unknown): string {
+  if (type === "string") return "TEXT"
+  if (type === "number") return "REAL"
+  if (type === "boolean") return "INTEGER"
+  if (type === "date") return "TEXT"
+  if (typeof type === "object" && type !== null) return "TEXT"
+  return "TEXT"
+}