@sedrino/db-schema 0.1.1 → 0.1.2

package/dist/index.js

@@ -130,6 +130,29 @@ function toSnakeCase(value) {
 function toPascalCase(value) {
   return value.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/\s+/).filter(Boolean).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
 }
+function toCamelCase(value) {
+  const pascal = toPascalCase(value);
+  return pascal.length > 0 ? `${pascal[0].toLowerCase()}${pascal.slice(1)}` : pascal;
+}
+function pluralize(value) {
+  if (value.endsWith("s")) return `${value}es`;
+  if (value.endsWith("y") && !/[aeiou]y$/i.test(value)) {
+    return `${value.slice(0, -1)}ies`;
+  }
+  return `${value}s`;
+}
+function singularize(value) {
+  if (value.endsWith("ies") && value.length > 3) {
+    return `${value.slice(0, -3)}y`;
+  }
+  if (value.endsWith("ses") && value.length > 3) {
+    return value.slice(0, -2);
+  }
+  if (value.endsWith("s") && !value.endsWith("ss") && value.length > 1) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
 function quoteIdentifier(value) {
   return `"${value.replace(/"/g, '""')}"`;
 }
@@ -142,23 +165,23 @@ function fieldAutoId(tableName, fieldName) {
 function tableAutoId(tableName) {
   return `tbl_${toSnakeCase(tableName)}`;
 }
-function defaultStorageForLogical(logical, column) {
+function defaultStorageForLogical(logical, column2) {
   switch (logical.kind) {
     case "id":
     case "string":
     case "text":
     case "enum":
     case "json":
-      return { strategy: "sqlite.text", column };
+      return { strategy: "sqlite.text", column: column2 };
     case "boolean":
     case "integer":
-      return { strategy: "sqlite.integer", column };
+      return { strategy: "sqlite.integer", column: column2 };
     case "number":
-      return { strategy: "sqlite.real", column };
+      return { strategy: "sqlite.real", column: column2 };
     case "temporal.instant":
-      return { strategy: "sqlite.temporalInstantEpochMs", column };
+      return { strategy: "sqlite.temporalInstantEpochMs", column: column2 };
     case "temporal.plainDate":
-      return { strategy: "sqlite.temporalPlainDateText", column };
+      return { strategy: "sqlite.temporalPlainDateText", column: column2 };
   }
 }
 function validateLogicalAndStorageCompatibility(logical, storage) {
@@ -196,6 +219,7 @@ function validateDefaultCompatibility(field, defaultValue) {
 function validateSchemaDocumentCompatibility(schema) {
   const issues = [];
   const tableNames = /* @__PURE__ */ new Set();
+  const indexNames = /* @__PURE__ */ new Set();
   for (const table of schema.tables) {
     if (tableNames.has(table.name)) {
       issues.push({
@@ -205,6 +229,7 @@ function validateSchemaDocumentCompatibility(schema) {
     }
     tableNames.add(table.name);
     const fieldNames = /* @__PURE__ */ new Set();
+    const columnNames = /* @__PURE__ */ new Set();
     let primaryKeyCount = 0;
     for (const field of table.fields) {
       if (fieldNames.has(field.name)) {
@@ -214,6 +239,13 @@ function validateSchemaDocumentCompatibility(schema) {
         });
       }
       fieldNames.add(field.name);
+      if (columnNames.has(field.storage.column)) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: `Duplicate column name ${field.storage.column}`
+        });
+      }
+      columnNames.add(field.storage.column);
       if (field.primaryKey) primaryKeyCount += 1;
       if (field.primaryKey && field.nullable) {
         issues.push({
@@ -270,6 +302,14 @@ function validateSchemaDocumentCompatibility(schema) {
       });
     }
     for (const index of table.indexes) {
+      const indexName = index.name ?? `${table.name}_${index.fields.join("_")}_idx`;
+      if (indexNames.has(indexName)) {
+        issues.push({
+          path: `tables.${table.name}.indexes.${indexName}`,
+          message: `Duplicate index name ${indexName}`
+        });
+      }
+      indexNames.add(indexName);
       for (const fieldName of index.fields) {
         if (!fieldNames.has(fieldName)) {
           issues.push({
@@ -280,6 +320,14 @@ function validateSchemaDocumentCompatibility(schema) {
       }
     }
     for (const unique of table.uniques) {
+      const uniqueName = unique.name ?? `${table.name}_${unique.fields.join("_")}_unique`;
+      if (indexNames.has(uniqueName)) {
+        issues.push({
+          path: `tables.${table.name}.uniques.${uniqueName}`,
+          message: `Duplicate index name ${uniqueName}`
+        });
+      }
+      indexNames.add(uniqueName);
       for (const fieldName of unique.fields) {
         if (!fieldNames.has(fieldName)) {
           issues.push({
@@ -319,18 +367,20 @@ function cloneSchema(value) {
 }
 function renameStorageColumn(field, newFieldName) {
   const next = cloneSchema(field);
-  const column = toSnakeCase(newFieldName);
+  const column2 = toSnakeCase(newFieldName);
   next.name = newFieldName;
-  next.storage = { ...next.storage, column };
+  next.storage = { ...next.storage, column: column2 };
   return next;
 }
 
 // src/migration.ts
 var MutableFieldBuilder = class {
-  constructor(field) {
+  constructor(field, hooks = {}) {
     this.field = field;
+    this.hooks = hooks;
   }
   field;
+  hooks;
   required() {
     this.field.nullable = false;
     return this;
@@ -370,20 +420,136 @@ var MutableFieldBuilder = class {
     this.field.description = description;
     return this;
   }
-  column(column) {
+  column(column2) {
     this.field.storage = {
       ...this.field.storage,
-      column
+      column: column2
     };
     return this;
   }
+  backfillSql(expression) {
+    const value = normalizeSqlExpression(expression);
+    if (!this.hooks.setBackfillSql) {
+      throw new Error("backfillSql is only supported for fields added in alterTable(...)");
+    }
+    this.hooks.setBackfillSql(value.sql);
+    return this;
+  }
+  backfill(expression) {
+    return this.backfillSql(expression);
+  }
   build() {
     return this.field;
   }
 };
+var AlterFieldBuilder = class {
+  patch = {};
+  transform;
+  required() {
+    this.patch.nullable = false;
+    return this;
+  }
+  nullable() {
+    this.patch.nullable = true;
+    return this;
+  }
+  unique() {
+    this.patch.unique = true;
+    return this;
+  }
+  notUnique() {
+    this.patch.unique = false;
+    return this;
+  }
+  default(value) {
+    this.patch.default = {
+      kind: "literal",
+      value
+    };
+    return this;
+  }
+  defaultNow() {
+    this.patch.default = {
+      kind: "now"
+    };
+    return this;
+  }
+  dropDefault() {
+    this.patch.default = null;
+    return this;
+  }
+  references(reference) {
+    this.patch.references = reference;
+    return this;
+  }
+  dropReferences() {
+    this.patch.references = null;
+    return this;
+  }
+  description(description) {
+    this.patch.description = description;
+    return this;
+  }
+  dropDescription() {
+    this.patch.description = null;
+    return this;
+  }
+  column(column2) {
+    this.patch.column = column2;
+    return this;
+  }
+  storage(storage) {
+    this.patch.storage = storage;
+    return this;
+  }
+  usingSql(expression) {
+    this.transform = normalizeSqlExpression(expression);
+    return this;
+  }
+  using(expression) {
+    return this.usingSql(expression);
+  }
+  logical(logical, options = {}) {
+    this.patch.logical = logical;
+    if (options.column !== void 0) this.patch.column = options.column;
+    if (options.storage !== void 0) this.patch.storage = options.storage;
+    return this;
+  }
+  string(options = {}) {
+    return this.logical({ kind: "string", format: options.format }, options);
+  }
+  text(options = {}) {
+    return this.logical({ kind: "text" }, options);
+  }
+  boolean(options = {}) {
+    return this.logical({ kind: "boolean" }, options);
+  }
+  integer(options = {}) {
+    return this.logical({ kind: "integer" }, options);
+  }
+  number(options = {}) {
+    return this.logical({ kind: "number" }, options);
+  }
+  enum(values, options = {}) {
+    return this.logical({ kind: "enum", values }, options);
+  }
+  json(tsType, options = {}) {
+    return this.logical({ kind: "json", tsType }, options);
+  }
+  temporalInstant(options = {}) {
+    return this.logical({ kind: "temporal.instant" }, options);
+  }
+  temporalPlainDate(options = {}) {
+    return this.logical({ kind: "temporal.plainDate" }, options);
+  }
+  reference(options) {
+    this.patch.references = options.references;
+    return this.logical({ kind: "string" }, options);
+  }
+};
 function createFieldSpec(tableName, fieldName, logical, options = {}) {
-  const column = options.column ?? toSnakeCase(fieldName);
-  const storage = options.storage ?? defaultStorageForLogical(logical, column);
+  const column2 = options.column ?? toSnakeCase(fieldName);
+  const storage = options.storage ?? defaultStorageForLogical(logical, column2);
   const storageIssue = validateLogicalAndStorageCompatibility(logical, storage);
   if (storageIssue) throw new Error(storageIssue);
   const field = {
@@ -481,6 +647,24 @@ var TableCreateBuilder = class {
       )
     );
   }
+  belongsTo(targetTable, options = {}) {
+    const fieldName = resolveBelongsToFieldName(targetTable, options.fieldName);
+    const builder = this.reference(fieldName, {
+      ...options,
+      references: {
+        table: targetTable,
+        field: options.referencesField ?? fieldName,
+        onDelete: options.onDelete,
+        onUpdate: options.onUpdate
+      }
+    });
+    if (options.required) builder.required();
+    if (options.unique) builder.unique();
+    if ((options.index ?? !options.unique) === true) {
+      this.index([fieldName], options.indexName ? { name: options.indexName } : {});
+    }
+    return builder;
+  }
   index(fields, options = {}) {
     this.indexes.push({
       fields,
@@ -519,7 +703,11 @@ var TableAlterBuilder = class {
       field
     };
     this.operations.push(operation);
-    return new MutableFieldBuilder(field);
+    return new MutableFieldBuilder(field, {
+      setBackfillSql: (sql) => {
+        operation.backfill = { sql };
+      }
+    });
   }
   string(fieldName, options = {}) {
     return this.addField(
@@ -573,6 +761,24 @@ var TableAlterBuilder = class {
       )
     );
   }
+  belongsTo(targetTable, options = {}) {
+    const fieldName = resolveBelongsToFieldName(targetTable, options.fieldName);
+    const builder = this.reference(fieldName, {
+      ...options,
+      references: {
+        table: targetTable,
+        field: options.referencesField ?? fieldName,
+        onDelete: options.onDelete,
+        onUpdate: options.onUpdate
+      }
+    });
+    if (options.required) builder.required();
+    if (options.unique) builder.unique();
+    if ((options.index ?? !options.unique) === true) {
+      this.addIndex([fieldName], options.indexName ? { name: options.indexName } : {});
+    }
+    return builder;
+  }
   dropField(fieldName) {
     this.operations.push({
       kind: "dropField",
@@ -590,6 +796,21 @@ var TableAlterBuilder = class {
     });
     return this;
   }
+  alterField(fieldName, callback) {
+    const field = new AlterFieldBuilder();
+    callback(field);
+    if (Object.keys(field.patch).length === 0 && !field.transform) {
+      throw new Error(`alterField(${fieldName}) requires at least one field change or usingSql(...)`);
+    }
+    this.operations.push({
+      kind: "alterField",
+      tableName: this.tableName,
+      fieldName,
+      patch: field.patch,
+      transform: field.transform
+    });
+    return this;
+  }
   addIndex(fields, options = {}) {
     this.operations.push({
       kind: "addIndex",
@@ -640,6 +861,34 @@ var MigrationBuilderImpl = class {
     });
     return this;
   }
+  createJunctionTable(name, options) {
+    return this.createTable(name, (table) => {
+      if (options.description) table.description(options.description);
+      const leftFieldName = resolveBelongsToFieldName(options.left.table, options.left.fieldName);
+      const rightFieldName = resolveBelongsToFieldName(options.right.table, options.right.fieldName);
+      table.belongsTo(options.left.table, {
+        fieldName: leftFieldName,
+        referencesField: options.left.referencesField,
+        description: options.left.description,
+        onDelete: options.left.onDelete ?? "cascade",
+        onUpdate: options.left.onUpdate,
+        required: true,
+        index: options.indexes ?? true
+      });
+      table.belongsTo(options.right.table, {
+        fieldName: rightFieldName,
+        referencesField: options.right.referencesField,
+        description: options.right.description,
+        onDelete: options.right.onDelete ?? "cascade",
+        onUpdate: options.right.onUpdate,
+        required: true,
+        index: options.indexes ?? true
+      });
+      if (options.unique ?? true) {
+        table.unique([leftFieldName, rightFieldName], options.uniqueName ? { name: options.uniqueName } : {});
+      }
+    });
+  }
   dropTable(tableName) {
     this.operations.push({
       kind: "dropTable",
@@ -672,6 +921,15 @@ function createMigration(meta, callback) {
     }
   };
 }
+function normalizeSqlExpression(expression) {
+  const value = typeof expression === "string" ? expression.trim() : expression.sql.trim();
+  if (!value) throw new Error("SQL expression must be non-empty");
+  return { sql: value };
+}
+function resolveBelongsToFieldName(targetTable, fieldName) {
+  if (fieldName) return fieldName;
+  return `${toCamelCase(singularize(targetTable))}Id`;
+}
 
 // src/schema.ts
 function createEmptySchema(schemaId = "schema") {
@@ -712,6 +970,223 @@ function findField(table, fieldName) {
   return table.fields.find((field) => field.name === fieldName) ?? null;
 }
 
+// src/operations.ts
+function applyOperationsToSchema(schemaInput, operations) {
+  const schema = cloneSchema(schemaInput);
+  for (const operation of operations) {
+    applyOperationToSchemaMutating(schema, operation);
+  }
+  return assertValidSchemaDocument(schema);
+}
+function applyOperationToSchema(schemaInput, operation) {
+  const schema = cloneSchema(schemaInput);
+  applyOperationToSchemaMutating(schema, operation);
+  return assertValidSchemaDocument(schema);
+}
+function applyOperationToSchemaMutating(schema, operation) {
+  switch (operation.kind) {
+    case "createTable":
+      if (findTable(schema, operation.table.name)) {
+        throw new Error(`Table ${operation.table.name} already exists`);
+      }
+      schema.tables.push(cloneSchema(operation.table));
+      return;
+    case "dropTable": {
+      const referencedBy = schema.tables.flatMap(
+        (table) => table.fields.filter((field) => field.references?.table === operation.tableName).map((field) => `${table.name}.${field.name}`)
+      );
+      if (referencedBy.length > 0) {
+        throw new Error(
+          `Cannot drop table ${operation.tableName}; still referenced by ${referencedBy.join(", ")}`
+        );
+      }
+      const index = schema.tables.findIndex((table) => table.name === operation.tableName);
+      if (index < 0) throw new Error(`Table ${operation.tableName} does not exist`);
+      schema.tables.splice(index, 1);
+      return;
+    }
+    case "renameTable": {
+      const table = findTable(schema, operation.from);
+      if (!table) throw new Error(`Table ${operation.from} does not exist`);
+      if (findTable(schema, operation.to)) {
+        throw new Error(`Table ${operation.to} already exists`);
+      }
+      table.name = operation.to;
+      for (const candidateTable of schema.tables) {
+        for (const field of candidateTable.fields) {
+          if (field.references?.table === operation.from) {
+            field.references = {
+              ...field.references,
+              table: operation.to
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "addField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      if (findField(table, operation.field.name)) {
+        throw new Error(`Field ${operation.tableName}.${operation.field.name} already exists`);
+      }
+      table.fields.push(cloneSchema(operation.field));
+      return;
+    }
+    case "dropField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const fieldIndex = table.fields.findIndex((field) => field.name === operation.fieldName);
+      if (fieldIndex < 0) {
+        throw new Error(`Field ${operation.tableName}.${operation.fieldName} does not exist`);
+      }
+      const referencedBy = schema.tables.flatMap(
+        (candidateTable) => candidateTable.fields.filter(
+          (field) => field.references?.table === operation.tableName && field.references.field === operation.fieldName
+        ).map((field) => `${candidateTable.name}.${field.name}`)
+      );
+      if (referencedBy.length > 0) {
+        throw new Error(
+          `Cannot drop field ${operation.tableName}.${operation.fieldName}; still referenced by ${referencedBy.join(", ")}`
+        );
+      }
+      table.fields.splice(fieldIndex, 1);
+      table.indexes = table.indexes.filter((index) => !index.fields.includes(operation.fieldName));
+      table.uniques = table.uniques.filter((unique) => !unique.fields.includes(operation.fieldName));
+      return;
+    }
+    case "renameField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const field = findField(table, operation.from);
+      if (!field) throw new Error(`Field ${operation.tableName}.${operation.from} does not exist`);
+      if (findField(table, operation.to)) {
+        throw new Error(`Field ${operation.tableName}.${operation.to} already exists`);
+      }
+      const renamed = renameStorageColumn(field, operation.to);
+      const index = table.fields.findIndex((candidate) => candidate.id === field.id);
+      table.fields[index] = renamed;
+      table.indexes = renameFieldInIndexes(table.indexes, operation.from, operation.to);
+      table.uniques = renameFieldInUniques(table.uniques, operation.from, operation.to);
+      for (const candidateTable of schema.tables) {
+        for (const candidateField of candidateTable.fields) {
+          if (candidateField.references?.table === table.name && candidateField.references.field === operation.from) {
+            candidateField.references = {
+              ...candidateField.references,
+              field: operation.to
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "alterField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const field = findField(table, operation.fieldName);
+      if (!field) {
+        throw new Error(`Field ${operation.tableName}.${operation.fieldName} does not exist`);
+      }
+      const nextField = applyAlterFieldPatch(operation.tableName, field, operation.patch);
+      const fieldIndex = table.fields.findIndex((candidate) => candidate.id === field.id);
+      table.fields[fieldIndex] = nextField;
+      return;
+    }
+    case "addIndex": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      table.indexes.push(cloneSchema(operation.index));
+      return;
+    }
+    case "dropIndex": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const nextIndexes = table.indexes.filter(
+        (index) => resolveIndexName(table.name, index) !== operation.indexName
+      );
+      if (nextIndexes.length === table.indexes.length) {
+        throw new Error(`Index ${operation.indexName} does not exist on ${table.name}`);
+      }
+      table.indexes = nextIndexes;
+      return;
+    }
+    case "addUnique": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      table.uniques.push(cloneSchema(operation.unique));
+      return;
+    }
+    case "dropUnique": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const nextUniques = table.uniques.filter(
+        (unique) => resolveUniqueName(table.name, unique) !== operation.uniqueName
+      );
+      if (nextUniques.length === table.uniques.length) {
+        throw new Error(`Unique ${operation.uniqueName} does not exist on ${table.name}`);
+      }
+      table.uniques = nextUniques;
+      return;
+    }
+  }
+}
+function applyAlterFieldPatch(tableName, field, patch) {
+  if (field.primaryKey) {
+    throw new Error(`Field ${tableName}.${field.name} is a primary key and cannot be altered in v1`);
+  }
+  if (patch.logical?.kind === "id") {
+    throw new Error(`Field ${tableName}.${field.name} cannot be altered into an id field in v1`);
+  }
+  const nextLogical = patch.logical ?? field.logical;
+  const nextColumn = patch.column ?? patch.storage?.column ?? field.storage.column;
+  const nextStorage = patch.storage ?? (patch.logical ? defaultStorageForLogical(nextLogical, nextColumn) : { ...field.storage, column: nextColumn });
+  const nextField = {
+    ...cloneSchema(field),
+    logical: cloneSchema(nextLogical),
+    storage: cloneSchema(nextStorage)
+  };
+  if (patch.nullable !== void 0) nextField.nullable = patch.nullable;
+  if (patch.default !== void 0) nextField.default = patch.default ?? void 0;
+  if (patch.unique !== void 0) nextField.unique = patch.unique;
+  if (patch.description !== void 0) nextField.description = patch.description ?? void 0;
+  if (patch.references !== void 0) nextField.references = patch.references ?? void 0;
+  const storageIssue = validateLogicalAndStorageCompatibility(nextField.logical, nextField.storage);
+  if (storageIssue) {
+    throw new Error(`Field ${tableName}.${field.name}: ${storageIssue}`);
+  }
+  if (nextField.default) {
+    const defaultIssue = validateDefaultCompatibility(nextField, nextField.default);
+    if (defaultIssue) {
+      throw new Error(`Field ${tableName}.${field.name}: ${defaultIssue}`);
+    }
+  }
+  return nextField;
+}
+function fieldStorageStrategyChanged(before, after) {
+  return before.storage.strategy !== after.storage.strategy;
+}
+function fieldNullabilityTightened(before, after) {
+  return before.nullable && !after.nullable;
+}
+function resolveIndexName(tableName, index) {
+  return index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+}
+function resolveUniqueName(tableName, unique) {
+  return unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+}
+function renameFieldInIndexes(indexes, from, to) {
+  return indexes.map((index) => ({
+    ...index,
+    fields: index.fields.map((field) => field === from ? to : field)
+  }));
+}
+function renameFieldInUniques(uniques, from, to) {
+  return uniques.map((unique) => ({
+    ...unique,
+    fields: unique.fields.map((field) => field === from ? to : field)
+  }));
+}
+
 // src/sqlite.ts
 function compileSchemaToSqlite(schema) {
   const statements = [];
@@ -722,10 +1197,13 @@ function compileSchemaToSqlite(schema) {
   return `${statements.join("\n\n")}
 `;
 }
-function renderSqliteMigration(operations) {
+function renderSqliteMigration(operations, options = {}) {
   const statements = [];
   const warnings = [];
+  let workingSchema = options.currentSchema ?? createEmptySchema();
+  let rebuildSequence = 0;
   for (const operation of operations) {
+    const nextSchema = applyOperationToSchema(workingSchema, operation);
     switch (operation.kind) {
       case "createTable":
         statements.push(renderCreateTableStatement(operation.table));
@@ -739,11 +1217,6 @@ function renderSqliteMigration(operations) {
           `ALTER TABLE ${quoteIdentifier(operation.from)} RENAME TO ${quoteIdentifier(operation.to)};`
         );
         break;
-      case "addField":
-        statements.push(
-          `ALTER TABLE ${quoteIdentifier(operation.tableName)} ADD COLUMN ${renderColumnDefinition(operation.field)};`
-        );
-        break;
       case "renameField":
         statements.push(
           `ALTER TABLE ${quoteIdentifier(operation.tableName)} RENAME COLUMN ${quoteIdentifier(toSnakeCase(operation.from))} TO ${quoteIdentifier(toSnakeCase(operation.to))};`
@@ -761,12 +1234,31 @@ function renderSqliteMigration(operations) {
       case "dropUnique":
         statements.push(`DROP INDEX ${quoteIdentifier(operation.uniqueName)};`);
         break;
+      case "addField":
       case "dropField":
-        warnings.push(
-          `dropField ${operation.tableName}.${operation.fieldName} requires a table rebuild and is not emitted in v1`
-        );
+      case "alterField": {
+        const tableName = operation.tableName;
+        const beforeTable = findTable(workingSchema, tableName);
+        const afterTable = findTable(nextSchema, tableName);
+        if (!beforeTable || !afterTable) {
+          warnings.push(
+            `operation ${operation.kind} on ${tableName} could not be emitted because the table state was incomplete`
+          );
+          break;
+        }
+        const rebuild = renderTableRebuild({
+          beforeTable,
+          afterTable,
+          operation,
+          sequence: rebuildSequence
+        });
+        rebuildSequence += 1;
+        statements.push(...rebuild.statements);
+        warnings.push(...rebuild.warnings);
         break;
+      }
     }
+    workingSchema = nextSchema;
   }
   return {
     statements,
@@ -848,6 +1340,73 @@ function resolveColumnName(table, fieldName) {
   const field = table?.fields.find((candidate) => candidate.name === fieldName);
   return field?.storage.column ?? toSnakeCase(fieldName);
 }
+function renderTableRebuild(args) {
+  const warnings = [];
+  const tempName = `__sedrino_rebuild_${args.afterTable.name}_${args.sequence}`;
+  const insertColumns = args.afterTable.fields.map((field) => quoteIdentifier(field.storage.column));
+  const selectExpressions = args.afterTable.fields.map(
+    (field) => renderRebuildSelectExpression({
+      beforeTable: args.beforeTable,
+      afterTable: args.afterTable,
+      operation: args.operation,
+      targetField: field,
+      warnings
+    })
+  );
+  const statements = [
+    "PRAGMA foreign_keys = OFF;",
+    `ALTER TABLE ${quoteIdentifier(args.beforeTable.name)} RENAME TO ${quoteIdentifier(tempName)};`,
+    renderCreateTableStatement(args.afterTable),
+    ...renderCreateIndexStatements(args.afterTable),
+    `INSERT INTO ${quoteIdentifier(args.afterTable.name)} (${insertColumns.join(", ")}) SELECT ${selectExpressions.join(", ")} FROM ${quoteIdentifier(tempName)};`,
+    `DROP TABLE ${quoteIdentifier(tempName)};`,
+    "PRAGMA foreign_keys = ON;"
+  ];
+  return {
+    statements,
+    warnings
+  };
+}
+function renderRebuildSelectExpression(args) {
+  const sourceField = args.beforeTable.fields.find((candidate) => candidate.id === args.targetField.id) ?? null;
+  if (!sourceField) {
+    if (args.operation.kind === "addField" && args.operation.field.id === args.targetField.id && args.operation.backfill) {
+      return `(${args.operation.backfill.sql}) AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    }
+    const defaultSql = renderSqlDefault(args.targetField.default, args.targetField);
+    if (defaultSql) return `${defaultSql} AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    if (args.targetField.nullable) {
+      return `NULL AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    }
+    args.warnings.push(
+      `addField ${args.afterTable.name}.${args.targetField.name} is required with no default and cannot be backfilled safely`
+    );
+    return `NULL AS ${quoteIdentifier(args.targetField.storage.column)}`;
+  }
+  if (fieldStorageStrategyChanged(sourceField, args.targetField)) {
+    if (args.operation.kind === "alterField" && args.operation.transform && args.operation.fieldName === args.targetField.name) {
+      return `(${args.operation.transform.sql}) AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    }
+    args.warnings.push(
+      `alterField ${args.afterTable.name}.${args.targetField.name} changes storage strategy from ${sourceField.storage.strategy} to ${args.targetField.storage.strategy}; explicit data transforms are not supported in v1`
+    );
+  }
+  let expression = quoteIdentifier(sourceField.storage.column);
+  if (args.operation.kind === "alterField" && args.operation.transform && args.operation.fieldName === args.targetField.name) {
+    expression = `(${args.operation.transform.sql})`;
+  }
+  if (fieldNullabilityTightened(sourceField, args.targetField) && !(args.operation.kind === "alterField" && args.operation.transform && args.operation.fieldName === args.targetField.name)) {
+    const defaultSql = renderSqlDefault(args.targetField.default, args.targetField);
+    if (defaultSql) {
+      expression = `COALESCE(${expression}, ${defaultSql})`;
+    } else {
+      args.warnings.push(
+        `alterField ${args.afterTable.name}.${args.targetField.name} makes a nullable field required without a default; existing NULL rows would fail during rebuild`
+      );
+    }
+  }
+  return `${expression} AS ${quoteIdentifier(args.targetField.storage.column)}`;
+}
 
 // src/planner.ts
 function planMigration(args) {
@@ -861,7 +1420,7 @@ function planMigration(args) {
     toSchemaHash: createSchemaHash(nextSchema),
     operations,
     nextSchema,
-    sql: renderSqliteMigration(operations)
+    sql: renderSqliteMigration(operations, { currentSchema })
   };
 }
 function materializeSchema(args) {
@@ -880,173 +1439,12 @@ function materializeSchema(args) {
     plans
   };
 }
-function applyOperationsToSchema(schemaInput, operations) {
-  const schema = cloneSchema(schemaInput);
-  for (const operation of operations) {
-    switch (operation.kind) {
-      case "createTable":
-        if (findTable(schema, operation.table.name)) {
-          throw new Error(`Table ${operation.table.name} already exists`);
-        }
-        schema.tables.push(cloneSchema(operation.table));
-        break;
-      case "dropTable": {
-        const referencedBy = schema.tables.flatMap(
-          (table) => table.fields.filter((field) => field.references?.table === operation.tableName).map((field) => `${table.name}.${field.name}`)
-        );
-        if (referencedBy.length > 0) {
-          throw new Error(
-            `Cannot drop table ${operation.tableName}; still referenced by ${referencedBy.join(", ")}`
-          );
-        }
-        const index = schema.tables.findIndex((table) => table.name === operation.tableName);
-        if (index < 0) throw new Error(`Table ${operation.tableName} does not exist`);
-        schema.tables.splice(index, 1);
-        break;
-      }
-      case "renameTable": {
-        const table = findTable(schema, operation.from);
-        if (!table) throw new Error(`Table ${operation.from} does not exist`);
-        if (findTable(schema, operation.to)) {
-          throw new Error(`Table ${operation.to} already exists`);
-        }
-        table.name = operation.to;
-        for (const candidateTable of schema.tables) {
-          for (const field of candidateTable.fields) {
-            if (field.references?.table === operation.from) {
-              field.references = {
-                ...field.references,
-                table: operation.to
-              };
-            }
-          }
-        }
-        break;
-      }
-      case "addField": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        if (findField(table, operation.field.name)) {
-          throw new Error(`Field ${operation.tableName}.${operation.field.name} already exists`);
-        }
-        table.fields.push(cloneSchema(operation.field));
-        break;
-      }
-      case "dropField": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        const fieldIndex = table.fields.findIndex((field) => field.name === operation.fieldName);
-        if (fieldIndex < 0) {
-          throw new Error(`Field ${operation.tableName}.${operation.fieldName} does not exist`);
-        }
-        const referencedBy = schema.tables.flatMap(
-          (candidateTable) => candidateTable.fields.filter(
-            (field) => field.references?.table === operation.tableName && field.references.field === operation.fieldName
-          ).map((field) => `${candidateTable.name}.${field.name}`)
-        );
-        if (referencedBy.length > 0) {
-          throw new Error(
-            `Cannot drop field ${operation.tableName}.${operation.fieldName}; still referenced by ${referencedBy.join(", ")}`
-          );
-        }
-        table.fields.splice(fieldIndex, 1);
-        table.indexes = table.indexes.filter(
-          (index) => !index.fields.includes(operation.fieldName)
-        );
-        table.uniques = table.uniques.filter(
-          (unique) => !unique.fields.includes(operation.fieldName)
-        );
-        break;
-      }
-      case "renameField": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        const field = findField(table, operation.from);
-        if (!field)
-          throw new Error(`Field ${operation.tableName}.${operation.from} does not exist`);
-        if (findField(table, operation.to)) {
-          throw new Error(`Field ${operation.tableName}.${operation.to} already exists`);
-        }
-        const renamed = renameStorageColumn(field, operation.to);
-        const index = table.fields.findIndex((candidate) => candidate.id === field.id);
-        table.fields[index] = renamed;
-        table.indexes = renameFieldInIndexes(table.indexes, operation.from, operation.to);
-        table.uniques = renameFieldInUniques(table.uniques, operation.from, operation.to);
-        for (const candidateTable of schema.tables) {
-          for (const candidateField of candidateTable.fields) {
-            if (candidateField.references?.table === table.name && candidateField.references.field === operation.from) {
-              candidateField.references = {
-                ...candidateField.references,
-                field: operation.to
-              };
-            }
-          }
-        }
-        break;
-      }
-      case "addIndex": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        table.indexes.push(cloneSchema(operation.index));
-        break;
-      }
-      case "dropIndex": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        const nextIndexes = table.indexes.filter(
-          (index) => resolveIndexName(table.name, index) !== operation.indexName
-        );
-        if (nextIndexes.length === table.indexes.length) {
-          throw new Error(`Index ${operation.indexName} does not exist on ${table.name}`);
-        }
-        table.indexes = nextIndexes;
-        break;
-      }
-      case "addUnique": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        table.uniques.push(cloneSchema(operation.unique));
-        break;
-      }
-      case "dropUnique": {
-        const table = findTable(schema, operation.tableName);
-        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
-        const nextUniques = table.uniques.filter(
-          (unique) => resolveUniqueName(table.name, unique) !== operation.uniqueName
-        );
-        if (nextUniques.length === table.uniques.length) {
-          throw new Error(`Unique ${operation.uniqueName} does not exist on ${table.name}`);
-        }
-        table.uniques = nextUniques;
-        break;
-      }
-    }
-  }
-  return assertValidSchemaDocument(schema);
-}
-function renameFieldInIndexes(indexes, from, to) {
-  return indexes.map((index) => ({
-    ...index,
-    fields: index.fields.map((field) => field === from ? to : field)
-  }));
-}
-function renameFieldInUniques(uniques, from, to) {
-  return uniques.map((unique) => ({
-    ...unique,
-    fields: unique.fields.map((field) => field === from ? to : field)
-  }));
-}
-function resolveIndexName(tableName, index) {
-  return index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
-}
-function resolveUniqueName(tableName, unique) {
-  return unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
-}
 
 // src/drizzle.ts
 function compileSchemaToDrizzle(schema) {
   const sqliteImports = /* @__PURE__ */ new Set(["sqliteTable"]);
   const toolkitImports = /* @__PURE__ */ new Set();
+  let needsRelationsImport = false;
   let needsUlid = false;
   for (const table of schema.tables) {
     for (const field of table.fields) {
@@ -1074,11 +1472,15 @@ function compileSchemaToDrizzle(schema) {
       }
       if (field.default?.kind === "generatedId") needsUlid = true;
       if (field.default?.kind === "now") toolkitImports.add("epochMsNow");
+      if (field.references) needsRelationsImport = true;
     }
     if (table.indexes.length > 0) sqliteImports.add("index");
     if (table.uniques.length > 0) sqliteImports.add("uniqueIndex");
   }
   const lines = [];
+  if (needsRelationsImport) {
+    lines.push(`import { defineRelations } from "drizzle-orm";`);
+  }
   lines.push(
     `import { ${Array.from(sqliteImports).sort().join(", ")} } from "drizzle-orm/sqlite-core";`
   );
@@ -1095,8 +1497,47 @@ function compileSchemaToDrizzle(schema) {
     lines.push(renderTable(table));
     lines.push("");
   }
+  const relationsSource = compileSchemaToDrizzleRelations(schema);
+  if (relationsSource) {
+    lines.push(relationsSource);
+    lines.push("");
+  }
   return lines.join("\n").trimEnd() + "\n";
 }
+function compileSchemaToDrizzleRelations(schema) {
+  const directRelations = inferDirectRelations(schema);
+  const manyToManyRelations = inferManyToManyRelations(schema, directRelations.usedKeysByTable);
+  if (directRelations.relations.length === 0 && manyToManyRelations.length === 0) return "";
+  const schemaEntries = schema.tables.map((table) => `  ${tableSchemaKey(table.name)}: ${tableVariableName(table.name)},`).join("\n");
+  const tableBlocks = schema.tables.map((table) => {
+    const tableKey = tableSchemaKey(table.name);
+    const relationLines = directRelations.relations.filter(
+      (relation) => relation.sourceTable.name === table.name || relation.targetTable.name === table.name
+    ).flatMap((relation) => {
+      const lines = [];
+      if (relation.sourceTable.name === table.name) {
+        lines.push(`    ${relation.forwardKey}: ${renderOneRelation(relation)},`);
+      }
+      if (relation.targetTable.name === table.name && !relation.skipReverse) {
+        lines.push(`    ${relation.reverseKey}: ${renderReverseRelation(relation)},`);
+      }
+      return lines;
+    }).concat(
+      manyToManyRelations.filter((relation) => relation.leftTable.name === table.name || relation.rightTable.name === table.name).map(
+        (relation) => relation.leftTable.name === table.name ? `    ${relation.leftKey}: ${renderManyToManyRelation(relation, "left")},` : `    ${relation.rightKey}: ${renderManyToManyRelation(relation, "right")},`
+      )
+    );
+    if (relationLines.length === 0) return null;
+    return `  ${tableKey}: {
+${relationLines.join("\n")}
+  },`;
+  }).filter((block) => block !== null).join("\n");
+  return `export const relations = defineRelations({
+${schemaEntries}
+}, (r) => ({
+${tableBlocks}
+}));`;
+}
 function renderTable(table) {
   const variableName = tableVariableName(table.name);
   const fieldLines = table.fields.map((field) => `  ${field.name}: ${renderField(field)},`);
@@ -1191,6 +1632,373 @@ function renderDrizzleDefault(defaultValue) {
       return JSON.stringify(defaultValue.value);
   }
 }
+function inferDirectRelations(schema) {
+  const junctionTableNames = new Set(inferJunctionCandidates(schema).map((candidate) => candidate.junctionTable.name));
+  const raw2 = schema.tables.flatMap(
+    (sourceTable) => sourceTable.fields.filter((field) => field.references).map((field) => {
+      const targetTable = schema.tables.find((table) => table.name === field.references.table);
+      if (!targetTable) {
+        throw new Error(
+          `Cannot infer relation for ${sourceTable.name}.${field.name}; missing target table ${field.references.table}`
+        );
+      }
+      return {
+        sourceTable,
+        targetTable,
+        sourceField: field,
+        targetFieldName: field.references.field,
+        sourceTableKey: tableSchemaKey(sourceTable.name),
+        targetTableKey: tableSchemaKey(targetTable.name),
+        forwardBase: inferForwardRelationKey(field, targetTable),
+        reverseBase: tableSchemaKey(pluralize(sourceTable.name))
+      };
+    })
+  );
+  const duplicatePairCounts = /* @__PURE__ */ new Map();
+  for (const relation of raw2) {
+    const key = `${relation.sourceTable.name}::${relation.targetTable.name}`;
+    duplicatePairCounts.set(key, (duplicatePairCounts.get(key) ?? 0) + 1);
+  }
+  const usedByTable = /* @__PURE__ */ new Map();
+  return {
+    relations: raw2.map((relation) => {
+      const skipReverse = junctionTableNames.has(relation.sourceTable.name);
+      const pairKey = `${relation.sourceTable.name}::${relation.targetTable.name}`;
+      const needsAlias = (duplicatePairCounts.get(pairKey) ?? 0) > 1;
+      const alias = needsAlias ? relation.forwardBase : null;
+      const sourceUsed = ensureUsedSet(usedByTable, relation.sourceTable.name);
+      const targetUsed = ensureUsedSet(usedByTable, relation.targetTable.name);
+      const reverseKind = inferReverseKind(relation.sourceTable, relation.sourceField);
+      const forwardKey = ensureUniqueKey(
+        sourceUsed,
+        relation.forwardBase,
+        `${relation.forwardBase}${toPascalCase(relation.targetTable.name)}`
+      );
+      const reversePreferred = needsAlias ? `${relation.forwardBase}${toPascalCase(pluralize(relation.sourceTable.name))}` : relation.reverseBase;
+      const reverseFallback = `${relation.forwardBase}${toPascalCase(pluralize(relation.sourceTable.name))}`;
+      const reverseKey = skipReverse ? reversePreferred : ensureUniqueKey(targetUsed, reversePreferred, reverseFallback);
+      return {
+        sourceTable: relation.sourceTable,
+        targetTable: relation.targetTable,
+        sourceField: relation.sourceField,
+        targetFieldName: relation.targetFieldName,
+        sourceTableKey: relation.sourceTableKey,
+        targetTableKey: relation.targetTableKey,
+        forwardKey,
+        reverseKey,
+        alias,
+        reverseKind,
+        skipReverse
+      };
+    }),
+    usedKeysByTable: usedByTable
+  };
+}
+function inferManyToManyRelations(schema, usedByTable) {
+  const candidates = inferJunctionCandidates(schema);
+  const pairCounts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const pairKey = createPairKey(candidate.leftTable.name, candidate.rightTable.name);
+    pairCounts.set(pairKey, (pairCounts.get(pairKey) ?? 0) + 1);
+  }
+  return candidates.map((candidate) => {
+    const pairKey = createPairKey(candidate.leftTable.name, candidate.rightTable.name);
+    const duplicatePair = (pairCounts.get(pairKey) ?? 0) > 1;
+    const selfRelation = candidate.leftTable.name === candidate.rightTable.name;
+    const alias = duplicatePair || selfRelation ? tableSchemaKey(candidate.junctionTable.name) : null;
+    const leftUsed = ensureUsedSet(usedByTable, candidate.leftTable.name);
+    const rightUsed = ensureUsedSet(usedByTable, candidate.rightTable.name);
+    const leftPreferred = inferManyToManyKey(candidate.rightTable, candidate.rightField, selfRelation);
+    const rightPreferred = inferManyToManyKey(candidate.leftTable, candidate.leftField, selfRelation);
+    const leftFallback = `${leftPreferred}${toPascalCase(candidate.junctionTable.name)}`;
+    const rightFallback = `${rightPreferred}${toPascalCase(candidate.junctionTable.name)}`;
+    return {
+      junctionTable: candidate.junctionTable,
+      leftTable: candidate.leftTable,
+      rightTable: candidate.rightTable,
+      leftField: candidate.leftField,
+      rightField: candidate.rightField,
+      leftTargetFieldName: candidate.leftField.references.field,
+      rightTargetFieldName: candidate.rightField.references.field,
+      junctionTableKey: tableSchemaKey(candidate.junctionTable.name),
+      leftTableKey: tableSchemaKey(candidate.leftTable.name),
+      rightTableKey: tableSchemaKey(candidate.rightTable.name),
+      leftKey: ensureUniqueKey(leftUsed, leftPreferred, leftFallback),
+      rightKey: ensureUniqueKey(rightUsed, rightPreferred, rightFallback),
+      alias
+    };
+  });
+}
+function inferJunctionCandidates(schema) {
+  return schema.tables.flatMap((junctionTable) => {
+    const referencedFields = junctionTable.fields.filter((field) => field.references);
+    if (referencedFields.length !== 2) return [];
+    if (junctionTable.fields.length !== 2) return [];
+    const compositeUnique = junctionTable.uniques.some(
+      (unique) => unique.fields.length === 2 && referencedFields.every((field) => unique.fields.includes(field.name))
+    );
+    if (!compositeUnique) return [];
+    const [leftField, rightField] = referencedFields;
+    const leftTable = schema.tables.find((table) => table.name === leftField.references.table);
+    const rightTable = schema.tables.find((table) => table.name === rightField.references.table);
+    if (!leftTable || !rightTable) return [];
+    return [
+      {
+        junctionTable,
+        leftField,
+        rightField,
+        leftTable,
+        rightTable
+      }
+    ];
+  });
+}
+function renderOneRelation(relation) {
+  const options = [
+    `from: r.${relation.sourceTableKey}.${relation.sourceField.name}`,
+    `to: r.${relation.targetTableKey}.${relation.targetFieldName}`
+  ];
+  if (relation.alias) {
+    options.push(`alias: "${relation.alias}"`);
+  }
+  return `r.one.${relation.targetTableKey}({ ${options.join(", ")} })`;
+}
+function renderReverseRelation(relation) {
+  const options = [
+    `from: r.${relation.targetTableKey}.${relation.targetFieldName}`,
+    `to: r.${relation.sourceTableKey}.${relation.sourceField.name}`
+  ];
+  if (relation.alias) {
+    options.push(`alias: "${relation.alias}"`);
+  }
+  return `r.${relation.reverseKind}.${relation.sourceTableKey}({ ${options.join(", ")} })`;
+}
+function renderManyToManyRelation(relation, side) {
+  const isLeft = side === "left";
+  const currentTableKey = isLeft ? relation.leftTableKey : relation.rightTableKey;
+  const currentTargetFieldName = isLeft ? relation.leftTargetFieldName : relation.rightTargetFieldName;
+  const currentJunctionFieldName = isLeft ? relation.leftField.name : relation.rightField.name;
+  const otherTableKey = isLeft ? relation.rightTableKey : relation.leftTableKey;
+  const otherTargetFieldName = isLeft ? relation.rightTargetFieldName : relation.leftTargetFieldName;
+  const otherJunctionFieldName = isLeft ? relation.rightField.name : relation.leftField.name;
+  const options = [
+    `from: r.${currentTableKey}.${currentTargetFieldName}.through(r.${relation.junctionTableKey}.${currentJunctionFieldName})`,
+    `to: r.${otherTableKey}.${otherTargetFieldName}.through(r.${relation.junctionTableKey}.${otherJunctionFieldName})`
+  ];
+  if (relation.alias) {
+    options.push(`alias: "${relation.alias}"`);
+  }
+  return `r.many.${otherTableKey}({ ${options.join(", ")} })`;
+}
+function inferForwardRelationKey(field, targetTable) {
+  const trimmed2 = field.name.replace(/Id$/, "").replace(/Ids$/, "").replace(/Ref$/, "");
+  const candidate = trimmed2.length > 0 ? trimmed2 : tableSchemaKey(targetTable.name);
+  return toCamelCase(candidate);
+}
+function inferManyToManyKey(targetTable, targetField, selfRelation) {
+  if (!selfRelation) {
+    return tableSchemaKey(pluralize(singularize(targetTable.name)));
+  }
+  return tableSchemaKey(pluralize(inferForwardRelationKey(targetField, targetTable)));
+}
+function inferReverseKind(sourceTable, sourceField) {
+  if (sourceField.primaryKey || sourceField.unique) return "one";
+  const hasSingleFieldUnique = sourceTable.uniques.some(
+    (unique) => unique.fields.length === 1 && unique.fields[0] === sourceField.name
+  );
+  return hasSingleFieldUnique ? "one" : "many";
+}
+function ensureUsedSet(map, key) {
+  const existing = map.get(key);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Set();
+  map.set(key, created);
+  return created;
+}
+function ensureUniqueKey(used, preferred, fallback) {
+  if (!used.has(preferred)) {
+    used.add(preferred);
+    return preferred;
+  }
+  if (!used.has(fallback)) {
+    used.add(fallback);
+    return fallback;
+  }
+  let counter = 2;
+  while (used.has(`${fallback}${counter}`)) {
+    counter += 1;
+  }
+  const candidate = `${fallback}${counter}`;
+  used.add(candidate);
+  return candidate;
+}
+function tableSchemaKey(tableName) {
+  return toCamelCase(tableName);
+}
+function createPairKey(left, right) {
+  return [left, right].sort((a, b) => a.localeCompare(b)).join("::");
+}
+
+// src/sql-expression.ts
+var SqlExpressionBuilder = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  toSqlExpression() {
+    return { sql: this.text };
+  }
+  toString() {
+    return this.text;
+  }
+};
+function sqlExpression(sql) {
+  const value = sql.trim();
+  if (!value) throw new Error("SQL expression must be non-empty");
+  return { sql: value };
+}
+function column(fieldName) {
+  return sqlExpression(quoteIdentifier2(toSnakeCase(fieldName)));
+}
+function raw(sql) {
+  return sqlExpression(sql);
+}
+function literal(value) {
+  if (value === null) return sqlExpression("NULL");
+  if (typeof value === "string") {
+    return sqlExpression(`'${value.replace(/'/g, "''")}'`);
+  }
+  if (typeof value === "boolean") {
+    return sqlExpression(value ? "TRUE" : "FALSE");
+  }
+  return sqlExpression(String(value));
+}
+function lower(expression) {
+  return sqlExpression(`lower(${normalizeExpression(expression)})`);
+}
+function trim(expression) {
+  return sqlExpression(`trim(${normalizeExpression(expression)})`);
+}
+function replace(expression, search, replacement) {
+  return sqlExpression(
+    `replace(${normalizeExpression(expression)}, ${literal(search).sql}, ${literal(replacement).sql})`
+  );
+}
+function cast(expression, sqlType) {
+  return sqlExpression(`CAST(${normalizeExpression(expression)} AS ${sqlType})`);
+}
+function unixepoch(expression) {
+  return sqlExpression(`unixepoch(${normalizeExpression(expression)})`);
+}
+function date(expression) {
+  return sqlExpression(`date(${normalizeExpression(expression)})`);
+}
+function multiply(expression, factor) {
+  return sqlExpression(`${normalizeExpression(expression)} * ${factor}`);
+}
+function coalesce(...expressions) {
+  if (expressions.length === 0) {
+    throw new Error("coalesce requires at least one expression");
+  }
+  return sqlExpression(`COALESCE(${expressions.map((value) => normalizeExpression(value)).join(", ")})`);
+}
+function concat(...expressions) {
+  if (expressions.length === 0) {
+    throw new Error("concat requires at least one expression");
+  }
+  return sqlExpression(expressions.map((value) => normalizeExpression(value)).join(" || "));
+}
+var sqlExpr = {
+  raw,
+  column,
+  literal,
+  lower,
+  trim,
+  replace,
+  cast,
+  unixepoch,
+  date,
+  multiply,
+  coalesce,
+  concat,
+  build(sql) {
+    return new SqlExpressionBuilder(sql).toSqlExpression();
+  }
+};
+function normalizeExpression(expression) {
+  return typeof expression === "string" ? sqlExpression(expression).sql : expression.sql;
+}
+function quoteIdentifier2(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+// src/transforms.ts
+function copy(fieldName) {
+  return column(fieldName);
+}
+function lowercase(source) {
+  return lower(resolveSource(source));
+}
+function trimmed(source) {
+  return trim(resolveSource(source));
+}
+function slugFrom(source, options = {}) {
+  const separator = options.separator ?? "-";
+  return lower(replace(trim(resolveSource(source)), " ", separator));
+}
+function concatFields(fieldNames, options = {}) {
+  if (fieldNames.length === 0) {
+    throw new Error("concatFields requires at least one field name");
+  }
+  const separator = options.separator ?? "";
+  const expressions = [];
+  for (const [index, fieldName] of fieldNames.entries()) {
+    if (index > 0 && separator.length > 0) {
+      expressions.push(literal(separator));
+    }
+    expressions.push(column(fieldName));
+  }
+  return concat(...expressions);
+}
+function coalesceFields(fieldNames, fallback) {
+  if (fieldNames.length === 0) {
+    throw new Error("coalesceFields requires at least one field name");
+  }
+  const expressions = fieldNames.map((fieldName) => column(fieldName));
+  if (fallback !== void 0) expressions.push(resolveFallback(fallback));
+  return coalesce(...expressions);
+}
+function epochMsFromIsoString(source) {
+  return multiply(cast(unixepoch(resolveSource(source)), "INTEGER"), 1e3);
+}
+function plainDateFromIsoString(source) {
+  return date(resolveSource(source));
+}
+function integerFromText(source) {
+  return cast(trim(resolveSource(source)), "INTEGER");
+}
+function realFromText(source) {
+  return cast(trim(resolveSource(source)), "REAL");
+}
+var transforms = {
+  copy,
+  lowercase,
+  trimmed,
+  slugFrom,
+  concatFields,
+  coalesceFields,
+  epochMsFromIsoString,
+  plainDateFromIsoString,
+  integerFromText,
+  realFromText
+};
+function resolveSource(source) {
+  return typeof source === "string" ? column(source) : source;
+}
+function resolveFallback(fallback) {
+  if (typeof fallback === "object" && fallback !== null && "sql" in fallback) return fallback;
+  return literal(fallback);
+}
 
 // src/apply.ts
 import { createClient } from "@libsql/client";
@@ -1276,6 +2084,35 @@ async function listAppliedMigrations(client) {
     appliedAt: getNumber(row.applied_at) ?? 0
   }));
 }
+async function inspectMigrationStatus(args) {
+  const client = args.client ?? createLibsqlClient(assertConnection(args.connection));
+  const metadataTablesPresent = await hasMetadataTables(client);
+  const appliedRows = metadataTablesPresent ? await listAppliedMigrations(client) : [];
+  const appliedIds = new Set(appliedRows.map((row) => row.migrationId));
+  const localMigrationIds = args.migrations.map((migration) => migration.meta.id);
+  const pendingMigrationIds = localMigrationIds.filter((id) => !appliedIds.has(id));
+  const unexpectedDatabaseMigrationIds = appliedRows.map((row) => row.migrationId).filter((id) => !localMigrationIds.includes(id));
+  const appliedLocalMigrations = args.migrations.filter((migration) => appliedIds.has(migration.meta.id));
+  const expectedCurrent = materializeSchema({
+    baseSchema: args.baseSchema,
+    migrations: appliedLocalMigrations
+  }).schema;
+  const currentState = metadataTablesPresent ? await getSchemaState(client) : null;
+  const localSchemaHash = schemaHash(expectedCurrent);
+  const databaseSchemaHash = currentState?.schemaHash ?? null;
+  return {
+    localMigrationIds,
+    appliedMigrationIds: appliedRows.map((row) => row.migrationId),
+    pendingMigrationIds,
+    unexpectedDatabaseMigrationIds,
+    schemaHash: {
+      local: localSchemaHash,
+      database: databaseSchemaHash,
+      driftDetected: databaseSchemaHash !== null && databaseSchemaHash !== localSchemaHash
+    },
+    metadataTablesPresent
+  };
+}
 async function getSchemaState(client) {
   const result = await client.execute(
     `SELECT schema_hash, schema_json
@@ -1317,6 +2154,17 @@ async function ensureMetadataTables(client) {
     "write"
   );
 }
+async function hasMetadataTables(client) {
+  const result = await client.execute({
+    sql: `SELECT name FROM sqlite_master
+          WHERE type = 'table' AND name IN (?, ?)`,
+    args: [MIGRATIONS_TABLE, STATE_TABLE]
+  });
+  const names = new Set(
+    result.rows.map((row) => getString(row.name)).filter((value) => value !== null)
+  );
+  return names.has(MIGRATIONS_TABLE) && names.has(STATE_TABLE);
+}
 async function executePlan(client, plan) {
   const appliedAt = Date.now();
   const statements = [
@@ -1373,7 +2221,7 @@ function getNumber(value) {
 }
 
 // src/project.ts
-import { mkdir, readdir, writeFile } from "fs/promises";
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
 import path from "path";
 import { pathToFileURL } from "url";
 var MIGRATION_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".js", ".mjs"]);
@@ -1403,12 +2251,38 @@ async function loadMigrationDefinitionsFromDirectory(migrationsDir) {
 }
 async function materializeProjectMigrations(layout) {
   const migrations = await loadMigrationDefinitionsFromDirectory(layout.migrationsDir);
+  assertUniqueMigrationIds(migrations);
   const materialized = materializeSchema({ migrations });
   return {
     ...materialized,
     migrations
   };
 }
+async function validateDbProject(layout) {
+  const materialized = await materializeProjectMigrations(layout);
+  const expectedSnapshot = `${JSON.stringify(materialized.schema, null, 2)}
+`;
+  const expectedDrizzle = compileSchemaToDrizzle(materialized.schema);
+  const warnings = materialized.plans.flatMap(
+    (plan) => plan.sql.warnings.map((warning) => `${plan.migrationId}: ${warning}`)
+  );
+  const [snapshotContents, drizzleContents] = await Promise.all([
+    readTextIfExists(layout.snapshotPath),
+    readTextIfExists(layout.drizzlePath)
+  ]);
+  return {
+    ...materialized,
+    warnings,
+    expectedSnapshot,
+    expectedDrizzle,
+    artifacts: {
+      snapshotExists: snapshotContents !== null,
+      drizzleExists: drizzleContents !== null,
+      snapshotUpToDate: snapshotContents === expectedSnapshot,
+      drizzleUpToDate: drizzleContents === expectedDrizzle
+    }
+  };
+}
 async function writeSchemaSnapshot(schema, snapshotPath) {
   await mkdir(path.dirname(snapshotPath), { recursive: true });
   await writeFile(snapshotPath, `${JSON.stringify(schema, null, 2)}
@@ -1418,16 +2292,45 @@ async function writeDrizzleSchema(schema, drizzlePath) {
   await mkdir(path.dirname(drizzlePath), { recursive: true });
   await writeFile(drizzlePath, compileSchemaToDrizzle(schema), "utf8");
 }
+function assertUniqueMigrationIds(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.meta.id)) {
+      throw new Error(`Duplicate migration id ${migration.meta.id}`);
+    }
+    seen.add(migration.meta.id);
+  }
+}
+async function readTextIfExists(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
 export {
   applyMigrations,
   applyOperationsToSchema,
   assertValidSchemaDocument,
+  cast,
+  coalesce,
+  coalesceFields,
+  column,
   compileSchemaToDrizzle,
+  compileSchemaToDrizzleRelations,
   compileSchemaToSqlite,
+  concat,
+  concatFields,
+  copy,
   createEmptySchema,
   createLibsqlClient,
   createMigration,
+  date,
   defaultSpecSchema,
+  epochMsFromIsoString,
   fieldReferenceSpecSchema,
   fieldSpecSchema,
   findField,
@@ -1435,20 +2338,38 @@ export {
   foreignKeyActionSchema,
   getSchemaState,
   indexSpecSchema,
+  inspectMigrationStatus,
+  integerFromText,
   listAppliedMigrations,
+  literal,
   loadMigrationDefinitionsFromDirectory,
   logicalTypeSpecSchema,
+  lower,
+  lowercase,
   materializeProjectMigrations,
   materializeSchema,
+  multiply,
   parseSchemaDocument,
+  plainDateFromIsoString,
   planMigration,
+  raw,
+  realFromText,
   renderSqliteMigration,
+  replace,
   resolveDbProjectLayout,
   schemaDocumentSchema,
   schemaHash,
+  slugFrom,
+  sqlExpr,
+  sqlExpression,
   storageSpecSchema,
   tableSpecSchema,
+  transforms,
+  trim,
+  trimmed,
   uniqueSpecSchema,
+  unixepoch,
+  validateDbProject,
   validateSchemaDocument,
   writeDrizzleSchema,
   writeSchemaSnapshot