@michaelthielemann/kestrel 3.0.0 → 4.0.0

package/layers/core/server/schema/diff.ts

@@ -1,110 +0,0 @@
-import type { SchemaSnapshot, SchemaOp, IndexShape, ColumnShape } from './model'
-
-/** Two indexes are equivalent when uniqueness, partial predicate, and ordered columns all match. */
-function sameIndex(a: IndexShape, b: IndexShape): boolean {
-  return a.unique === b.unique
-    && a.where === b.where
-    && a.columns.length === b.columns.length
-    && a.columns.every((c, i) => c === b.columns[i])
-}
-
-/** A column's definition drifted (same name, different shape) — only fixable by a table rebuild in SQLite. */
-function columnDiffers(a: ColumnShape, b: ColumnShape): boolean {
-  return a.type !== b.type || a.notNull !== b.notNull || a.primaryKey !== b.primaryKey
-    || a.autoIncrement !== b.autoIncrement || a.default !== b.default
-}
-
-/**
- * Schema diff (ADR-0002). Additive changes (create table/column/index, drop_index) are always emitted.
- * Destructive changes are emitted too but kept distinct: a table only in `actual` becomes `drop_table`;
- * a table whose columns were dropped or whose definitions drifted becomes a `rebuild_table` (SQLite has
- * no in-place ALTER COLUMN). A table needing a rebuild takes the rebuild path WHOLE — its added columns
- * and indexes are recreated by the rebuild, not emitted separately.
- *
- * Returned in an apply-safe order: additive first (create_table → add_column → drop_index →
- * create_index), destructive last (rebuild_table → drop_table). The additive/destructive split lets the
- * apply layer gate destructive ops behind an explicit opt-in (see `isDestructive`).
- */
-export function diffSchema(desired: SchemaSnapshot, actual: SchemaSnapshot): SchemaOp[] {
-  const createTables: SchemaOp[] = []
-  const renames: SchemaOp[] = []
-  const addColumns: SchemaOp[] = []
-  const dropIndexes: SchemaOp[] = []
-  const createIndexes: SchemaOp[] = []
-  const rebuilds: SchemaOp[] = []
-  const dropTables: SchemaOp[] = []
-
-  for (const name of Object.keys(desired)) {
-    const want = desired[name]
-    const have = actual[name]
-
-    if (!have) {
-      createTables.push({ type: 'create_table', table: want })
-      for (const index of want.indexes) createIndexes.push({ type: 'create_index', index })
-      continue
-    }
-
-    const haveByName = new Map(have.columns.map((c) => [c.name, c]))
-    const wantNames = new Set(want.columns.map((c) => c.name))
-
-    // Resolve renames: a desired column whose `renamedFrom` exists in actual while its own name does not.
-    // `rename_column` is additive and ordered before any rebuild, so the rest of the diff can treat the
-    // column as already present under its NEW name (the "effective" actual view).
-    const renameMap = new Map<string, string>() // newName -> oldName
-    const transformMap = new Map<string, { from: string; type: 'wrap' | 'unwrap' }>() // single↔multiple toggles
-    for (const c of want.columns) {
-      if (c.renamedFrom && haveByName.has(c.renamedFrom) && !haveByName.has(c.name)) {
-        renameMap.set(c.name, c.renamedFrom)
-        if (c.renameTransform) transformMap.set(c.name, { from: c.renamedFrom, type: c.renameTransform })
-      }
-    }
-    const renamedOld = new Set(renameMap.values())
-    // A name vacated by a rename (renamedOld) reads as absent unless something else renamed INTO it —
-    // otherwise a field re-using a just-freed name is mistaken for the column that just moved away.
-    const effectiveHas = (n: string) => (haveByName.has(n) && !renamedOld.has(n)) || renameMap.has(n)
-    const actualColOf = (n: string) => (renameMap.has(n) || !renamedOld.has(n)) ? haveByName.get(renameMap.get(n) ?? n) : undefined
-
-    const dropped = have.columns.some((c) => !wantNames.has(c.name) && !renamedOld.has(c.name))
-    const changed = want.columns.some((c) => { const a = actualColOf(c.name); return a !== undefined && columnDiffers(a, c) })
-
-    // Plain renames are an in-place ALTER RENAME; a single↔multiple toggle reshapes the data, so it is
-    // handled by the rebuild's transformed copy below (NO rename_column for those).
-    for (const [to, from] of renameMap) {
-      if (!transformMap.has(to)) renames.push({ type: 'rename_column', table: name, from, to })
-    }
-
-    if (dropped || changed || transformMap.size > 0) {
-      // Rebuild recreates the table at `want`, copying columns present in both (by effective/new name —
-      // plain renames already ran). A toggled column is copied from its old, differently-named source via
-      // a shape transform. Columns dropped without a rename hint are not copied: the data loss line.
-      const copy = want.columns.filter((c) => effectiveHas(c.name)).map((c) => c.name)
-      const transforms = Object.fromEntries(copy.filter((c) => transformMap.has(c)).map((c) => [c, transformMap.get(c)!]))
-      rebuilds.push({ type: 'rebuild_table', table: want, copy, ...(Object.keys(transforms).length ? { transforms } : {}) })
-      continue
-    }
-
-    // Purely additive for this table (renames already queued above).
-    for (const column of want.columns) {
-      if (!effectiveHas(column.name)) addColumns.push({ type: 'add_column', table: name, column })
-    }
-    const haveIdx = new Map(have.indexes.map((i) => [i.name, i]))
-    const wantIdx = new Map(want.indexes.map((i) => [i.name, i]))
-    for (const index of want.indexes) {
-      const existing = haveIdx.get(index.name)
-      if (!existing) { createIndexes.push({ type: 'create_index', index }); continue }
-      if (!sameIndex(existing, index)) {
-        dropIndexes.push({ type: 'drop_index', index: existing })
-        createIndexes.push({ type: 'create_index', index })
-      }
-    }
-    for (const index of have.indexes) {
-      if (!wantIdx.has(index.name)) dropIndexes.push({ type: 'drop_index', index })
-    }
-  }
-
-  for (const name of Object.keys(actual)) {
-    if (!desired[name]) dropTables.push({ type: 'drop_table', name })
-  }
-
-  return [...createTables, ...renames, ...addColumns, ...dropIndexes, ...createIndexes, ...rebuilds, ...dropTables]
-}

