@topogram/cli 0.3.34

package/src/generator/surfaces/databases/migration-plan.js

@@ -0,0 +1,281 @@
+import { generateDbSchemaSnapshot } from "./snapshot.js";
+
+function fieldSetKey(fields) {
+  return fields.join("|");
+}
+
+function relationKey(relation) {
+  return `${relation.field}:${relation.target?.id || ""}:${relation.target?.field || ""}:${relation.onDelete || ""}`;
+}
+
+function findInsertedEnumValues(previousValues, nextValues) {
+  const previousSet = new Set(previousValues);
+  const inserted = [];
+  let previousIndex = 0;
+
+  for (const value of nextValues) {
+    if (previousIndex < previousValues.length && previousValues[previousIndex] === value) {
+      previousIndex += 1;
+      continue;
+    }
+    if (previousSet.has(value)) {
+      return null;
+    }
+    inserted.push(value);
+  }
+
+  if (previousIndex !== previousValues.length) {
+    return null;
+  }
+
+  return inserted;
+}
+
+function enumPlacement(nextValues, value, previousValues) {
+  const index = nextValues.indexOf(value);
+  for (let cursor = index + 1; cursor < nextValues.length; cursor += 1) {
+    const candidate = nextValues[cursor];
+    if (previousValues.includes(candidate)) {
+      return { before: candidate, after: null };
+    }
+  }
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const candidate = nextValues[cursor];
+    if (previousValues.includes(candidate)) {
+      return { before: null, after: candidate };
+    }
+  }
+  return { before: null, after: null };
+}
+
+export function buildDbMigrationPlan(fromSnapshot, toSnapshot, options = {}) {
+  const operations = [];
+  const manual = [];
+  const fromEnums = new Map((fromSnapshot.enums || []).map((entry) => [entry.id, entry]));
+  const toEnums = new Map((toSnapshot.enums || []).map((entry) => [entry.id, entry]));
+  const fromTables = new Map((fromSnapshot.tables || []).map((table) => [table.table, table]));
+  const toTables = new Map((toSnapshot.tables || []).map((table) => [table.table, table]));
+
+  for (const enumEntry of toSnapshot.enums || []) {
+    const previous = fromEnums.get(enumEntry.id);
+    if (!previous) {
+      operations.push({
+        type: "create_enum",
+        enum: enumEntry.id,
+        values: [...enumEntry.values]
+      });
+      continue;
+    }
+
+    const inserted = findInsertedEnumValues(previous.values || [], enumEntry.values || []);
+    if (inserted == null) {
+      manual.push({
+        type: "alter_enum",
+        enum: enumEntry.id,
+        reason: "Enum values changed in a non-additive way"
+      });
+      continue;
+    }
+
+    for (const value of inserted) {
+      const placement = enumPlacement(enumEntry.values || [], value, previous.values || []);
+      operations.push({
+        type: "add_enum_value",
+        enum: enumEntry.id,
+        value,
+        before: placement.before,
+        after: placement.after
+      });
+    }
+  }
+
+  for (const enumEntry of fromSnapshot.enums || []) {
+    if (!toEnums.has(enumEntry.id)) {
+      manual.push({
+        type: "drop_enum",
+        enum: enumEntry.id,
+        reason: "Dropping enums is not generated automatically"
+      });
+    }
+  }
+
+  for (const table of toSnapshot.tables || []) {
+    const previous = fromTables.get(table.table);
+    if (!previous) {
+      operations.push({
+        type: "create_table",
+        table: table.table,
+        entity: table.entity?.id || null
+      });
+      for (const index of table.indexes || []) {
+        if (index.type !== "index") {
+          continue;
+        }
+        operations.push({
+          type: "add_index",
+          table: table.table,
+          fields: index.fields
+        });
+      }
+      continue;
+    }
+
+    const previousColumns = new Map((previous.columns || []).map((column) => [column.name, column]));
+    const nextColumns = new Map((table.columns || []).map((column) => [column.name, column]));
+
+    for (const column of table.columns || []) {
+      const previousColumn = previousColumns.get(column.name);
+      if (!previousColumn) {
+        operations.push({
+          type: "add_column",
+          table: table.table,
+          column: column.name
+        });
+        continue;
+      }
+
+      const changed =
+        previousColumn.sourceField !== column.sourceField ||
+        previousColumn.fieldType !== column.fieldType ||
+        previousColumn.dbType !== column.dbType ||
+        previousColumn.required !== column.required ||
+        previousColumn.defaultSql !== column.defaultSql;
+
+      if (changed) {
+        manual.push({
+          type: "alter_column",
+          table: table.table,
+          column: column.name,
+          reason: "Column definition changed in a non-additive way"
+        });
+      }
+    }
+
+    for (const column of previous.columns || []) {
+      if (!nextColumns.has(column.name)) {
+        manual.push({
+          type: "drop_column",
+          table: table.table,
+          column: column.name,
+          reason: "Dropping columns is not generated automatically"
+        });
+      }
+    }
+
+    const previousUniqueKeys = new Set((previous.uniques || []).map(fieldSetKey));
+    const nextUniqueKeys = new Set((table.uniques || []).map(fieldSetKey));
+    for (const unique of table.uniques || []) {
+      const key = fieldSetKey(unique);
+      if (!previousUniqueKeys.has(key)) {
+        operations.push({
+          type: "add_unique_constraint",
+          table: table.table,
+          fields: unique
+        });
+      }
+    }
+    for (const unique of previous.uniques || []) {
+      const key = fieldSetKey(unique);
+      if (!nextUniqueKeys.has(key)) {
+        manual.push({
+          type: "drop_unique_constraint",
+          table: table.table,
+          fields: unique,
+          reason: "Dropping unique constraints is not generated automatically"
+        });
+      }
+    }
+
+    const previousIndexes = new Set((previous.indexes || []).map((entry) => `${entry.type}:${fieldSetKey(entry.fields)}`));
+    const nextIndexes = new Set((table.indexes || []).map((entry) => `${entry.type}:${fieldSetKey(entry.fields)}`));
+    for (const index of table.indexes || []) {
+      const key = `${index.type}:${fieldSetKey(index.fields)}`;
+      if (!previousIndexes.has(key)) {
+        if (index.type !== "index") {
+          continue;
+        }
+        operations.push({
+          type: "add_index",
+          table: table.table,
+          fields: index.fields
+        });
+      }
+    }
+    for (const index of previous.indexes || []) {
+      const key = `${index.type}:${fieldSetKey(index.fields)}`;
+      if (!nextIndexes.has(key)) {
+        manual.push({
+          type: "drop_index",
+          table: table.table,
+          fields: index.fields,
+          reason: "Dropping indexes is not generated automatically"
+        });
+      }
+    }
+
+    const previousRelations = new Set((previous.relations || []).map(relationKey));
+    const nextRelations = new Set((table.relations || []).map(relationKey));
+    for (const relation of table.relations || []) {
+      const key = relationKey(relation);
+      if (!previousRelations.has(key)) {
+        operations.push({
+          type: "add_foreign_key",
+          table: table.table,
+          field: relation.field,
+          target: relation.target,
+          onDelete: relation.onDelete || null
+        });
+      }
+    }
+    for (const relation of previous.relations || []) {
+      const key = relationKey(relation);
+      if (!nextRelations.has(key)) {
+        manual.push({
+          type: "drop_foreign_key",
+          table: table.table,
+          field: relation.field,
+          reason: "Dropping or changing foreign keys is not generated automatically"
+        });
+      }
+    }
+  }
+
+  for (const table of fromSnapshot.tables || []) {
+    if (!toTables.has(table.table)) {
+      manual.push({
+        type: "drop_table",
+        table: table.table,
+        reason: "Dropping tables is not generated automatically"
+      });
+    }
+  }
+
+  return {
+    type: "db_migration_plan",
+    projection: toSnapshot.projection,
+    engine: toSnapshot.engine,
+    from: {
+      snapshotPath: options.fromSnapshotPath || null,
+      tableCount: (fromSnapshot.tables || []).length
+    },
+    to: {
+      tableCount: (toSnapshot.tables || []).length
+    },
+    supported: manual.length === 0,
+    operations,
+    manualInterventionRequired: manual.length > 0,
+    manual
+  };
+}
+
+export function generateDbMigrationPlan(graph, options = {}) {
+  if (!options.projectionId) {
+    throw new Error("db-migration-plan requires --projection");
+  }
+  if (!options.fromSnapshot) {
+    throw new Error("db-migration-plan requires --from-snapshot");
+  }
+
+  const toSnapshot = generateDbSchemaSnapshot(graph, options);
+  return buildDbMigrationPlan(options.fromSnapshot, toSnapshot, options);
+}

