@sedrino/db-schema 0.1.1 → 0.1.2

package/src/planner.ts

@@ -1,8 +1,11 @@
-import type { DatabaseSchemaDocument, IndexSpec, TableSpec, UniqueSpec } from "./types";
+import type { DatabaseSchemaDocument } from "./types";
 import { type MigrationDefinition, type MigrationOperation } from "./migration";
-import { assertValidSchemaDocument, createEmptySchema, findField, findTable } from "./schema";
+import { assertValidSchemaDocument, createEmptySchema } from "./schema";
+import { applyOperationsToSchema } from "./operations";
 import { renderSqliteMigration } from "./sqlite";
-import { cloneSchema, createSchemaHash, renameStorageColumn } from "./utils";
+import { createSchemaHash } from "./utils";
+
+export { applyOperationsToSchema } from "./operations";
 
 export type PlannedMigration = {
   migrationId: string;
@@ -34,7 +37,7 @@ export function planMigration(args: {
     toSchemaHash: createSchemaHash(nextSchema),
     operations,
     nextSchema,
-    sql: renderSqliteMigration(operations),
+    sql: renderSqliteMigration(operations, { currentSchema }),
   };
 }
 
@@ -59,189 +62,3 @@ export function materializeSchema(args: {
     plans,
   };
 }
-
-export function applyOperationsToSchema(
-  schemaInput: DatabaseSchemaDocument,
-  operations: MigrationOperation[],
-) {
-  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: IndexSpec[], from: string, to: string): IndexSpec[] {
-  return indexes.map((index) => ({
-    ...index,
-    fields: index.fields.map((field) => (field === from ? to : field)),
-  }));
-}
-
-function renameFieldInUniques(uniques: UniqueSpec[], from: string, to: string): UniqueSpec[] {
-  return uniques.map((unique) => ({
-    ...unique,
-    fields: unique.fields.map((field) => (field === from ? to : field)),
-  }));
-}
-
-function resolveIndexName(tableName: string, index: IndexSpec) {
-  return index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
-}
-
-function resolveUniqueName(tableName: string, unique: UniqueSpec) {
-  return unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
-}

package/src/project.ts

@@ -1,4 +1,4 @@
-import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import type { DatabaseSchemaDocument } from "./types";
@@ -16,6 +16,13 @@ export type DbProjectLayout = {
   drizzlePath: string;
 };
 
+export type CreatedMigrationFile = {
+  filePath: string;
+  fileName: string;
+  migrationId: string;
+  migrationName: string;
+};
+
 export function resolveDbProjectLayout(dbDir = "db"): DbProjectLayout {
   const absoluteDbDir = path.resolve(dbDir);
   return {
@@ -61,6 +68,7 @@ export async function loadMigrationDefinitionsFromDirectory(
 
 export async function materializeProjectMigrations(layout: DbProjectLayout) {
   const migrations = await loadMigrationDefinitionsFromDirectory(layout.migrationsDir);
+  assertUniqueMigrationIds(migrations);
   const materialized = materializeSchema({ migrations });
   return {
     ...materialized,
@@ -68,6 +76,67 @@ export async function materializeProjectMigrations(layout: DbProjectLayout) {
   };
 }
 
+export async function createMigrationScaffold(
+  layout: DbProjectLayout,
+  rawName: string,
+  now = new Date(),
+): Promise<CreatedMigrationFile> {
+  const slug = toKebabCase(rawName);
+  if (!slug) {
+    throw new Error("Migration name must contain at least one letter or number");
+  }
+
+  await mkdir(layout.migrationsDir, { recursive: true });
+
+  const datePrefix = formatMigrationDate(now);
+  const sequence = await nextMigrationSequence(layout.migrationsDir, datePrefix);
+  const sequenceText = String(sequence).padStart(3, "0");
+  const migrationId = `${datePrefix}-${sequenceText}-${slug}`;
+  const fileName = `${migrationId}.ts`;
+  const filePath = path.join(layout.migrationsDir, fileName);
+  const migrationName = humanizeMigrationName(slug);
+  const source = renderMigrationTemplate({
+    migrationId,
+    migrationName,
+  });
+
+  await writeFile(filePath, source, { encoding: "utf8", flag: "wx" });
+
+  return {
+    filePath,
+    fileName,
+    migrationId,
+    migrationName,
+  };
+}
+
+export async function validateDbProject(layout: DbProjectLayout) {
+  const materialized = await materializeProjectMigrations(layout);
+  const expectedSnapshot = `${JSON.stringify(materialized.schema, null, 2)}\n`;
+  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,
+    },
+  };
+}
+
 export async function writeSchemaSnapshot(schema: DatabaseSchemaDocument, snapshotPath: string) {
   await mkdir(path.dirname(snapshotPath), { recursive: true });
   await writeFile(snapshotPath, `${JSON.stringify(schema, null, 2)}\n`, "utf8");
@@ -77,3 +146,90 @@ export async function writeDrizzleSchema(schema: DatabaseSchemaDocument, drizzle
   await mkdir(path.dirname(drizzlePath), { recursive: true });
   await writeFile(drizzlePath, compileSchemaToDrizzle(schema), "utf8");
 }
+
+function assertUniqueMigrationIds(migrations: MigrationDefinition[]) {
+  const seen = new Set<string>();
+  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: string) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function nextMigrationSequence(migrationsDir: string, datePrefix: string) {
+  const files = await readdir(migrationsDir, { withFileTypes: true });
+  let maxSequence = 0;
+
+  for (const entry of files) {
+    if (!entry.isFile()) continue;
+    const match = entry.name.match(/^(\d{4}-\d{2}-\d{2})-(\d{3})(?:-[^.]+)?\.(?:ts|mts|js|mjs)$/);
+    if (!match) continue;
+    if (match[1] !== datePrefix) continue;
+
+    const parsed = Number(match[2]);
+    if (Number.isInteger(parsed) && parsed > maxSequence) {
+      maxSequence = parsed;
+    }
+  }
+
+  return maxSequence + 1;
+}
+
+function formatMigrationDate(date: Date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function toKebabCase(value: string) {
+  return value
+    .trim()
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1-$2")
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+}
+
+function humanizeMigrationName(slug: string) {
+  const parts = slug.split("-").filter(Boolean);
+  const first = parts[0];
+  if (!first) return "New migration";
+
+  const rest = parts.slice(1);
+  return [
+    `${first[0]!.toUpperCase()}${first.slice(1)}`,
+    ...rest,
+  ].join(" ");
+}
+
+function renderMigrationTemplate(args: {
+  migrationId: string;
+  migrationName: string;
+}) {
+  return `import { createMigration } from "@sedrino/db-schema";
+
+export default createMigration(
+  {
+    id: ${JSON.stringify(args.migrationId)},
+    name: ${JSON.stringify(args.migrationName)},
+  },
+  (m) => {
+    // TODO: define migration operations.
+  },
+);
+`;
+}

package/src/sql-expression.ts

@@ -0,0 +1,123 @@
+import { toSnakeCase } from "./utils";
+import type { MigrationSqlExpression } from "./migration";
+
+class SqlExpressionBuilder {
+  constructor(private readonly text: string) {}
+
+  toSqlExpression(): MigrationSqlExpression {
+    return { sql: this.text };
+  }
+
+  toString() {
+    return this.text;
+  }
+}
+
+export function sqlExpression(sql: string): MigrationSqlExpression {
+  const value = sql.trim();
+  if (!value) throw new Error("SQL expression must be non-empty");
+  return { sql: value };
+}
+
+export function column(fieldName: string): MigrationSqlExpression {
+  return sqlExpression(quoteIdentifier(toSnakeCase(fieldName)));
+}
+
+export function raw(sql: string): MigrationSqlExpression {
+  return sqlExpression(sql);
+}
+
+export function literal(value: string | number | boolean | null): MigrationSqlExpression {
+  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));
+}
+
+export function lower(expression: MigrationSqlExpression | string): MigrationSqlExpression {
+  return sqlExpression(`lower(${normalizeExpression(expression)})`);
+}
+
+export function trim(expression: MigrationSqlExpression | string): MigrationSqlExpression {
+  return sqlExpression(`trim(${normalizeExpression(expression)})`);
+}
+
+export function replace(
+  expression: MigrationSqlExpression | string,
+  search: string,
+  replacement: string,
+): MigrationSqlExpression {
+  return sqlExpression(
+    `replace(${normalizeExpression(expression)}, ${literal(search).sql}, ${literal(replacement).sql})`,
+  );
+}
+
+export function cast(
+  expression: MigrationSqlExpression | string,
+  sqlType: "INTEGER" | "REAL" | "TEXT",
+): MigrationSqlExpression {
+  return sqlExpression(`CAST(${normalizeExpression(expression)} AS ${sqlType})`);
+}
+
+export function unixepoch(expression: MigrationSqlExpression | string): MigrationSqlExpression {
+  return sqlExpression(`unixepoch(${normalizeExpression(expression)})`);
+}
+
+export function date(expression: MigrationSqlExpression | string): MigrationSqlExpression {
+  return sqlExpression(`date(${normalizeExpression(expression)})`);
+}
+
+export function multiply(
+  expression: MigrationSqlExpression | string,
+  factor: number,
+): MigrationSqlExpression {
+  return sqlExpression(`${normalizeExpression(expression)} * ${factor}`);
+}
+
+export function coalesce(
+  ...expressions: Array<MigrationSqlExpression | string>
+): MigrationSqlExpression {
+  if (expressions.length === 0) {
+    throw new Error("coalesce requires at least one expression");
+  }
+  return sqlExpression(`COALESCE(${expressions.map((value) => normalizeExpression(value)).join(", ")})`);
+}
+
+export function concat(
+  ...expressions: Array<MigrationSqlExpression | string>
+): MigrationSqlExpression {
+  if (expressions.length === 0) {
+    throw new Error("concat requires at least one expression");
+  }
+  return sqlExpression(expressions.map((value) => normalizeExpression(value)).join(" || "));
+}
+
+export const sqlExpr = {
+  raw,
+  column,
+  literal,
+  lower,
+  trim,
+  replace,
+  cast,
+  unixepoch,
+  date,
+  multiply,
+  coalesce,
+  concat,
+  build(sql: string) {
+    return new SqlExpressionBuilder(sql).toSqlExpression();
+  },
+};
+
+function normalizeExpression(expression: MigrationSqlExpression | string) {
+  return typeof expression === "string" ? sqlExpression(expression).sql : expression.sql;
+}
+
+function quoteIdentifier(value: string) {
+  return `"${value.replace(/"/g, '""')}"`;
+}