@bakery-framework/orm 1.2.3 → 2.0.0-alpha.11

package/src/sync/rename.ts

@@ -0,0 +1,188 @@
+import type { Logger } from '@bakery-framework/core/logger'
+import { Case } from '@bakery-framework/core/utils'
+import type * as SyncTypes from './types'
+
+type SyncPlan = SyncTypes.SyncPlan
+
+function getStringSimilarity(str1: string, str2: string) {
+  const getBigrams = (str: string) =>
+    new Set(
+      Array.from({ length: str.length - 1 }, (_, i) => str.slice(i, i + 2)),
+    )
+  const bg1 = getBigrams(str1.toLowerCase())
+  const bg2 = getBigrams(str2.toLowerCase())
+  const intersection = bg1.intersection(bg2).size
+  const union = bg1.union(bg2).size
+  return union === 0 ? (str1 === str2 ? 1 : 0) : intersection / union
+}
+
+/**
+ * Shared with `sync/diff.ts`, which asks the same question about a column.
+ *
+ * The prompt and the bigram matcher behind it are the same for both; only the
+ * wording of the question and the default threshold differ.
+ */
+export function findBestMatchAndPrompt(
+  oldName: string,
+  unmappedSet: Set<string>,
+  itemType: 'table' | 'column',
+  contextName: string,
+  logger: Logger,
+  threshold = 0.3,
+): string | null {
+  let bestAutoMatch: string | null = null
+  let bestScore = 0
+
+  for (const newCamel of unmappedSet) {
+    const score = getStringSimilarity(oldName, Case.snake(newCamel))
+    if (score > bestScore && score >= threshold) {
+      bestScore = score
+      bestAutoMatch = newCamel
+    }
+  }
+
+  const unmappedArr = Array.from(unmappedSet)
+  const options = [
+    bestAutoMatch
+      ? `Pick automatically (${Case.snake(bestAutoMatch)}: ${Math.round(bestScore * 100)}%)`
+      : 'Pick automatically (none)',
+    ...unmappedArr.map(t => `Use ${itemType}: ${Case.snake(t)}`),
+    `Drop ${itemType}`,
+  ]
+
+  const promptMsg =
+    itemType === 'table'
+      ? `Unmapped database table: '${contextName}'. What should we do?`
+      : `Unmapped column '${oldName}' in table '${contextName}'. What should we do?`
+  const sel = logger.selectIndex(promptMsg, options)
+
+  if (sel === 0) return bestAutoMatch
+  if (sel === options.length - 1) return null
+  return unmappedArr[sel - 1]
+}
+
+export function initDbTablesMap(dbConstraints: SyncTypes.DBConstraints) {
+  const dbTables: Record<
+    string,
+    { dbName: string; camelName: string; cols: Set<string> }
+  > = {}
+  for (const [rawTable, tableObj] of Object.entries(dbConstraints)) {
+    if (tableObj._view) continue
+    const camelTable = Case.camel(rawTable)
+    dbTables[camelTable] = {
+      dbName: Case.snake(rawTable),
+      camelName: camelTable,
+      cols: new Set(Object.keys(tableObj).filter(k => k !== '_view')),
+    }
+  }
+  return dbTables
+}
+
+function tableHasTransform(tsTableObj: SyncTypes.TableConstraints): boolean {
+  return (
+    !!tsTableObj._transform ||
+    Object.values(tsTableObj).some(
+      col => col && (col as SyncTypes.ColumnConstraint)._transform,
+    )
+  )
+}
+
+function resolveOldTableMapping(
+  plan: SyncPlan,
+  dbTables: any,
+  unmappedDbTables: Set<string>,
+  newCamel: string,
+  tsTableObj: SyncTypes.TableConstraints,
+  hasTransform: boolean,
+) {
+  if (!tsTableObj._oldTable || !plan.unmappedTsTables.has(newCamel)) return
+  const oldCamel = Case.camel(tsTableObj._oldTable)
+  if (!dbTables[oldCamel]) return
+  if (!hasTransform) {
+    plan.tablesToRename.push({
+      oldName: dbTables[oldCamel].dbName,
+      newName: Case.snake(newCamel),
+    })
+  }
+  unmappedDbTables.delete(oldCamel)
+  plan.unmappedTsTables.delete(newCamel)
+  dbTables[newCamel] = { ...dbTables[oldCamel], camelName: newCamel }
+  delete dbTables[oldCamel]
+}
+
+export function handleTableRenames(
+  plan: SyncPlan,
+  constraints: SyncTypes.DBConstraints,
+  dbTables: any,
+) {
+  const normalizedConstraints: SyncTypes.DBConstraints = {}
+  for (const [k, v] of Object.entries(constraints)) {
+    normalizedConstraints[Case.camel(k)] = v
+  }
+
+  const unmappedDbTables = new Set(
+    Object.keys(dbTables).filter(camel => !normalizedConstraints[camel]),
+  )
+  // Views are excluded, not merely absent. `initDbTablesMap` skips `_view`
+  // entries, so a view is never in `dbTables` and would look like a table that
+  // still needs creating — on every run, forever. `evaluateChanges` counts
+  // `unmappedTsTables`, so a schema with a view could never report a perfectly
+  // synced database. The view phase creates them; this set is about tables.
+  plan.unmappedTsTables = new Set(
+    Object.keys(normalizedConstraints).filter(
+      camel =>
+        !dbTables[camel] && !(normalizedConstraints[camel] as any)?._view,
+    ),
+  )
+
+  for (const [newRaw, tsTableObj] of Object.entries(constraints)) {
+    if (!tsTableObj) continue
+    const newCamel = Case.camel(newRaw)
+    const hasTransform = tableHasTransform(tsTableObj)
+    if (hasTransform) plan.tablesToRebuild.add(Case.snake(newCamel))
+    resolveOldTableMapping(
+      plan,
+      dbTables,
+      unmappedDbTables,
+      newCamel,
+      tsTableObj,
+      hasTransform,
+    )
+  }
+  return unmappedDbTables
+}
+
+export function promptAndRenameTables(
+  plan: SyncPlan,
+  dbTables: any,
+  unmappedDbTables: Set<string>,
+  logger: Logger,
+) {
+  for (const oldCamel of [...unmappedDbTables]) {
+    const dbName = dbTables[oldCamel]!.dbName
+    const bestMatch = findBestMatchAndPrompt(
+      dbName,
+      plan.unmappedTsTables,
+      'table',
+      dbName,
+      logger,
+      0.5,
+    )
+
+    if (bestMatch) {
+      plan.tablesToRename.push({
+        oldName: dbName,
+        newName: Case.snake(bestMatch),
+      })
+      unmappedDbTables.delete(oldCamel)
+      plan.unmappedTsTables.delete(bestMatch)
+      dbTables[bestMatch] = {
+        ...dbTables[oldCamel]!,
+        camelName: bestMatch,
+      }
+      delete dbTables[oldCamel]
+    } else {
+      plan.tablesToDrop.push(dbName)
+    }
+  }
+}