package/layers/core/server/schema/introspect.ts

@@ -1,68 +0,0 @@
-import type { ColumnShape, IndexShape, SchemaSnapshot } from './model'
-
-// Read the *actual* schema of a live SQLite database into the normalized model, so `diffSchema` can
-// compare it against the desired schema (ADR-0002). Typed structurally (prepare + pragma) to keep the
-// native module out of this file — but the shape is narrower than better-sqlite3's own (which types
-// `pragma` as returning `unknown`), so a real connection only reaches these entry points through a cast.
-
-interface Row { [key: string]: unknown }
-export interface IntrospectDb {
-  prepare(sql: string): { all(...params: unknown[]): Row[] }
-  pragma(source: string): Row[]
-}
-
-/** Double-quote an identifier for a PRAGMA argument (names come from sqlite_master, but quote defensively). */
-const dq = (id: string) => `"${id.replace(/"/g, '""')}"`
-
-export function introspect(db: IntrospectDb): SchemaSnapshot {
-  // Exclude sqlite internals, the drizzle migrations ledger, and any `__kestrel_new_*` rebuild temp
-  // table left by an interrupted rebuild — so an orphan is never mistaken for a real (droppable) table.
-  const tables = db.prepare(
-    "SELECT name, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__kestrel_new_%' AND name <> '__drizzle_migrations'",
-  ).all() as { name: string; sql: string | null }[]
-
-  const snapshot: SchemaSnapshot = {}
-  for (const { name, sql } of tables) {
-    snapshot[name] = { name, columns: columnsOf(db, name, sql ?? ''), indexes: indexesOf(db, name) }
-  }
-  return snapshot
-}
-
-function columnsOf(db: IntrospectDb, table: string, tableSql: string): ColumnShape[] {
-  // PRAGMA exposes no AUTOINCREMENT flag — it only ever applies to the INTEGER PRIMARY KEY, so detect
-  // it from the table's stored CREATE statement.
-  const hasAutoInc = /\bAUTOINCREMENT\b/i.test(tableSql)
-  const rows = db.pragma(`table_info(${dq(table)})`) as
-    { name: string; type: string; notnull: number; dflt_value: unknown; pk: number }[]
-  return rows.map((r) => ({
-    name: r.name,
-    type: r.type.toLowerCase(),
-    notNull: r.notnull === 1,
-    primaryKey: r.pk > 0,
-    autoIncrement: r.pk > 0 && hasAutoInc,
-    default: r.dflt_value == null ? null : String(r.dflt_value),
-  }))
-}
-
-function indexesOf(db: IntrospectDb, table: string): IndexShape[] {
-  const uniqueByName = new Map(
-    (db.pragma(`index_list(${dq(table)})`) as { name: string; unique: number }[]).map((m) => [m.name, m.unique === 1]),
-  )
-  // Only explicitly-created indexes carry a non-null `sql`; auto-indexes from UNIQUE/PK constraints are
-  // null-sql and excluded (they mirror column constraints, not declared indexes).
-  const rows = db.prepare(
-    "SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ? AND sql IS NOT NULL",
-  ).all(table) as { name: string; sql: string }[]
-
-  return rows.map(({ name, sql }) => {
-    const columns = (db.pragma(`index_info(${dq(name)})`) as { name: string }[]).map((c) => c.name)
-    const where = sql.match(/\bWHERE\b\s+(.+)$/is)
-    return {
-      name,
-      table,
-      columns,
-      unique: uniqueByName.get(name) ?? /\bCREATE\s+UNIQUE\b/i.test(sql),
-      where: where ? where[1].trim() : null,
-    }
-  })
-}