package/src/generator/surfaces/databases/postgres/capabilities.js

@@ -0,0 +1,14 @@
+export const POSTGRES_CAPABILITIES = {
+  default: {
+    family: "postgres",
+    profiles: ["default"],
+    supportsEnums: true,
+    supportsPrisma: true,
+    supportsDrizzle: true,
+    supportsGeneratedBundles: true
+  }
+};
+
+export function resolvePostgresCapabilities(profileId = "default") {
+  return POSTGRES_CAPABILITIES[profileId] || POSTGRES_CAPABILITIES.default;
+}

package/src/generator/surfaces/databases/postgres/drizzle.js

@@ -0,0 +1,99 @@
+import { buildDbProjectionContract, defaultTableName, getProjection } from "../shared.js";
+import { normalizeDbSchemaSnapshot } from "../snapshot.js";
+import { resolvePostgresCapabilities } from "./capabilities.js";
+
+function fieldSetKey(fields) {
+  return fields.join("|");
+}
+
+function drizzleScalarForColumn(column) {
+  switch (column.fieldType) {
+    case "uuid":
+      return "uuid";
+    case "integer":
+      return "integer";
+    case "number":
+      return "doublePrecision";
+    case "boolean":
+      return "boolean";
+    case "datetime":
+      return "timestamp";
+    default:
+      return "text";
+  }
+}
+
+function drizzleColumnBuilder(column, relation, targetTableVar) {
+  const fn = drizzleScalarForColumn(column);
+  const args = [`"${column.name}"`];
+  const chain = [];
+  if (fn === "timestamp") {
+    args.push('{ withTimezone: true, mode: "string" }');
+  }
+  if (column.required) {
+    chain.push("notNull()");
+  }
+  if (column.defaultValue != null) {
+    if (column.fieldType === "boolean" || column.fieldType === "integer" || column.fieldType === "number") {
+      chain.push(`default(${column.defaultValue})`);
+    } else {
+      chain.push(`default("${String(column.defaultValue).replace(/"/g, '\\"')}")`);
+    }
+  }
+  if (relation && targetTableVar) {
+    const config = relation.onDelete ? `, { onDelete: "${relation.onDelete.replace("_", " ")}" }` : "";
+    chain.push(`references(() => ${targetTableVar}.${relation.target.field}${config})`);
+  }
+  return `${fn}(${args.join(", ")})${chain.length > 0 ? `.${chain.join(".")}` : ""}`;
+}
+
+export function generatePostgresDrizzleSchema(graph, options = {}) {
+  resolvePostgresCapabilities(options.profileId);
+  const projection = getProjection(graph, options.projectionId);
+  if (projection.platform !== "db_postgres") {
+    throw new Error(`Drizzle schema generation currently supports db_postgres projections only, found '${projection.platform}'`);
+  }
+
+  const contract = buildDbProjectionContract(graph, projection);
+  const snapshot = normalizeDbSchemaSnapshot(contract);
+  const tableVarByName = new Map(snapshot.tables.map((table) => [table.table, `${table.table}Table`]));
+  const imports = new Set(["pgTable", "text", "uuid", "integer", "doublePrecision", "boolean", "timestamp", "index", "uniqueIndex"]);
+  const lines = [];
+
+  lines.push(`import { ${[...imports].sort().join(", ")} } from "drizzle-orm/pg-core";`);
+  lines.push("");
+
+  for (const table of snapshot.tables) {
+    const tableVar = tableVarByName.get(table.table);
+    const relationByField = new Map((table.relations || []).map((entry) => [entry.field, entry]));
+    lines.push(`export const ${tableVar} = pgTable("${table.table}", {`);
+    for (const column of table.columns) {
+      const relation = relationByField.get(column.name);
+      const targetTableVar = relation ? tableVarByName.get(defaultTableName(relation.target.id)) : null;
+      let builder = drizzleColumnBuilder(column, relation, targetTableVar);
+      if (table.primaryKey.length === 1 && table.primaryKey[0] === column.name) {
+        builder += ".primaryKey()";
+      }
+      lines.push(`  ${column.sourceField}: ${builder},`);
+    }
+    lines.push("}, (table) => ({");
+    for (const index of table.indexes || []) {
+      const fn = index.type === "unique" ? "uniqueIndex" : "index";
+      const name = `${table.table}_${index.fields.join("_")}_${index.type}`;
+      const refs = index.fields.map((field) => `table.${(table.columns.find((column) => column.name === field) || { sourceField: field }).sourceField}`).join(", ");
+      lines.push(`  ${name}: ${fn}("${name}").on(${refs}),`);
+    }
+    for (const fields of table.uniques || []) {
+      if (fields.length === 1 && (table.indexes || []).some((entry) => entry.type === "unique" && fieldSetKey(entry.fields) === fieldSetKey(fields))) {
+        continue;
+      }
+      const name = `${table.table}_${fields.join("_")}_unique`;
+      const refs = fields.map((field) => `table.${(table.columns.find((column) => column.name === field) || { sourceField: field }).sourceField}`).join(", ");
+      lines.push(`  ${name}: uniqueIndex("${name}").on(${refs}),`);
+    }
+    lines.push("}));");
+    lines.push("");
+  }
+
+  return `${lines.join("\n").trimEnd()}\n`;
+}

