@sedrino/db-schema 0.1.1 → 0.1.2

package/src/sqlite.ts

@@ -8,6 +8,12 @@ import type {
   UniqueSpec,
 } from "./types";
 import type { MigrationOperation } from "./migration";
+import { createEmptySchema, findTable } from "./schema";
+import {
+  applyOperationToSchema,
+  fieldNullabilityTightened,
+  fieldStorageStrategyChanged,
+} from "./operations";
 import { quoteIdentifier, sqliteEpochMsNowSql, toSnakeCase } from "./utils";
 
 export function compileSchemaToSqlite(schema: DatabaseSchemaDocument) {
@@ -21,11 +27,18 @@ export function compileSchemaToSqlite(schema: DatabaseSchemaDocument) {
   return `${statements.join("\n\n")}\n`;
 }
 
-export function renderSqliteMigration(operations: MigrationOperation[]) {
+export function renderSqliteMigration(
+  operations: MigrationOperation[],
+  options: { currentSchema?: DatabaseSchemaDocument } = {},
+) {
   const statements: string[] = [];
   const warnings: string[] = [];
+  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));
@@ -39,11 +52,6 @@ export function renderSqliteMigration(operations: MigrationOperation[]) {
           `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))};`,
@@ -61,12 +69,34 @@ export function renderSqliteMigration(operations: MigrationOperation[]) {
       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 {
@@ -170,3 +200,114 @@ function resolveColumnName(table: TableSpec | undefined, fieldName: string) {
   const field = table?.fields.find((candidate) => candidate.name === fieldName);
   return field?.storage.column ?? toSnakeCase(fieldName);
 }
+
+function renderTableRebuild(args: {
+  beforeTable: TableSpec;
+  afterTable: TableSpec;
+  operation: Extract<MigrationOperation, { kind: "addField" | "dropField" | "alterField" }>;
+  sequence: number;
+}) {
+  const warnings: string[] = [];
+  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: {
+  beforeTable: TableSpec;
+  afterTable: TableSpec;
+  operation: Extract<MigrationOperation, { kind: "addField" | "dropField" | "alterField" }>;
+  targetField: FieldSpec;
+  warnings: string[];
+}) {
+  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)}`;
+}

package/src/transforms.ts

@@ -0,0 +1,94 @@
+import type { MigrationSqlExpression } from "./migration";
+import { cast, coalesce, column, concat, date, literal, lower, multiply, replace, trim, unixepoch } from "./sql-expression";
+
+type Source = string | MigrationSqlExpression;
+type Fallback = string | number | boolean | null | MigrationSqlExpression;
+
+export function copy(fieldName: string): MigrationSqlExpression {
+  return column(fieldName);
+}
+
+export function lowercase(source: Source): MigrationSqlExpression {
+  return lower(resolveSource(source));
+}
+
+export function trimmed(source: Source): MigrationSqlExpression {
+  return trim(resolveSource(source));
+}
+
+export function slugFrom(source: Source, options: { separator?: string } = {}): MigrationSqlExpression {
+  const separator = options.separator ?? "-";
+  return lower(replace(trim(resolveSource(source)), " ", separator));
+}
+
+export function concatFields(
+  fieldNames: string[],
+  options: { separator?: string } = {},
+): MigrationSqlExpression {
+  if (fieldNames.length === 0) {
+    throw new Error("concatFields requires at least one field name");
+  }
+
+  const separator = options.separator ?? "";
+  const expressions: MigrationSqlExpression[] = [];
+
+  for (const [index, fieldName] of fieldNames.entries()) {
+    if (index > 0 && separator.length > 0) {
+      expressions.push(literal(separator));
+    }
+    expressions.push(column(fieldName));
+  }
+
+  return concat(...expressions);
+}
+
+export function coalesceFields(
+  fieldNames: string[],
+  fallback?: Fallback,
+): MigrationSqlExpression {
+  if (fieldNames.length === 0) {
+    throw new Error("coalesceFields requires at least one field name");
+  }
+
+  const expressions = fieldNames.map((fieldName) => column(fieldName));
+  if (fallback !== undefined) expressions.push(resolveFallback(fallback));
+  return coalesce(...expressions);
+}
+
+export function epochMsFromIsoString(source: Source): MigrationSqlExpression {
+  return multiply(cast(unixepoch(resolveSource(source)), "INTEGER"), 1000);
+}
+
+export function plainDateFromIsoString(source: Source): MigrationSqlExpression {
+  return date(resolveSource(source));
+}
+
+export function integerFromText(source: Source): MigrationSqlExpression {
+  return cast(trim(resolveSource(source)), "INTEGER");
+}
+
+export function realFromText(source: Source): MigrationSqlExpression {
+  return cast(trim(resolveSource(source)), "REAL");
+}
+
+export const transforms = {
+  copy,
+  lowercase,
+  trimmed,
+  slugFrom,
+  concatFields,
+  coalesceFields,
+  epochMsFromIsoString,
+  plainDateFromIsoString,
+  integerFromText,
+  realFromText,
+};
+
+function resolveSource(source: Source) {
+  return typeof source === "string" ? column(source) : source;
+}
+
+function resolveFallback(fallback: Fallback) {
+  if (typeof fallback === "object" && fallback !== null && "sql" in fallback) return fallback;
+  return literal(fallback);
+}

package/src/utils.ts

@@ -32,6 +32,32 @@ export function toPascalCase(value: string) {
     .join("");
 }
 
+export function toCamelCase(value: string) {
+  const pascal = toPascalCase(value);
+  return pascal.length > 0 ? `${pascal[0]!.toLowerCase()}${pascal.slice(1)}` : pascal;
+}
+
+export function pluralize(value: string) {
+  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`;
+}
+
+export function singularize(value: string) {
+  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;
+}
+
 export function quoteIdentifier(value: string) {
   return `"${value.replace(/"/g, '""')}"`;
 }
@@ -132,6 +158,7 @@ export function validateSchemaDocumentCompatibility(
 ): SchemaValidationIssue[] {
   const issues: SchemaValidationIssue[] = [];
   const tableNames = new Set<string>();
+  const indexNames = new Set<string>();
 
   for (const table of schema.tables) {
     if (tableNames.has(table.name)) {
@@ -143,6 +170,7 @@ export function validateSchemaDocumentCompatibility(
     tableNames.add(table.name);
 
     const fieldNames = new Set<string>();
+    const columnNames = new Set<string>();
     let primaryKeyCount = 0;
 
     for (const field of table.fields) {
@@ -154,6 +182,14 @@ export function validateSchemaDocumentCompatibility(
       }
       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({
@@ -217,6 +253,15 @@ export function validateSchemaDocumentCompatibility(
     }
 
     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({
@@ -228,6 +273,15 @@ export function validateSchemaDocumentCompatibility(
     }
 
     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({