package/layers/core/server/schema/model.ts

@@ -1,61 +0,0 @@
-// Normalized, dialect-agnostic schema model for the migration engine (ADR-0002). Both sides of a diff
-// are expressed in this shape: the *desired* snapshot (built from collection tables via getTableConfig)
-// and the *actual* snapshot (introspected from the live DB). `diffSchema` compares them; a dialect
-// renderer turns the resulting ops into DDL. SQLite is the first dialect.
-
-export interface ColumnShape {
-  name: string
-  /** SQLite storage type as it appears in DDL: `integer` | `text` | `real` | `blob`. */
-  type: string
-  notNull: boolean
-  primaryKey: boolean
-  autoIncrement: boolean
-  /** Raw SQL default token, exactly as it follows `DEFAULT` (e.g. `'draft'`, `0`), or null for none. */
-  default: string | null
-  /** The column's previous name (from a `renamedFrom` field hint) — the diff renames in place rather
-   *  than dropping the old column and losing its data. */
-  renamedFrom?: string
-  /** A relation/media `single↔multiple` toggle: the column moved between `<col>_id` (scalar) and `<col>`
-   *  (json array), so the rename needs a data shape transform. `wrap` = scalar→array, `unwrap` = array→scalar. */
-  renameTransform?: 'wrap' | 'unwrap'
-}
-
-export interface IndexShape {
-  name: string
-  table: string
-  columns: string[]
-  unique: boolean
-  /** Partial-index predicate (the text after `WHERE`), or null for a full index. */
-  where: string | null
-}
-
-export interface TableShape {
-  name: string
-  columns: ColumnShape[]
-  indexes: IndexShape[]
-}
-
-/** A whole schema, keyed by table name. */
-export type SchemaSnapshot = Record<string, TableShape>
-
-/**
- * One structured, dialect-agnostic schema change. The first four variants are **additive** (no data
- * loss): create table/column/index, and drop_index (indexes hold no row data, so dropping one is
- * reversible). The last two are **destructive** (see `isDestructive`):
- *  - `drop_table` — a collection was removed.
- *  - `rebuild_table` — a column was dropped or its definition changed; since SQLite has no in-place
- *    ALTER COLUMN, the table is recreated and the surviving columns (`copy`) are carried over.
- * Destructive ops are never auto-applied; they require an explicit opt-in (ADR-0002).
- */
-export type SchemaOp =
-  | { type: 'create_table'; table: TableShape }
-  | { type: 'add_column'; table: string; column: ColumnShape }
-  | { type: 'create_index'; index: IndexShape }
-  | { type: 'drop_index'; index: IndexShape }
-  // `rename_column` is additive (data-preserving, `ALTER TABLE … RENAME COLUMN`); it runs before any
-  // rebuild, so a rebuilt table sees the column under its new name.
-  | { type: 'rename_column'; table: string; from: string; to: string }
-  | { type: 'drop_table'; name: string }
-  // `transforms` maps a copied column to a shape transform of a differently-named source column (a
-  // relation/media single↔multiple toggle); plain copies just use the column's own (new) name.
-  | { type: 'rebuild_table'; table: TableShape; copy: string[]; transforms?: Record<string, { from: string; type: 'wrap' | 'unwrap' }> }