package/src/generator/surfaces/databases/postgres/index.js

@@ -0,0 +1,9 @@
+export { resolvePostgresCapabilities } from "./capabilities.js";
+export { generatePostgresSqlSchema } from "./sql-schema.js";
+export { generatePostgresSqlMigration } from "./sql-migration.js";
+export { generatePostgresPrismaSchema } from "./prisma.js";
+export { generatePostgresDrizzleSchema } from "./drizzle.js";
+export {
+  generatePostgresDbLifecycleBundle,
+  generatePostgresDbLifecyclePlan
+} from "./lifecycle.js";

package/src/generator/surfaces/databases/postgres/lifecycle.js

@@ -0,0 +1,16 @@
+import {
+  generateDbLifecycleBundleForProjection,
+  generateDbLifecyclePlanForProjection
+} from "../lifecycle-shared.js";
+import { getProjection } from "../shared.js";
+import { resolvePostgresCapabilities } from "./capabilities.js";
+
+export function generatePostgresDbLifecyclePlan(graph, options = {}) {
+  resolvePostgresCapabilities(options.profileId);
+  return generateDbLifecyclePlanForProjection(graph, getProjection(graph, options.projectionId), options);
+}
+
+export function generatePostgresDbLifecycleBundle(graph, options = {}) {
+  resolvePostgresCapabilities(options.profileId);
+  return generateDbLifecycleBundleForProjection(graph, getProjection(graph, options.projectionId), options);
+}