package/src/sync/types.ts

@@ -55,19 +55,27 @@ export interface IndexConstraint {
   type: 'index' | 'unique' | 'foreign'
   table: string
   cols: string[]
+  /**
+   * The column names exactly as the database reported them, aligned with
+   * `cols` by position. Introspection always fills this; a TS-declared index
+   * (`Field.Unique`, `Field.Index`) has no database spelling to carry, which
+   * is why it is optional.
+   *
+   * It exists because `Case.snake` is not the inverse of `Case.camel`
+   * (`SKU_code` → `sKUCode` → `s_k_u_code`), so a consumer that needs the raw
+   * spelling — a statement, a display — cannot recover it from `cols` and had
+   * to rebuild a camel→raw map from the schema's column list. That rebuild was
+   * first-wins over collisions: a table holding both `user_id` and `userId`
+   * files them under one camel key, and an index over the *second* resolved to
+   * the first — a predicate over the wrong column. The adapter knows the real
+   * names at parse time; carrying them costs an array.
+   */
+  rawCols?: string[]
   /** Set only when `type` is 'foreign'. */
   refTable?: string
   refCols?: string[]
 }
 
-/**
- * A foreign key as the database reports it.
- *
- * Identity is the tuple, not the name: SQLite's `PRAGMA foreign_key_list`
- * does not return a constraint name at all, so keying on one would make every
- * SQLite foreign key look new on every sync — the perpetual-rebuild failure
- * this project keeps hitting.
- */
 /**
  * Referential actions, normalised to the SQL spelling.
  *
@@ -83,6 +91,13 @@ export type ForeignKeyAction =
   | 'SET NULL'
   | 'SET DEFAULT'
 
+/**
+ * A foreign key as the database reports it.
+ *
+ * Identity is the tuple, not the name: SQLite's `PRAGMA foreign_key_list` does
+ * not return a constraint name at all, so keying on one would make every SQLite
+ * foreign key look new on every sync.
+ */
 export interface ForeignKeyInfo {
   table: string
   cols: string[]
@@ -94,6 +109,52 @@ export interface ForeignKeyInfo {
   onUpdate?: ForeignKeyAction
 }
 
+/**
+ * The diff, as one value: what `sync/plan.ts` decided and `sync/execute.ts`
+ * applies.
+ *
+ * It lives here rather than beside `buildSyncPlan` because `sync/rename.ts` and
+ * `sync/diff.ts` both mutate a plan and are both imported *by* the planner. A
+ * home in `plan.ts` would make that pair of edges circular — type-only, and so
+ * erased under `verbatimModuleSyntax`, but this repo has been bitten by import
+ * cycles often enough that not creating one is worth more than the adjacency.
+ */
+export namespace SyncPlan {
+  export interface TableRename {
+    oldName: string
+    newName: string
+  }
+  export interface ColumnDrop {
+    table: string
+    column: string
+  }
+  export interface ColumnAdd {
+    table: string
+    column: string
+    def: ColumnConstraint
+  }
+  export interface ColumnRename {
+    table: string
+    oldColumn: string
+    newColumn: string
+  }
+}
+
+export interface SyncPlan {
+  tablesToDrop: string[]
+  tablesToRename: SyncPlan.TableRename[]
+  columnsToDrop: SyncPlan.ColumnDrop[]
+  columnsToAdd: SyncPlan.ColumnAdd[]
+  columnsToRename: SyncPlan.ColumnRename[]
+  tablesToRebuild: Set<string>
+  /** Which source `dbConstraintsForDiff` came from, so the run can say so. */
+  ledgerSource?: 'ledger' | 'introspection'
+  ledgerReason?: string
+  viewsToUpdate: string[]
+  unmappedTsTables: Set<string>
+  dbConstraintsForDiff: DBConstraints
+}
+
 export type DBForeignKeys = Record<string, ForeignKeyInfo>
 
 export type DBConstraints = Record<string, TableConstraints>