package/layers/core/server/schema/render-sqlite.ts

@@ -1,89 +0,0 @@
-import type { ColumnShape, IndexShape, TableShape, SchemaOp } from './model'
-
-// SQLite dialect renderer: structured ops → DDL strings. Kept separate from `diffSchema` (which is
-// dialect-agnostic) so a future Postgres renderer can sit behind the same op interface (ADR-0002).
-
-const q = (id: string) => `\`${id.replace(/`/g, '``')}\``
-const lit = (s: string) => `'${s.replace(/'/g, "''")}'`
-
-/**
- * A column definition, shared by CREATE TABLE and ALTER TABLE ADD COLUMN. Clause order matches the
- * committed drizzle-kit migrations: `<type> [PRIMARY KEY [AUTOINCREMENT]] [DEFAULT <x>] [NOT NULL]`.
- * (SQLite rejects a NOT-NULL ADD COLUMN without a default on a non-empty table — that guard belongs to
- * the apply/validation layer, not here.)
- */
-function columnClause(c: ColumnShape): string {
-  let s = `${q(c.name)} ${c.type}`
-  if (c.primaryKey) s += c.autoIncrement ? ' PRIMARY KEY AUTOINCREMENT' : ' PRIMARY KEY'
-  if (c.default !== null) s += ` DEFAULT ${c.default}`
-  if (c.notNull) s += ' NOT NULL'
-  return s
-}
-
-// Indexes are emitted as separate create_index ops, so CREATE TABLE renders columns only.
-function createTableSql(name: string, columns: ColumnShape[]): string {
-  const cols = columns.map((c) => `  ${columnClause(c)}`).join(',\n')
-  return `CREATE TABLE ${q(name)} (\n${cols}\n);`
-}
-
-/**
- * SQLite has no ALTER COLUMN / safe DROP COLUMN, so a destructive column change is a table rebuild:
- * create a new table at the desired shape, copy the surviving columns' data, drop the old, rename the
- * new into place, then recreate the indexes. (No foreign keys exist in this schema, so the usual
- * `PRAGMA foreign_keys` dance is unnecessary.)
- */
-/** SELECT source for a copied column: itself, or a single↔multiple shape transform of a differently-named source. */
-function copySource(col: string, transforms?: Record<string, { from: string; type: 'wrap' | 'unwrap' }>): string {
-  const t = transforms?.[col]
-  if (!t) return q(col)
-  return t.type === 'wrap'
-    ? `CASE WHEN ${q(t.from)} IS NULL THEN '[]' ELSE json_array(${q(t.from)}) END`
-    : `json_extract(${q(t.from)}, '$[0]')`
-}
-
-function rebuildTable(table: TableShape, copy: string[], transforms?: Record<string, { from: string; type: 'wrap' | 'unwrap' }>): string[] {
-  const tmp = `__kestrel_new_${table.name}`
-  // `DROP TABLE IF EXISTS` first so an orphan temp from an interrupted earlier rebuild self-heals
-  // instead of colliding on CREATE and wedging the migration.
-  const stmts = [`DROP TABLE IF EXISTS ${q(tmp)};`, createTableSql(tmp, table.columns)]
-  if (copy.length) {
-    const into = copy.map(q).join(', ')
-    const select = copy.map((c) => copySource(c, transforms)).join(', ')
-    stmts.push(`INSERT INTO ${q(tmp)} (${into}) SELECT ${select} FROM ${q(table.name)};`)
-  }
-  // Preserve the AUTOINCREMENT high-water mark across the rebuild so ids are never reused (a reused id
-  // could silently repoint a stale internal-link / relation reference). `sqlite_sequence` has no UNIQUE
-  // on `name`, so INSERT-OR-REPLACE won't work — ensure the temp row exists, then bump it to the old
-  // table's mark. Must run while the old table's seq row still exists (before its DROP); the RENAME then
-  // carries the row's name across.
-  if (table.columns.some((c) => c.autoIncrement)) {
-    stmts.push(`INSERT INTO sqlite_sequence (name, seq) SELECT ${lit(tmp)}, 0 WHERE NOT EXISTS (SELECT 1 FROM sqlite_sequence WHERE name = ${lit(tmp)});`)
-    stmts.push(`UPDATE sqlite_sequence SET seq = MAX(seq, COALESCE((SELECT seq FROM sqlite_sequence WHERE name = ${lit(table.name)}), 0)) WHERE name = ${lit(tmp)};`)
-  }
-  stmts.push(`DROP TABLE ${q(table.name)};`)
-  stmts.push(`ALTER TABLE ${q(tmp)} RENAME TO ${q(table.name)};`)
-  for (const index of table.indexes) stmts.push(createIndex(index))
-  return stmts
-}
-
-function createIndex(i: IndexShape): string {
-  const unique = i.unique ? 'UNIQUE ' : ''
-  const cols = i.columns.map(q).join(',')
-  const where = i.where ? ` WHERE ${i.where}` : ''
-  return `CREATE ${unique}INDEX ${q(i.name)} ON ${q(i.table)} (${cols})${where};`
-}
-
-/** Render structured ops into SQLite DDL, preserving order. Most ops are one statement; a rebuild is several. */
-export function renderSqlite(ops: SchemaOp[]): string[] {
-  return ops.flatMap((op): string[] => {
-    switch (op.type) {
-      case 'create_table': return [createTableSql(op.table.name, op.table.columns)]
-      case 'add_column': return [`ALTER TABLE ${q(op.table)} ADD COLUMN ${columnClause(op.column)};`]
-      case 'create_index': return [createIndex(op.index)]
-      case 'drop_index': return [`DROP INDEX IF EXISTS ${q(op.index.name)};`]
-      case 'rename_column': return [`ALTER TABLE ${q(op.table)} RENAME COLUMN ${q(op.from)} TO ${q(op.to)};`]
-      case 'drop_table': return [`DROP TABLE ${q(op.name)};`]
-      case 'rebuild_table': return rebuildTable(op.table, op.copy, op.transforms)
-    }
-  })
-}