package/src/generator/surfaces/databases/postgres/prisma.js

@@ -0,0 +1,159 @@
+import { buildDbProjectionContract, defaultTableName, findEnumStatement, getProjection, indexGraphStatements, toPascalCase } from "../shared.js";
+import { normalizeDbSchemaSnapshot } from "../snapshot.js";
+import { resolvePostgresCapabilities } from "./capabilities.js";
+
+function prismaScalarForColumn(column, byId) {
+  const enumStatement = findEnumStatement(byId, column.fieldType);
+  if (enumStatement) {
+    return { type: toPascalCase(enumStatement.id.replace(/^enum_/, "")), enumStatement };
+  }
+
+  switch (column.fieldType) {
+    case "uuid":
+      return { type: "String", db: "@db.Uuid" };
+    case "integer":
+      return { type: "Int" };
+    case "number":
+      return { type: "Float" };
+    case "boolean":
+      return { type: "Boolean" };
+    case "datetime":
+      return { type: "DateTime", db: "@db.Timestamptz(3)" };
+    default:
+      return { type: "String" };
+  }
+}
+
+function prismaDefaultForColumn(column, byId) {
+  if (column.defaultValue == null) {
+    return null;
+  }
+  if (column.fieldType === "boolean" || column.fieldType === "integer" || column.fieldType === "number") {
+    return `@default(${column.defaultValue})`;
+  }
+  if (byId.has(column.fieldType) && byId.get(column.fieldType)?.kind === "enum") {
+    return `@default(${String(column.defaultValue)})`;
+  }
+  return `@default("${String(column.defaultValue).replace(/"/g, '\\"')}")`;
+}
+
+export function generatePostgresPrismaSchema(graph, options = {}) {
+  resolvePostgresCapabilities(options.profileId);
+  const projection = getProjection(graph, options.projectionId);
+  if (projection.platform !== "db_postgres") {
+    throw new Error(`Prisma schema generation currently supports db_postgres projections only, found '${projection.platform}'`);
+  }
+
+  const byId = indexGraphStatements(graph);
+  const snapshot = normalizeDbSchemaSnapshot(buildDbProjectionContract(graph, projection));
+  const enumStatements = new Map();
+  for (const table of snapshot.tables) {
+    for (const column of table.columns) {
+      const enumStatement = findEnumStatement(byId, column.fieldType);
+      if (enumStatement) {
+        enumStatements.set(enumStatement.id, enumStatement);
+      }
+    }
+  }
+
+  const relationBackrefs = new Map();
+  for (const table of snapshot.tables) {
+    for (const relation of table.relations || []) {
+      const targetTable = defaultTableName(relation.target.id);
+      if (!relationBackrefs.has(targetTable)) {
+        relationBackrefs.set(targetTable, []);
+      }
+      relationBackrefs.get(targetTable).push({
+        fromTable: table.table,
+        fromModel: toPascalCase(table.entity.id.replace(/^entity_/, "")),
+        field: relation.field,
+        relationName: `${toPascalCase(table.entity.id.replace(/^entity_/, ""))}_${relation.field}_to_${toPascalCase(relation.target.id.replace(/^entity_/, ""))}`
+      });
+    }
+  }
+
+  const lines = [];
+  lines.push('generator client {');
+  lines.push('  provider = "prisma-client-js"');
+  lines.push("}");
+  lines.push("");
+  lines.push("datasource db {");
+  lines.push('  provider = "postgresql"');
+  lines.push('  url      = env("DATABASE_URL")');
+  lines.push("}");
+  lines.push("");
+
+  for (const enumStatement of [...enumStatements.values()].sort((a, b) => a.id.localeCompare(b.id))) {
+    lines.push(`enum ${toPascalCase(enumStatement.id.replace(/^enum_/, ""))} {`);
+    for (const value of enumStatement.values) {
+      lines.push(`  ${value}`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+
+  for (const table of snapshot.tables) {
+    const modelName = toPascalCase(table.entity.id.replace(/^entity_/, ""));
+    const pk = table.primaryKey || [];
+    const relationFields = new Map((table.relations || []).map((entry) => [entry.field, entry]));
+
+    lines.push(`model ${modelName} {`);
+    for (const column of table.columns) {
+      const scalar = prismaScalarForColumn(column, byId);
+      const optional = column.required ? "" : "?";
+      const attrs = [];
+      if (pk.length === 1 && pk[0] === column.name) {
+        attrs.push("@id");
+      }
+      const uniqueMatch = (table.uniques || []).find((fields) => fields.length === 1 && fields[0] === column.name);
+      if (uniqueMatch) {
+        attrs.push("@unique");
+      }
+      const defaultAttr = prismaDefaultForColumn(column, byId);
+      if (defaultAttr) {
+        attrs.push(defaultAttr);
+      }
+      if (scalar.db) {
+        attrs.push(scalar.db);
+      }
+      if (column.name !== column.sourceField) {
+        attrs.push(`@map("${column.name}")`);
+      }
+      lines.push(`  ${column.sourceField} ${scalar.type}${optional}${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}`);
+
+      const relation = relationFields.get(column.name);
+      if (relation) {
+        const targetModel = toPascalCase(relation.target.id.replace(/^entity_/, ""));
+        const relationName = `${modelName}_${column.sourceField}_to_${targetModel}`;
+        const optionalRelation = column.required ? "" : "?";
+        lines.push(`  ${column.sourceField.replace(/_id$/, "")} ${targetModel}${optionalRelation} @relation("${relationName}", fields: [${column.sourceField}], references: [${relation.target.field}])`);
+      }
+    }
+
+    for (const backref of relationBackrefs.get(table.table) || []) {
+      const relationFieldName = `${backref.fromTable}`;
+      lines.push(`  ${relationFieldName} ${backref.fromModel}[] @relation("${backref.relationName}")`);
+    }
+
+    if (pk.length > 1) {
+      lines.push(`  @@id([${pk.join(", ")}])`);
+    }
+    for (const fields of table.uniques || []) {
+      if (fields.length > 1) {
+        lines.push(`  @@unique([${fields.join(", ")}])`);
+      }
+    }
+    for (const index of table.indexes || []) {
+      if (index.type === "index") {
+        lines.push(`  @@index([${index.fields.join(", ")}])`);
+      }
+    }
+    if (table.table !== modelName) {
+      lines.push(`  @@map("${table.table}")`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+
+  return `${lines.join("\n").trimEnd()}\n`;
+}

package/src/generator/surfaces/databases/postgres/sql-migration.js

@@ -0,0 +1,102 @@
+import { buildDbMigrationPlan } from "../migration-plan.js";
+import { generateDbSchemaSnapshot, getTableFromSnapshot } from "../snapshot.js";
+import {
+  defaultTableName,
+  indexGraphStatements,
+  renderAddColumn,
+  renderAddEnumValue,
+  renderCreateEnumType,
+  renderCreateTable
+} from "../shared.js";
+import { resolvePostgresCapabilities } from "./capabilities.js";
+
+function renderSqlMigration(plan, snapshot) {
+  if (!plan.supported) {
+    throw new Error(`Migration plan for '${plan.projection.id}' requires manual intervention`);
+  }
+
+  const statements = [];
+  const byId = plan.graph ? indexGraphStatements(plan.graph) : null;
+  const enumsById = new Map((snapshot.enums || []).map((entry) => [entry.id, entry]));
+  const createdTables = new Set();
+  const pendingForeignKeys = [];
+  for (const operation of plan.operations) {
+    if (operation.type === "create_enum") {
+      const enumStatement = enumsById.get(operation.enum) || (byId ? byId.get(operation.enum) : null);
+      if (enumStatement) {
+        statements.push(renderCreateEnumType(enumStatement));
+      }
+      continue;
+    }
+
+    if (operation.type === "add_enum_value") {
+      const enumStatement = enumsById.get(operation.enum) || (byId ? byId.get(operation.enum) : null);
+      if (enumStatement) {
+        statements.push(renderAddEnumValue(enumStatement, operation));
+      }
+      continue;
+    }
+
+    if (operation.type === "create_table") {
+      const table = getTableFromSnapshot(snapshot, operation.table);
+      createdTables.add(operation.table);
+      statements.push(renderCreateTable(table, "postgres", { includeRelations: false, byId }));
+      for (const relation of table?.relations || []) {
+        if (relation.target?.id && relation.target?.field) {
+          pendingForeignKeys.push({
+            table: operation.table,
+            field: relation.field,
+            target: relation.target,
+            onDelete: relation.onDelete || null
+          });
+        }
+      }
+      continue;
+    }
+
+    if (operation.type === "add_column") {
+      const table = getTableFromSnapshot(snapshot, operation.table);
+      const column = table?.columns.find((entry) => entry.name === operation.column);
+      statements.push(renderAddColumn(operation.table, column));
+      continue;
+    }
+
+    if (operation.type === "add_unique_constraint") {
+      statements.push(`alter table ${operation.table} add unique (${operation.fields.join(", ")});`);
+      continue;
+    }
+
+    if (operation.type === "add_index" || operation.type === "add_unique_index") {
+      const unique = operation.type === "add_unique_index" ? "unique " : "";
+      const name = `${operation.table}_${operation.fields.join("_")}_${operation.type === "add_unique_index" ? "unique" : "index"}`;
+      statements.push(`create ${unique}index ${name} on ${operation.table} (${operation.fields.join(", ")});`);
+      continue;
+    }
+
+    if (operation.type === "add_foreign_key") {
+      const targetTable = defaultTableName(operation.target.id);
+      statements.push(`alter table ${operation.table} add foreign key (${operation.field}) references ${targetTable}(${operation.target.field})${operation.onDelete ? ` on delete ${operation.onDelete.replace("_", " ")}` : ""};`);
+    }
+  }
+
+  for (const relation of pendingForeignKeys) {
+    const targetTable = defaultTableName(relation.target.id);
+    statements.push(`alter table ${relation.table} add foreign key (${relation.field}) references ${targetTable}(${relation.target.field})${relation.onDelete ? ` on delete ${relation.onDelete.replace("_", " ")}` : ""};`);
+  }
+
+  return `${statements.join("\n\n").trimEnd()}\n`;
+}
+
+export function generatePostgresSqlMigration(graph, options = {}) {
+  resolvePostgresCapabilities(options.profileId);
+  if (!options.projectionId) {
+    throw new Error("sql-migration requires --projection");
+  }
+  if (!options.fromSnapshot) {
+    throw new Error("sql-migration requires --from-snapshot");
+  }
+
+  const toSnapshot = generateDbSchemaSnapshot(graph, options);
+  const plan = buildDbMigrationPlan(options.fromSnapshot, toSnapshot, options);
+  return renderSqlMigration({ ...plan, graph }, toSnapshot);
+}