package/layers/core/server/schema/sync.ts

@@ -1,201 +0,0 @@
-import type { IntrospectDb } from './introspect'
-import { diffSchema } from './diff'
-import { sqlite, type Dialect } from './dialect'
-import type { SchemaSnapshot, SchemaOp } from './model'
-
-export interface SyncDb extends IntrospectDb {
-  exec(sql: string): unknown
-  transaction(fn: () => void): () => void
-}
-
-/** Destructive ops drop or rebuild a table (potential data loss); they require an explicit opt-in (ADR-0002). */
-export function isDestructive(op: SchemaOp): boolean {
-  return op.type === 'drop_table' || op.type === 'rebuild_table'
-}
-
-/** Human description of an op, for dry-run reports and the dev skipped-warning so data loss is visible. */
-export function describeOp(op: SchemaOp): string {
-  if (op.type === 'drop_table') return `drop table \`${op.name}\``
-  if (op.type === 'rebuild_table') {
-    // Name the carried columns + any transform sources (not just a count), so the operator can see exactly
-    // what survives — everything else that is live but NOT in this list has its data dropped by the rebuild.
-    const carried = op.copy.join(', ') || '—'
-    const sources = [...new Set(Object.values(op.transforms ?? {}).map((t) => t.from))]
-    const from = sources.length ? ` (+ transform source(s): ${sources.join(', ')})` : ''
-    return `rebuild table \`${op.table.name}\` — keeps: ${carried}${from}; any other live column's data is dropped`
-  }
-  if (op.type === 'create_table') return `create table \`${op.table.name}\` (${op.table.columns.length} column(s))`
-  if (op.type === 'add_column') return `add column \`${op.table}\`.\`${op.column.name}\` ${op.column.type}`
-  if (op.type === 'create_index') return `create index \`${op.index.name}\` on \`${op.index.table}\` (${op.index.columns.join(', ')})`
-  if (op.type === 'drop_index') return `drop index \`${op.index.name}\` on \`${op.index.table}\``
-  if (op.type === 'rename_column') return `rename column \`${op.table}\`.\`${op.from}\` to \`${op.to}\``
-  return (op as SchemaOp).type
-}
-
-/**
- * Reasons SQLite would reject a rebuild's `INSERT…SELECT` — surfaced up-front as a clear error instead
- * of an opaque "NOT NULL constraint failed" inside an aborted transaction:
- *  - a NOT NULL column with no default that isn't carried over (a new required field on a populated table)
- *  - a carried-over column that became NOT NULL but whose existing rows still hold NULL
- * Identifier quoting comes from the dialect (the feasibility probes run against the live DB).
- */
-function rebuildProblems(db: SyncDb, op: Extract<SchemaOp, { type: 'rebuild_table' }>, quote: Dialect['quote'], renames: Map<string, string>): string[] {
-  const carried = new Set(op.copy)
-  const problems: string[] = []
-  // The probes run against the LIVE table, which still holds the PRE-migration column names: rename_column
-  // ops and the rebuild's INSERT…SELECT only run later, inside the transaction. So resolve each carried
-  // column to its live SOURCE expression — a transform's `from`, else its own name — and skip when no live
-  // source exists yet (a plain rename we can't map here), rather than probe a name that doesn't exist and
-  // abort the whole migration with `no such column`. The expressions mirror render-sqlite's `copySource`.
-  const liveCols = new Set((db.pragma(`table_info("${op.table.name.replace(/"/g, '""')}")`) as { name: string }[]).map((r) => r.name))
-  const liveSourceIsNull = (c: string): boolean | null => {
-    const t = op.transforms?.[c]
-    if (t) {
-      // `wrap` (single→multiple) coalesces NULL to '[]' → never NULL. `unwrap` (multiple→single) is
-      // `json_extract(from, '$[0]')` → NULL for a NULL or empty source array.
-      if (t.type === 'wrap') return false
-      if (!liveCols.has(t.from)) return null
-      return db.prepare(`SELECT 1 FROM ${quote(op.table.name)} WHERE json_extract(${quote(t.from)}, '$[0]') IS NULL LIMIT 1`).all().length > 0
-    }
-    if (!liveCols.has(c)) {
-      // The column isn't live under its NEW name yet — it arrives via a plain `rename_column` that runs
-      // first. Probe its OLD live name instead (the rename preserves data, so a NOT NULL target still
-      // fails on rows the old column left NULL). Only skip when even the source name isn't live.
-      const from = renames.get(`${op.table.name} ${c}`)
-      if (from && liveCols.has(from)) return db.prepare(`SELECT 1 FROM ${quote(op.table.name)} WHERE ${quote(from)} IS NULL LIMIT 1`).all().length > 0
-      return null
-    }
-    return db.prepare(`SELECT 1 FROM ${quote(op.table.name)} WHERE ${quote(c)} IS NULL LIMIT 1`).all().length > 0
-  }
-  for (const c of op.table.columns) {
-    if (!c.notNull || c.default !== null || c.autoIncrement) continue
-    if (!carried.has(c.name)) {
-      problems.push(`${op.table.name}.${c.name}: new NOT NULL column has no default and no data to copy`)
-    } else if (liveSourceIsNull(c.name) === true) {
-      problems.push(`${op.table.name}.${c.name}: became NOT NULL but existing rows hold NULL`)
-    }
-  }
-  // A UNIQUE index recreated by the rebuild over carried-over data that already holds duplicates would
-  // abort the migration; flag it up front. (SQLite treats NULLs as distinct, so only non-null rows count.)
-  // Only probe when every index column already exists live (a renamed/transformed column can't be checked
-  // here without a live name — skip rather than crash, same as the NULL probe above).
-  for (const idx of op.table.indexes) {
-    if (!idx.unique || !idx.columns.every((c) => carried.has(c) && liveCols.has(c))) continue
-    const cols = idx.columns.map(quote).join(', ')
-    const notNull = idx.columns.map((c) => `${quote(c)} IS NOT NULL`).join(' AND ')
-    const partial = idx.where ? ` AND (${idx.where})` : ''
-    const dup = db.prepare(`SELECT 1 FROM ${quote(op.table.name)} WHERE ${notNull}${partial} GROUP BY ${cols} HAVING COUNT(*) > 1 LIMIT 1`).all().length > 0
-    if (dup) problems.push(`${op.table.name}.(${idx.columns.join(', ')}): UNIQUE index "${idx.name}" has duplicate values in existing rows`)
-  }
-  return problems
-}
-
-/**
- * A plain `ALTER TABLE … ADD COLUMN` can't add a NOT NULL column with no default to a table that
- * already holds rows (SQLite rejects it; an empty table is fine). This is reachable purely additively —
- * adding a required field with no default to a populated collection emits a standalone `add_column`,
- * never a rebuild — so the rebuild pre-flight misses it. Surface it as the same up-front 'infeasible'
- * message instead of an opaque mid-transaction abort.
- */
-function addColumnProblems(db: SyncDb, op: Extract<SchemaOp, { type: 'add_column' }>, quote: Dialect['quote']): string[] {
-  const c = op.column
-  if (!c.notNull || c.default !== null || c.autoIncrement) return []
-  const hasRows = db.prepare(`SELECT 1 FROM ${quote(op.table)} LIMIT 1`).all().length > 0
-  return hasRows ? [`${op.table}.${c.name}: new NOT NULL column has no default and the table already has rows`] : []
-}
-
-/**
- * A new standalone UNIQUE index (e.g. flipping an existing populated column to `unique: true`) aborts if
- * current rows already hold duplicate non-null values. Same duplicate probe `rebuildProblems` runs, but
- * for a `create_index` op against the live table. Skip when an index column isn't live yet (it arrives
- * via a rename that runs first) rather than probe a missing column and abort with `no such column`.
- */
-function createIndexProblems(db: SyncDb, op: Extract<SchemaOp, { type: 'create_index' }>, quote: Dialect['quote']): string[] {
-  const idx = op.index
-  if (!idx.unique) return []
-  const liveCols = new Set((db.pragma(`table_info("${idx.table.replace(/"/g, '""')}")`) as { name: string }[]).map((r) => r.name))
-  if (!idx.columns.every((c) => liveCols.has(c))) return []
-  const cols = idx.columns.map(quote).join(', ')
-  const notNull = idx.columns.map((c) => `${quote(c)} IS NOT NULL`).join(' AND ')
-  const partial = idx.where ? ` AND (${idx.where})` : ''
-  const dup = db.prepare(`SELECT 1 FROM ${quote(idx.table)} WHERE ${notNull}${partial} GROUP BY ${cols} HAVING COUNT(*) > 1 LIMIT 1`).all().length > 0
-  return dup ? [`${idx.table}.(${idx.columns.join(', ')}): UNIQUE index "${idx.name}" has duplicate values in existing rows`] : []
-}
-
-/** Compute the ops needed to bring `db` to `desired` WITHOUT applying them — the dry-run / `--check`
- *  source. Reads the live schema through `dialect.introspect` (defaults to SQLite). */
-export function planOps(db: SyncDb, desired: SchemaSnapshot, dialect: Dialect = sqlite): SchemaOp[] {
-  return diffSchema(desired, dialect.introspect(db))
-}
-
-export interface SyncOptions {
-  /** Apply `rebuild_table` ops (a managed collection's columns were dropped or changed). */
-  allowDestructive?: boolean
-  /** Table names allowed to be dropped. A `drop_table` applies ONLY if its table is listed here, so an
-   *  unmanaged / unrelated table is never dropped just because `allowDestructive` was set. */
-  dropTables?: string[]
-}
-
-export interface SyncResult {
-  /** DDL statements applied, in order (empty when already in sync). */
-  applied: string[]
-  /** Destructive ops withheld (not opted into) — the DB was left intact for them. */
-  skipped: SchemaOp[]
-}
-
-/**
- * Reconcile a live database to `desired` through `dialect` (defaults to SQLite). Additive ops always
- * apply. Destructive ops need an explicit, op-specific opt-in: `rebuild_table` requires
- * `allowDestructive`; `drop_table` requires the table to be named in `dropTables` (a blanket
- * `allowDestructive` never drops tables). Withheld ops are returned in `skipped`. Everything applied runs
- * in one transaction.
- */
-export function syncSchema(db: SyncDb, desired: SchemaSnapshot, opts: SyncOptions = {}, dialect: Dialect = sqlite): SyncResult {
-  const droppable = new Set(opts.dropTables ?? [])
-  const allowed = (op: SchemaOp): boolean => {
-    if (op.type === 'rebuild_table') return opts.allowDestructive === true
-    if (op.type === 'drop_table') return droppable.has(op.name)
-    return true
-  }
-  const ops = planOps(db, desired, dialect)
-  let toApply = ops.filter(allowed)
-  let skipped = ops.filter((op) => !allowed(op))
-
-  // A `rename_column` queued ahead of a `rebuild_table` is only sound as that rebuild's prologue (diff.ts
-  // never re-gates it on the rebuild being applied). If the rebuild was withheld, ship neither half — a
-  // bare rename would leave the table renamed but not rebuilt, silently diverging from `desired`.
-  const withheldRebuildTables = new Set(skipped.filter((op) => op.type === 'rebuild_table').map((op) => op.table.name))
-  if (withheldRebuildTables.size) {
-    const demoted = toApply.filter((op) => op.type === 'rename_column' && withheldRebuildTables.has(op.table))
-    if (demoted.length) {
-      toApply = toApply.filter((op) => !demoted.includes(op))
-      skipped = [...skipped, ...demoted]
-    }
-  }
-
-  // Validate feasibility BEFORE opening the transaction, so an impossible migration fails loud and
-  // changes nothing (rather than aborting the transaction with an opaque constraint error). Every
-  // apply-time-fatal op is pre-flighted: rebuilds, plus the purely-additive add_column(NOT NULL, no
-  // default) on a populated table and create_index(UNIQUE) over existing duplicates.
-  // Plain renames (`ALTER TABLE … RENAME COLUMN`) run BEFORE the rebuilds, so a rebuild's carried column
-  // may be probed under its OLD live name — build a PER-TABLE new→old map so the NOT NULL feasibility check
-  // can. Keyed by table: two tables renaming a different column to the SAME new name must not collide.
-  const renames = new Map<string, string>() // `${table} ${to}` → from
-  for (const op of toApply) if (op.type === 'rename_column') renames.set(`${op.table} ${op.to}`, op.from)
-  const problems = toApply.flatMap((op) =>
-    op.type === 'rebuild_table' ? rebuildProblems(db, op, dialect.quote, renames)
-    : op.type === 'add_column' ? addColumnProblems(db, op, dialect.quote)
-    : op.type === 'create_index' ? createIndexProblems(db, op, dialect.quote)
-    : [])
-  if (problems.length) {
-    throw new Error(`kestrel: schema migration is infeasible — fix the collection or its data, then retry:\n  - ${problems.join('\n  - ')}`)
-  }
-
-  const applied = dialect.render(toApply)
-  if (applied.length) {
-    db.transaction(() => {
-      for (const sql of applied) db.exec(sql)
-    })()
-  }
-  return { applied, skipped }
-}

package/layers/core/server/utils/blocks.ts

@@ -1,6 +0,0 @@
-export interface Block {
-  id: string
-  type: string
-  props: Record<string, unknown>
-  slots?: Record<string, Block[]>
-}

package/layers/core/server/utils/collection-types.ts

@@ -1,28 +0,0 @@
-import type { SQLiteTable } from 'drizzle-orm/sqlite-core'
-import type { z } from 'zod'
-import type { CollectionDef } from './defineCollection'
-
-/** The validation schemas are loose `ZodObject`s. drizzle-zod's builders are overloaded such that
- *  `ReturnType<typeof createInsertSchema>` resolves to the WRONG (ZodEnum) overload, so the shape is stated
- *  directly — `ZodObject` carries the `.safeParse()` / `.partial()` the CRUD layer calls; `buildCollection`
- *  casts the builder results to it. */
-export type CollectionSchema = z.ZodObject<z.ZodRawShape>
-
-export interface ConditionIssue {
-  path: (string | number)[]
-  message: string
-}
-
-export interface BuiltCollection {
-  name: string
-  def: CollectionDef
-  table: SQLiteTable
-  insert: CollectionSchema
-  update: CollectionSchema
-  select: CollectionSchema
-  /** Every pre-write check the per-field schema can't do because it sees one field at a time: `required`
-   *  re-enforced for conditional fields whose condition is met against the whole record, plus the
-   *  collection's own `def.validate`. Returns Zod-shaped issues keyed by the field's def name. Present
-   *  only when the collection has conditional required fields or a `validate`. */
-  applyConditions?: (record: Record<string, unknown>) => { issues: ConditionIssue[] }
-}