@momentumcms/migrations 0.3.0 → 0.4.0

package/src/cli/generate.js

@@ -0,0 +1,1686 @@
+// libs/migrations/src/cli/generate.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join2, resolve } from "node:path";
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+function getSoftDeleteField(config) {
+  if (!config.softDelete)
+    return null;
+  if (config.softDelete === true)
+    return "deletedAt";
+  const sdConfig = config.softDelete;
+  return sdConfig.field ?? "deletedAt";
+}
+
+// libs/core/src/lib/fields/field.types.ts
+function isNamedTab(tab) {
+  return typeof tab.name === "string" && tab.name.length > 0;
+}
+function flattenDataFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        if (isNamedTab(tab)) {
+          const syntheticGroup = {
+            name: tab.name,
+            type: "group",
+            label: tab.label,
+            description: tab.description,
+            fields: tab.fields
+          };
+          result.push(syntheticGroup);
+        } else {
+          result.push(...flattenDataFields(tab.fields));
+        }
+      }
+    } else if (field.type === "collapsible" || field.type === "row") {
+      result.push(...flattenDataFields(field.fields));
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  upload: {
+    mimeTypes: ["image/*", "application/pdf", "video/*", "audio/*"]
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/core/src/lib/migrations.ts
+function resolveMigrationMode(mode) {
+  if (mode === "push" || mode === "migrate")
+    return mode;
+  const env = process.env["NODE_ENV"];
+  if (env === "production")
+    return "migrate";
+  return "push";
+}
+function resolveMigrationConfig(config) {
+  if (!config)
+    return void 0;
+  const mode = resolveMigrationMode(config.mode);
+  return {
+    ...config,
+    directory: config.directory ?? "./migrations",
+    mode,
+    cloneTest: config.cloneTest ?? mode === "migrate",
+    dangerDetection: config.dangerDetection ?? true,
+    autoApply: config.autoApply ?? mode === "push"
+  };
+}
+
+// libs/migrations/src/lib/schema/schema-snapshot.ts
+import { createHash } from "node:crypto";
+var INTERNAL_TABLES = /* @__PURE__ */ new Set(["_momentum_migrations", "_momentum_seeds", "_globals"]);
+function computeSchemaChecksum(tables) {
+  const normalized = tables.map((t) => ({
+    name: t.name,
+    columns: [...t.columns].sort((a, b) => a.name.localeCompare(b.name)),
+    foreignKeys: [...t.foreignKeys].sort(
+      (a, b) => a.constraintName.localeCompare(b.constraintName)
+    ),
+    indexes: [...t.indexes].sort((a, b) => a.name.localeCompare(b.name))
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const json2 = JSON.stringify(normalized);
+  return createHash("sha256").update(json2).digest("hex");
+}
+function createSchemaSnapshot(dialect, tables) {
+  return {
+    dialect,
+    tables,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checksum: computeSchemaChecksum(tables)
+  };
+}
+function serializeSnapshot(snapshot) {
+  return JSON.stringify(snapshot, null, "	");
+}
+function deserializeSnapshot(json2) {
+  const parsed = JSON.parse(json2);
+  if (!isSchemaSnapshot(parsed)) {
+    throw new Error("Invalid schema snapshot JSON");
+  }
+  return parsed;
+}
+function isSchemaSnapshot(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return (obj["dialect"] === "postgresql" || obj["dialect"] === "sqlite") && Array.isArray(obj["tables"]) && typeof obj["capturedAt"] === "string" && typeof obj["checksum"] === "string";
+}
+
+// libs/migrations/src/lib/schema/column-type-map.ts
+function fieldToPostgresType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "password":
+    case "radio":
+    case "point":
+      return "TEXT";
+    case "email":
+    case "slug":
+    case "select":
+      return "VARCHAR(255)";
+    case "number":
+      return "NUMERIC";
+    case "checkbox":
+      return "BOOLEAN";
+    case "date":
+      return "TIMESTAMPTZ";
+    case "relationship":
+    case "upload":
+      return "VARCHAR(36)";
+    case "array":
+    case "group":
+    case "blocks":
+    case "json":
+      return "JSONB";
+    case "tabs":
+    case "collapsible":
+    case "row":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function fieldToSqliteType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "email":
+    case "slug":
+    case "select":
+    case "password":
+    case "radio":
+    case "point":
+      return "TEXT";
+    case "number":
+      return "REAL";
+    case "checkbox":
+      return "INTEGER";
+    case "date":
+    case "relationship":
+    case "upload":
+      return "TEXT";
+    case "array":
+    case "group":
+    case "blocks":
+    case "json":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function fieldToColumnType(field, dialect) {
+  if (dialect === "postgresql")
+    return fieldToPostgresType(field);
+  return fieldToSqliteType(field);
+}
+function normalizeColumnType(rawType, dialect) {
+  const upper = rawType.toUpperCase().trim();
+  if (dialect === "postgresql") {
+    return normalizePgType(upper);
+  }
+  return normalizeSqliteType(upper);
+}
+function normalizePgType(type) {
+  const charVaryingMatch = type.match(/^CHARACTER VARYING\((\d+)\)$/);
+  if (charVaryingMatch)
+    return `VARCHAR(${charVaryingMatch[1]})`;
+  if (type === "CHARACTER VARYING")
+    return "VARCHAR(255)";
+  if (type === "TIMESTAMP WITH TIME ZONE")
+    return "TIMESTAMPTZ";
+  if (type === "TIMESTAMP WITHOUT TIME ZONE")
+    return "TIMESTAMP";
+  if (type === "BOOLEAN")
+    return "BOOLEAN";
+  if (type === "NUMERIC")
+    return "NUMERIC";
+  if (type === "TEXT")
+    return "TEXT";
+  if (type === "JSONB")
+    return "JSONB";
+  if (type === "JSON")
+    return "JSON";
+  if (type === "INTEGER")
+    return "INTEGER";
+  if (type === "BIGINT")
+    return "BIGINT";
+  if (type === "REAL")
+    return "REAL";
+  if (type === "DOUBLE PRECISION")
+    return "DOUBLE PRECISION";
+  return type;
+}
+function normalizeSqliteType(type) {
+  if (type === "INT" || type === "INTEGER")
+    return "INTEGER";
+  if (type === "REAL" || type === "FLOAT" || type === "DOUBLE")
+    return "REAL";
+  return type;
+}
+function areTypesCompatible(typeA, typeB, dialect) {
+  const normA = normalizeColumnType(typeA, dialect);
+  const normB = normalizeColumnType(typeB, dialect);
+  return normA === normB;
+}
+
+// libs/migrations/src/lib/schema/collections-to-schema.ts
+function mapOnDelete(onDelete, required) {
+  const effective = required && (!onDelete || onDelete === "set-null") ? "restrict" : onDelete;
+  switch (effective) {
+    case "restrict":
+      return "RESTRICT";
+    case "cascade":
+      return "CASCADE";
+    default:
+      return "SET NULL";
+  }
+}
+function getTableName(collection) {
+  return collection.dbName ?? collection.slug;
+}
+function hasVersionDrafts(collection) {
+  const versions = collection.versions;
+  if (!versions)
+    return false;
+  if (typeof versions === "boolean")
+    return false;
+  return !!versions.drafts;
+}
+function isCollectionConfig(value) {
+  return typeof value === "object" && value !== null && "slug" in value && "fields" in value;
+}
+function resolveCollectionRef(ref) {
+  try {
+    const resolved = ref();
+    if (isCollectionConfig(resolved)) {
+      return resolved;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function buildAutoColumns(collection, dialect) {
+  const columns = [];
+  columns.push({
+    name: "id",
+    type: dialect === "postgresql" ? "VARCHAR(36)" : "TEXT",
+    nullable: false,
+    defaultValue: null,
+    isPrimaryKey: true
+  });
+  const timestamps = collection.timestamps;
+  const addCreatedAt = timestamps !== false && (timestamps === true || timestamps === void 0 || timestamps.createdAt !== false);
+  const addUpdatedAt = timestamps !== false && (timestamps === true || timestamps === void 0 || timestamps.updatedAt !== false);
+  if (addCreatedAt) {
+    columns.push({
+      name: "createdAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    });
+  }
+  if (addUpdatedAt) {
+    columns.push({
+      name: "updatedAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    });
+  }
+  if (hasVersionDrafts(collection)) {
+    columns.push({
+      name: "_status",
+      type: dialect === "postgresql" ? "VARCHAR(20)" : "TEXT",
+      nullable: false,
+      defaultValue: "'draft'",
+      isPrimaryKey: false
+    });
+  }
+  const softDeleteCol = getSoftDeleteField(collection);
+  if (softDeleteCol) {
+    columns.push({
+      name: softDeleteCol,
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: true,
+      defaultValue: null,
+      isPrimaryKey: false
+    });
+  }
+  return columns;
+}
+function fieldToColumn(field, dialect) {
+  return {
+    name: field.name,
+    type: fieldToColumnType(field, dialect),
+    nullable: !field.required,
+    defaultValue: null,
+    isPrimaryKey: false
+  };
+}
+function buildForeignKeys(tableName, fields) {
+  const foreignKeys = [];
+  for (const field of fields) {
+    if (field.type !== "relationship")
+      continue;
+    if (field.hasMany)
+      continue;
+    if (field.relationTo && field.relationTo.length > 0)
+      continue;
+    const target = resolveCollectionRef(field.collection);
+    if (!target)
+      continue;
+    const targetTable = getTableName(target);
+    const onDelete = mapOnDelete(field.onDelete, !!field.required);
+    foreignKeys.push({
+      constraintName: `fk_${tableName}_${field.name}`,
+      column: field.name,
+      referencedTable: targetTable,
+      referencedColumn: "id",
+      onDelete
+    });
+  }
+  return foreignKeys;
+}
+function buildIndexes(tableName, collection) {
+  const indexes = [];
+  const sdField = getSoftDeleteField(collection);
+  if (sdField) {
+    indexes.push({
+      name: `idx_${tableName}_${sdField}`,
+      columns: [sdField],
+      unique: false
+    });
+  }
+  if (collection.indexes) {
+    for (const idx of collection.indexes) {
+      indexes.push({
+        name: idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`,
+        columns: [...idx.columns],
+        unique: !!idx.unique
+      });
+    }
+  }
+  return indexes;
+}
+function buildVersionTable(collection, dialect) {
+  if (!collection.versions)
+    return null;
+  const baseTable = getTableName(collection);
+  const tableName = `${baseTable}_versions`;
+  const columns = [
+    {
+      name: "id",
+      type: dialect === "postgresql" ? "VARCHAR(36)" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: true
+    },
+    {
+      name: "parent",
+      type: dialect === "postgresql" ? "VARCHAR(36)" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "version",
+      type: "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "_status",
+      type: dialect === "postgresql" ? "VARCHAR(20)" : "TEXT",
+      nullable: false,
+      defaultValue: "'draft'",
+      isPrimaryKey: false
+    },
+    {
+      name: "autosave",
+      type: dialect === "postgresql" ? "BOOLEAN" : "INTEGER",
+      nullable: false,
+      defaultValue: dialect === "postgresql" ? "false" : "0",
+      isPrimaryKey: false
+    },
+    {
+      name: "publishedAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: true,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "createdAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    },
+    {
+      name: "updatedAt",
+      type: dialect === "postgresql" ? "TIMESTAMPTZ" : "TEXT",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: false
+    }
+  ];
+  const foreignKeys = [
+    {
+      constraintName: `fk_${tableName}_parent`,
+      column: "parent",
+      referencedTable: baseTable,
+      referencedColumn: "id",
+      onDelete: "CASCADE"
+    }
+  ];
+  const indexes = [
+    { name: `idx_${tableName}_parent`, columns: ["parent"], unique: false },
+    { name: `idx_${tableName}_status`, columns: ["_status"], unique: false },
+    { name: `idx_${tableName}_createdAt`, columns: ["createdAt"], unique: false }
+  ];
+  return { name: tableName, columns, foreignKeys, indexes };
+}
+function collectionToTableSnapshot(collection, dialect) {
+  const tableName = getTableName(collection);
+  const dataFields = flattenDataFields(collection.fields);
+  const columns = [
+    ...buildAutoColumns(collection, dialect),
+    ...dataFields.map((f) => fieldToColumn(f, dialect))
+  ];
+  const foreignKeys = buildForeignKeys(tableName, dataFields);
+  const indexes = buildIndexes(tableName, collection);
+  return { name: tableName, columns, foreignKeys, indexes };
+}
+function collectionsToSchema(collections, dialect) {
+  const tables = [];
+  for (const collection of collections) {
+    tables.push(collectionToTableSnapshot(collection, dialect));
+    const versionTable = buildVersionTable(collection, dialect);
+    if (versionTable) {
+      tables.push(versionTable);
+    }
+  }
+  return createSchemaSnapshot(dialect, tables);
+}
+
+// libs/migrations/src/lib/schema/schema-diff.ts
+var DEFAULT_DIFF_OPTIONS = {
+  detectRenames: true,
+  renameSimilarityThreshold: 0.6
+};
+function diffSchemas(desired, actual, dialect, options) {
+  const opts = { ...DEFAULT_DIFF_OPTIONS, ...options };
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const t of desired.tables)
+    desiredMap.set(t.name, t);
+  for (const t of actual.tables)
+    actualMap.set(t.name, t);
+  for (const [name, desiredTable] of desiredMap) {
+    if (!actualMap.has(name)) {
+      operations.push({
+        type: "createTable",
+        table: name,
+        columns: desiredTable.columns.map((c) => ({
+          name: c.name,
+          type: c.type,
+          nullable: c.nullable,
+          defaultValue: c.defaultValue ?? void 0,
+          primaryKey: c.isPrimaryKey || void 0
+        }))
+      });
+      summary.push(`Create table "${name}"`);
+      for (const fk of desiredTable.foreignKeys) {
+        operations.push({
+          type: "addForeignKey",
+          table: name,
+          constraintName: fk.constraintName,
+          column: fk.column,
+          referencedTable: fk.referencedTable,
+          referencedColumn: fk.referencedColumn,
+          onDelete: fk.onDelete
+        });
+      }
+      for (const idx of desiredTable.indexes) {
+        operations.push({
+          type: "createIndex",
+          table: name,
+          indexName: idx.name,
+          columns: idx.columns,
+          unique: idx.unique
+        });
+      }
+    }
+  }
+  for (const [name] of actualMap) {
+    if (!desiredMap.has(name)) {
+      operations.push({ type: "dropTable", table: name });
+      summary.push(`Drop table "${name}"`);
+    }
+  }
+  for (const [name, desiredTable] of desiredMap) {
+    const actualTable = actualMap.get(name);
+    if (!actualTable)
+      continue;
+    const tableOps = diffTable(desiredTable, actualTable, dialect, opts);
+    operations.push(...tableOps.operations);
+    summary.push(...tableOps.summary);
+  }
+  return {
+    hasChanges: operations.length > 0,
+    operations,
+    summary
+  };
+}
+function diffTable(desired, actual, dialect, opts) {
+  const operations = [];
+  const summary = [];
+  const tableName = desired.name;
+  const colOps = diffColumns(tableName, desired.columns, actual.columns, dialect, opts);
+  operations.push(...colOps.operations);
+  summary.push(...colOps.summary);
+  const fkOps = diffForeignKeys(tableName, desired.foreignKeys, actual.foreignKeys);
+  operations.push(...fkOps.operations);
+  summary.push(...fkOps.summary);
+  const idxOps = diffIndexes(tableName, desired.indexes, actual.indexes);
+  operations.push(...idxOps.operations);
+  summary.push(...idxOps.summary);
+  return { operations, summary };
+}
+function diffColumns(tableName, desiredColumns, actualColumns, dialect, opts) {
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const c of desiredColumns)
+    desiredMap.set(c.name, c);
+  for (const c of actualColumns)
+    actualMap.set(c.name, c);
+  const renamedFrom = /* @__PURE__ */ new Set();
+  const renamedTo = /* @__PURE__ */ new Set();
+  if (opts.detectRenames) {
+    const missingInActual = [...desiredMap.keys()].filter((k) => !actualMap.has(k));
+    const extraInActual = [...actualMap.keys()].filter((k) => !desiredMap.has(k));
+    for (const newName of missingInActual) {
+      const desiredCol = desiredMap.get(newName);
+      for (const oldName of extraInActual) {
+        if (renamedFrom.has(oldName))
+          continue;
+        const actualCol = actualMap.get(oldName);
+        if (areTypesCompatible(desiredCol.type, actualCol.type, dialect)) {
+          operations.push({
+            type: "renameColumn",
+            table: tableName,
+            from: oldName,
+            to: newName
+          });
+          summary.push(
+            `Rename column "${tableName}"."${oldName}" \u2192 "${newName}"`
+          );
+          renamedFrom.add(oldName);
+          renamedTo.add(newName);
+          break;
+        }
+      }
+    }
+  }
+  for (const [name, desiredCol] of desiredMap) {
+    if (actualMap.has(name) || renamedTo.has(name))
+      continue;
+    operations.push({
+      type: "addColumn",
+      table: tableName,
+      column: name,
+      columnType: desiredCol.type,
+      nullable: desiredCol.nullable,
+      defaultValue: desiredCol.defaultValue ?? void 0
+    });
+    summary.push(`Add column "${tableName}"."${name}" (${desiredCol.type})`);
+  }
+  for (const [name, actualCol] of actualMap) {
+    if (desiredMap.has(name) || renamedFrom.has(name))
+      continue;
+    operations.push({
+      type: "dropColumn",
+      table: tableName,
+      column: name,
+      previousType: actualCol.type,
+      previousNullable: actualCol.nullable
+    });
+    summary.push(`Drop column "${tableName}"."${name}"`);
+  }
+  for (const [name, desiredCol] of desiredMap) {
+    const actualCol = actualMap.get(name);
+    if (!actualCol)
+      continue;
+    if (!areTypesCompatible(desiredCol.type, actualCol.type, dialect)) {
+      operations.push({
+        type: "alterColumnType",
+        table: tableName,
+        column: name,
+        fromType: normalizeColumnType(actualCol.type, dialect),
+        toType: normalizeColumnType(desiredCol.type, dialect)
+      });
+      summary.push(
+        `Change type "${tableName}"."${name}": ${actualCol.type} \u2192 ${desiredCol.type}`
+      );
+    }
+    if (desiredCol.nullable !== actualCol.nullable) {
+      operations.push({
+        type: "alterColumnNullable",
+        table: tableName,
+        column: name,
+        nullable: desiredCol.nullable
+      });
+      summary.push(
+        `Change nullable "${tableName}"."${name}": ${actualCol.nullable} \u2192 ${desiredCol.nullable}`
+      );
+    }
+    if (normalizeDefault(desiredCol.defaultValue) !== normalizeDefault(actualCol.defaultValue)) {
+      operations.push({
+        type: "alterColumnDefault",
+        table: tableName,
+        column: name,
+        defaultValue: desiredCol.defaultValue,
+        previousDefault: actualCol.defaultValue
+      });
+      summary.push(
+        `Change default "${tableName}"."${name}": ${actualCol.defaultValue ?? "NULL"} \u2192 ${desiredCol.defaultValue ?? "NULL"}`
+      );
+    }
+  }
+  return { operations, summary };
+}
+function normalizeDefault(value) {
+  if (value === null || value === void 0 || value === "")
+    return null;
+  return value;
+}
+function diffForeignKeys(tableName, desiredFks, actualFks) {
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const fk of desiredFks)
+    desiredMap.set(fk.constraintName, fk);
+  for (const fk of actualFks)
+    actualMap.set(fk.constraintName, fk);
+  for (const [name, fk] of desiredMap) {
+    if (!actualMap.has(name)) {
+      operations.push({
+        type: "addForeignKey",
+        table: tableName,
+        constraintName: fk.constraintName,
+        column: fk.column,
+        referencedTable: fk.referencedTable,
+        referencedColumn: fk.referencedColumn,
+        onDelete: fk.onDelete
+      });
+      summary.push(`Add foreign key "${name}" on "${tableName}"`);
+    } else {
+      const actualFk = actualMap.get(name);
+      if (fk.column !== actualFk.column || fk.referencedTable !== actualFk.referencedTable || fk.referencedColumn !== actualFk.referencedColumn || fk.onDelete !== actualFk.onDelete) {
+        operations.push({
+          type: "dropForeignKey",
+          table: tableName,
+          constraintName: name
+        });
+        operations.push({
+          type: "addForeignKey",
+          table: tableName,
+          constraintName: fk.constraintName,
+          column: fk.column,
+          referencedTable: fk.referencedTable,
+          referencedColumn: fk.referencedColumn,
+          onDelete: fk.onDelete
+        });
+        summary.push(`Modify foreign key "${name}" on "${tableName}"`);
+      }
+    }
+  }
+  for (const [name] of actualMap) {
+    if (!desiredMap.has(name)) {
+      operations.push({
+        type: "dropForeignKey",
+        table: tableName,
+        constraintName: name
+      });
+      summary.push(`Drop foreign key "${name}" on "${tableName}"`);
+    }
+  }
+  return { operations, summary };
+}
+function diffIndexes(tableName, desiredIdxs, actualIdxs) {
+  const operations = [];
+  const summary = [];
+  const desiredMap = /* @__PURE__ */ new Map();
+  const actualMap = /* @__PURE__ */ new Map();
+  for (const idx of desiredIdxs)
+    desiredMap.set(idx.name, idx);
+  for (const idx of actualIdxs)
+    actualMap.set(idx.name, idx);
+  for (const [name, idx] of desiredMap) {
+    if (!actualMap.has(name)) {
+      operations.push({
+        type: "createIndex",
+        table: tableName,
+        indexName: idx.name,
+        columns: idx.columns,
+        unique: idx.unique
+      });
+      summary.push(`Create index "${name}" on "${tableName}"`);
+    } else {
+      const actualIdx = actualMap.get(name);
+      if (idx.unique !== actualIdx.unique || JSON.stringify(idx.columns) !== JSON.stringify(actualIdx.columns)) {
+        operations.push({
+          type: "dropIndex",
+          table: tableName,
+          indexName: name
+        });
+        operations.push({
+          type: "createIndex",
+          table: tableName,
+          indexName: idx.name,
+          columns: idx.columns,
+          unique: idx.unique
+        });
+        summary.push(`Modify index "${name}" on "${tableName}"`);
+      }
+    }
+  }
+  for (const [name] of actualMap) {
+    if (!desiredMap.has(name)) {
+      operations.push({
+        type: "dropIndex",
+        table: tableName,
+        indexName: name
+      });
+      summary.push(`Drop index "${name}" on "${tableName}"`);
+    }
+  }
+  return { operations, summary };
+}
+
+// libs/migrations/src/lib/danger/danger-detector.ts
+function detectDangers(operations, dialect) {
+  const warnings = [];
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    warnings.push(...checkOperation(op, i, operations, dialect));
+  }
+  const severityOrder = { error: 0, warning: 1, info: 2 };
+  warnings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  return {
+    warnings,
+    hasErrors: warnings.some((w) => w.severity === "error"),
+    hasWarnings: warnings.some((w) => w.severity === "warning")
+  };
+}
+function checkOperation(op, index, _allOps, dialect) {
+  const warnings = [];
+  switch (op.type) {
+    case "dropTable":
+      warnings.push({
+        severity: "error",
+        operation: op,
+        operationIndex: index,
+        message: `Dropping table "${op.table}" will permanently delete all data.`,
+        suggestion: 'Consider renaming the table with a deprecation prefix (e.g., "_deprecated_") and scheduling deletion after verifying no data is needed.'
+      });
+      break;
+    case "dropColumn":
+      warnings.push({
+        severity: "warning",
+        operation: op,
+        operationIndex: index,
+        message: `Dropping column "${op.table}"."${op.column}" will permanently delete all values in this column.`,
+        suggestion: "Before dropping, verify the column data is either migrated elsewhere or truly unneeded. Consider a backup or data export first."
+      });
+      break;
+    case "alterColumnType":
+      warnings.push(...checkTypeChange(op, index, dialect));
+      break;
+    case "alterColumnNullable":
+      if (!op.nullable) {
+        warnings.push({
+          severity: "warning",
+          operation: op,
+          operationIndex: index,
+          message: `Setting "${op.table}"."${op.column}" to NOT NULL may fail if existing rows contain NULL values.`,
+          suggestion: "First backfill NULL values with a default (e.g., UPDATE table SET column = 'default' WHERE column IS NULL), then add the NOT NULL constraint."
+        });
+      }
+      break;
+    case "addColumn":
+      if (!op.nullable && !op.defaultValue) {
+        warnings.push({
+          severity: "error",
+          operation: op,
+          operationIndex: index,
+          message: `Adding NOT NULL column "${op.table}"."${op.column}" without a default value will fail if the table has existing rows.`,
+          suggestion: "Either add a DEFAULT value, make the column nullable first and backfill, or add the column as nullable, backfill, then alter to NOT NULL."
+        });
+      }
+      break;
+    case "renameColumn":
+      warnings.push({
+        severity: "warning",
+        operation: op,
+        operationIndex: index,
+        message: `Renaming "${op.table}"."${op.from}" to "${op.to}" may break application code that references the old name.`,
+        suggestion: "Deploy application code changes to use the new column name before or alongside the migration. Consider a phased approach: add new column, migrate data, update code, then drop old column."
+      });
+      break;
+    case "renameTable":
+      warnings.push({
+        severity: "warning",
+        operation: op,
+        operationIndex: index,
+        message: `Renaming table "${op.from}" to "${op.to}" may break application code and queries.`,
+        suggestion: "Update application code to use the new table name before or alongside the migration."
+      });
+      break;
+    case "addForeignKey":
+      if (dialect === "postgresql") {
+        warnings.push({
+          severity: "info",
+          operation: op,
+          operationIndex: index,
+          message: `Adding foreign key "${op.constraintName}" acquires an ACCESS EXCLUSIVE lock on the referenced table.`,
+          suggestion: "On large tables, consider adding the FK constraint with NOT VALID first, then validating separately: ALTER TABLE ... ADD CONSTRAINT ... NOT VALID; ALTER TABLE ... VALIDATE CONSTRAINT ..."
+        });
+      }
+      break;
+    case "createIndex":
+      if (dialect === "postgresql" && !isCreateIndexConcurrent(op)) {
+        warnings.push({
+          severity: "info",
+          operation: op,
+          operationIndex: index,
+          message: `Creating index "${op.indexName}" will lock "${op.table}" for writes during index creation.`,
+          suggestion: "For large tables, consider CREATE INDEX CONCURRENTLY to avoid blocking writes (requires running outside a transaction)."
+        });
+      }
+      break;
+  }
+  return warnings;
+}
+function checkTypeChange(op, index, dialect) {
+  const warnings = [];
+  if (dialect === "sqlite") {
+    warnings.push({
+      severity: "error",
+      operation: op,
+      operationIndex: index,
+      message: `SQLite does not support ALTER COLUMN TYPE. Changing "${op.table}"."${op.column}" from ${op.fromType} to ${op.toType} requires a table rebuild.`,
+      suggestion: "Create a new table with the desired schema, copy data, drop old table, and rename new table. Use a raw SQL migration for this."
+    });
+    return warnings;
+  }
+  if (isLossyTypeChange(op.fromType, op.toType)) {
+    warnings.push({
+      severity: "warning",
+      operation: op,
+      operationIndex: index,
+      message: `Changing "${op.table}"."${op.column}" from ${op.fromType} to ${op.toType} may cause data loss or cast errors.`,
+      suggestion: "Test the type conversion on a clone database first. Consider adding a USING clause with explicit cast logic."
+    });
+  }
+  if (isTableRewriteType(op.fromType, op.toType)) {
+    warnings.push({
+      severity: "info",
+      operation: op,
+      operationIndex: index,
+      message: `Changing "${op.table}"."${op.column}" from ${op.fromType} to ${op.toType} may require a table rewrite on large tables.`,
+      suggestion: "On large tables, this can take significant time and lock the table. Consider running during low-traffic periods or using a phased approach."
+    });
+  }
+  return warnings;
+}
+function isLossyTypeChange(from, to) {
+  const fromUpper = from.toUpperCase();
+  const toUpper = to.toUpperCase();
+  if (isTextType(fromUpper) && isNumericType(toUpper))
+    return true;
+  if (fromUpper === "NUMERIC" && (toUpper === "INTEGER" || toUpper === "SMALLINT"))
+    return true;
+  if (fromUpper === "BIGINT" && (toUpper === "INTEGER" || toUpper === "SMALLINT"))
+    return true;
+  if (fromUpper === "DOUBLE PRECISION" && toUpper === "REAL")
+    return true;
+  if ((fromUpper === "JSONB" || fromUpper === "JSON") && !fromUpper.includes("JSON"))
+    return true;
+  if (fromUpper.includes("TIMESTAMP") && toUpper === "DATE")
+    return true;
+  const fromLength = extractLength(fromUpper);
+  const toLength = extractLength(toUpper);
+  if (fromLength && toLength && toLength < fromLength)
+    return true;
+  return false;
+}
+function isTableRewriteType(from, to) {
+  const fromUpper = from.toUpperCase();
+  const toUpper = to.toUpperCase();
+  if (fromUpper.startsWith("VARCHAR") && toUpper === "TEXT")
+    return false;
+  if (fromUpper === "TEXT" && toUpper.startsWith("VARCHAR"))
+    return true;
+  if (isNumericType(fromUpper) !== isNumericType(toUpper))
+    return true;
+  return false;
+}
+function isTextType(type) {
+  return type === "TEXT" || type.startsWith("VARCHAR") || type.startsWith("CHAR");
+}
+function isNumericType(type) {
+  return ["INTEGER", "BIGINT", "SMALLINT", "NUMERIC", "REAL", "DOUBLE PRECISION", "FLOAT"].includes(
+    type
+  );
+}
+function extractLength(type) {
+  const match = type.match(/\((\d+)\)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function isCreateIndexConcurrent(_op) {
+  return false;
+}
+
+// libs/migrations/src/lib/generator/sql-generator.ts
+function operationToSql(op, dialect) {
+  switch (op.type) {
+    case "createTable":
+      return generateCreateTable(op, dialect);
+    case "dropTable":
+      return `DROP TABLE IF EXISTS "${op.table}"`;
+    case "renameTable":
+      return `ALTER TABLE "${op.from}" RENAME TO "${op.to}"`;
+    case "addColumn":
+      return generateAddColumn(op, dialect);
+    case "dropColumn":
+      return generateDropColumn(op, dialect);
+    case "alterColumnType":
+      return generateAlterColumnType(op, dialect);
+    case "alterColumnNullable":
+      return generateAlterColumnNullable(op, dialect);
+    case "alterColumnDefault":
+      return generateAlterColumnDefault(op, dialect);
+    case "renameColumn":
+      return `ALTER TABLE "${op.table}" RENAME COLUMN "${op.from}" TO "${op.to}"`;
+    case "addForeignKey":
+      return generateAddForeignKey(op, dialect);
+    case "dropForeignKey":
+      return generateDropForeignKey(op, dialect);
+    case "createIndex":
+      return generateCreateIndex(op);
+    case "dropIndex":
+      return `DROP INDEX IF EXISTS "${op.indexName}"`;
+    case "rawSql":
+      return op.upSql;
+  }
+}
+function operationToReverseSql(op, dialect) {
+  switch (op.type) {
+    case "createTable":
+      return `DROP TABLE IF EXISTS "${op.table}"`;
+    case "dropTable":
+      return null;
+    case "renameTable":
+      return `ALTER TABLE "${op.to}" RENAME TO "${op.from}"`;
+    case "addColumn":
+      return `ALTER TABLE "${op.table}" DROP COLUMN "${op.column}"`;
+    case "dropColumn":
+      if (op.previousType) {
+        const nullable = op.previousNullable !== false ? "" : " NOT NULL";
+        return `ALTER TABLE "${op.table}" ADD COLUMN "${op.column}" ${op.previousType}${nullable}`;
+      }
+      return null;
+    case "alterColumnType":
+      return generateAlterColumnType(
+        { ...op, fromType: op.toType, toType: op.fromType },
+        dialect
+      );
+    case "alterColumnNullable":
+      return generateAlterColumnNullable(
+        { ...op, nullable: !op.nullable },
+        dialect
+      );
+    case "alterColumnDefault":
+      return generateAlterColumnDefault(
+        {
+          ...op,
+          defaultValue: op.previousDefault,
+          previousDefault: op.defaultValue
+        },
+        dialect
+      );
+    case "renameColumn":
+      return `ALTER TABLE "${op.table}" RENAME COLUMN "${op.to}" TO "${op.from}"`;
+    case "addForeignKey":
+      return generateDropForeignKey(
+        { type: "dropForeignKey", table: op.table, constraintName: op.constraintName },
+        dialect
+      );
+    case "dropForeignKey":
+      return null;
+    case "createIndex":
+      return `DROP INDEX IF EXISTS "${op.indexName}"`;
+    case "dropIndex":
+      return null;
+    case "rawSql":
+      return op.downSql;
+  }
+}
+function operationsToUpSql(operations, dialect) {
+  return operations.map((op) => operationToSql(op, dialect));
+}
+function operationsToDownSql(operations, dialect) {
+  return [...operations].reverse().map((op) => operationToReverseSql(op, dialect)).filter((sql) => sql !== null);
+}
+function generateCreateTable(op, _dialect) {
+  const columnDefs = op.columns.map((c) => {
+    let def = `"${c.name}" ${c.type}`;
+    if (c.primaryKey)
+      def += " PRIMARY KEY";
+    if (!c.nullable)
+      def += " NOT NULL";
+    if (c.defaultValue)
+      def += ` DEFAULT ${c.defaultValue}`;
+    return def;
+  });
+  return `CREATE TABLE "${op.table}" (
+  ${columnDefs.join(",\n  ")}
+)`;
+}
+function generateAddColumn(op, _dialect) {
+  let sql = `ALTER TABLE "${op.table}" ADD COLUMN "${op.column}" ${op.columnType}`;
+  if (!op.nullable)
+    sql += " NOT NULL";
+  if (op.defaultValue)
+    sql += ` DEFAULT ${op.defaultValue}`;
+  return sql;
+}
+function generateDropColumn(op, _dialect) {
+  return `ALTER TABLE "${op.table}" DROP COLUMN "${op.column}"`;
+}
+function generateAlterColumnType(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot alter column type for "${op.table}"."${op.column}" (${op.fromType} \u2192 ${op.toType}). Requires table rebuild.`;
+  }
+  const using = op.castExpression ? ` USING ${op.castExpression}` : ` USING "${op.column}"::${op.toType}`;
+  return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" TYPE ${op.toType}${using}`;
+}
+function generateAlterColumnNullable(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot alter nullable for "${op.table}"."${op.column}". Requires table rebuild.`;
+  }
+  if (op.nullable) {
+    return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" DROP NOT NULL`;
+  }
+  return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" SET NOT NULL`;
+}
+function generateAlterColumnDefault(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot alter default for "${op.table}"."${op.column}". Requires table rebuild.`;
+  }
+  if (op.defaultValue === null) {
+    return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" DROP DEFAULT`;
+  }
+  return `ALTER TABLE "${op.table}" ALTER COLUMN "${op.column}" SET DEFAULT ${op.defaultValue}`;
+}
+function generateAddForeignKey(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot add FK "${op.constraintName}" after table creation. Requires table rebuild.`;
+  }
+  return `ALTER TABLE "${op.table}" ADD CONSTRAINT "${op.constraintName}" FOREIGN KEY ("${op.column}") REFERENCES "${op.referencedTable}"("${op.referencedColumn}") ON DELETE ${op.onDelete}`;
+}
+function generateDropForeignKey(op, dialect) {
+  if (dialect === "sqlite") {
+    return `-- SQLite: Cannot drop FK "${op.constraintName}" after table creation. Requires table rebuild.`;
+  }
+  return `ALTER TABLE "${op.table}" DROP CONSTRAINT "${op.constraintName}"`;
+}
+function generateCreateIndex(op) {
+  const unique = op.unique ? "UNIQUE " : "";
+  const cols = op.columns.map((c) => `"${c}"`).join(", ");
+  return `CREATE ${unique}INDEX IF NOT EXISTS "${op.indexName}" ON "${op.table}" (${cols})`;
+}
+
+// libs/migrations/src/lib/generator/migration-file-generator.ts
+function generateMigrationName(name, timestamp) {
+  const d = timestamp ?? /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const prefix = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+  return `${prefix}_${name}`;
+}
+function generateMigrationFileContent(diff, options) {
+  const { name, description, dialect } = options;
+  const desc = description ?? (diff.summary.join("; ") || "Auto-generated migration");
+  const upStatements = operationsToUpSql(diff.operations, dialect);
+  const downStatements = operationsToDownSql(diff.operations, dialect);
+  const operationsMeta = serializeOperationsMeta(diff.operations);
+  const lines = [];
+  lines.push("import type { MigrationFile, MigrationContext } from '@momentumcms/migrations';");
+  lines.push("");
+  lines.push("export const meta: MigrationFile['meta'] = {");
+  lines.push(`	name: ${JSON.stringify(name)},`);
+  lines.push(`	description: ${JSON.stringify(desc)},`);
+  lines.push(`	operations: ${operationsMeta},`);
+  lines.push("};");
+  lines.push("");
+  lines.push("export async function up(ctx: MigrationContext): Promise<void> {");
+  for (const sql of upStatements) {
+    if (sql.startsWith("--")) {
+      lines.push(`	// ${sql.slice(3)}`);
+    } else {
+      lines.push(`	await ctx.sql(${JSON.stringify(sql)});`);
+    }
+  }
+  if (upStatements.length === 0) {
+    lines.push("	// No operations");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("export async function down(ctx: MigrationContext): Promise<void> {");
+  for (const sql of downStatements) {
+    if (sql.startsWith("--")) {
+      lines.push(`	// ${sql.slice(3)}`);
+    } else {
+      lines.push(`	await ctx.sql(${JSON.stringify(sql)});`);
+    }
+  }
+  if (downStatements.length === 0) {
+    lines.push("	// Cannot reverse all operations");
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function serializeOperationsMeta(operations) {
+  const simplified = operations.map((op) => {
+    switch (op.type) {
+      case "createTable":
+        return { type: op.type, table: op.table };
+      case "dropTable":
+        return { type: op.type, table: op.table };
+      case "renameTable":
+        return { type: op.type, from: op.from, to: op.to };
+      case "addColumn":
+        return {
+          type: op.type,
+          table: op.table,
+          column: op.column,
+          nullable: op.nullable,
+          defaultValue: op.defaultValue ?? null
+        };
+      case "dropColumn":
+        return { type: op.type, table: op.table, column: op.column };
+      case "alterColumnType":
+        return {
+          type: op.type,
+          table: op.table,
+          column: op.column,
+          fromType: op.fromType,
+          toType: op.toType
+        };
+      case "alterColumnNullable":
+        return { type: op.type, table: op.table, column: op.column, nullable: op.nullable };
+      case "alterColumnDefault":
+        return { type: op.type, table: op.table, column: op.column };
+      case "renameColumn":
+        return { type: op.type, table: op.table, from: op.from, to: op.to };
+      case "addForeignKey":
+        return { type: op.type, table: op.table, constraintName: op.constraintName };
+      case "dropForeignKey":
+        return { type: op.type, table: op.table, constraintName: op.constraintName };
+      case "createIndex":
+        return { type: op.type, table: op.table, indexName: op.indexName };
+      case "dropIndex":
+        return { type: op.type, table: op.table, indexName: op.indexName };
+      case "rawSql":
+        return { type: op.type, description: op.description };
+    }
+  });
+  return JSON.stringify(simplified, null, "	");
+}
+
+// libs/migrations/src/lib/loader/snapshot-manager.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+var SNAPSHOT_FILENAME = ".snapshot.json";
+function readSnapshot(directory) {
+  const filePath = join(directory, SNAPSHOT_FILENAME);
+  if (!existsSync(filePath))
+    return null;
+  const json2 = readFileSync(filePath, "utf-8");
+  return deserializeSnapshot(json2);
+}
+function writeSnapshot(directory, snapshot) {
+  mkdirSync(directory, { recursive: true });
+  const filePath = join(directory, SNAPSHOT_FILENAME);
+  writeFileSync(filePath, serializeSnapshot(snapshot), "utf-8");
+}
+
+// libs/migrations/src/cli/shared.ts
+import { pathToFileURL } from "node:url";
+
+// libs/migrations/src/lib/schema/introspect-postgres.ts
+async function introspectPostgres(queryFn, schema = "public") {
+  const [columnRows, fkRows, indexRows, pkRows] = await Promise.all([
+    queryFn(
+      `SELECT table_name, column_name, data_type, character_maximum_length, is_nullable, column_default
+			 FROM information_schema.columns
+			 WHERE table_schema = $1
+			 ORDER BY table_name, ordinal_position`,
+      [schema]
+    ),
+    queryFn(
+      `SELECT
+				tc.table_name,
+				tc.constraint_name,
+				kcu.column_name,
+				ccu.table_name AS foreign_table_name,
+				ccu.column_name AS foreign_column_name,
+				rc.delete_rule
+			 FROM information_schema.table_constraints tc
+			 JOIN information_schema.key_column_usage kcu
+				ON tc.constraint_name = kcu.constraint_name
+				AND tc.table_schema = kcu.table_schema
+			 JOIN information_schema.constraint_column_usage ccu
+				ON ccu.constraint_name = tc.constraint_name
+				AND ccu.table_schema = tc.table_schema
+			 JOIN information_schema.referential_constraints rc
+				ON rc.constraint_name = tc.constraint_name
+				AND rc.constraint_schema = tc.constraint_schema
+			 WHERE tc.constraint_type = 'FOREIGN KEY'
+				AND tc.table_schema = $1
+			 ORDER BY tc.table_name, tc.constraint_name`,
+      [schema]
+    ),
+    queryFn(
+      `SELECT tablename, indexname, indexdef
+			 FROM pg_indexes
+			 WHERE schemaname = $1
+			 ORDER BY tablename, indexname`,
+      [schema]
+    ),
+    queryFn(
+      `SELECT tc.table_name, kcu.column_name
+			 FROM information_schema.table_constraints tc
+			 JOIN information_schema.key_column_usage kcu
+				ON tc.constraint_name = kcu.constraint_name
+				AND tc.table_schema = kcu.table_schema
+			 WHERE tc.constraint_type = 'PRIMARY KEY'
+				AND tc.table_schema = $1`,
+      [schema]
+    )
+  ]);
+  const pkLookup = /* @__PURE__ */ new Map();
+  for (const row2 of pkRows) {
+    const tableName = row2.table_name;
+    if (!pkLookup.has(tableName)) {
+      pkLookup.set(tableName, /* @__PURE__ */ new Set());
+    }
+    pkLookup.get(tableName).add(row2.column_name);
+  }
+  const tableColumnsMap = /* @__PURE__ */ new Map();
+  for (const row2 of columnRows) {
+    const tableName = row2.table_name;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    if (!tableColumnsMap.has(tableName)) {
+      tableColumnsMap.set(tableName, []);
+    }
+    const rawType = buildPgColumnType(row2);
+    const pkSet = pkLookup.get(tableName);
+    tableColumnsMap.get(tableName).push({
+      name: row2.column_name,
+      type: normalizeColumnType(rawType, "postgresql"),
+      nullable: row2.is_nullable === "YES",
+      defaultValue: row2.column_default,
+      isPrimaryKey: pkSet?.has(row2.column_name) ?? false
+    });
+  }
+  const tableFkMap = /* @__PURE__ */ new Map();
+  for (const row2 of fkRows) {
+    const tableName = row2.table_name;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    if (!tableFkMap.has(tableName)) {
+      tableFkMap.set(tableName, []);
+    }
+    tableFkMap.get(tableName).push({
+      constraintName: row2.constraint_name,
+      column: row2.column_name,
+      referencedTable: row2.foreign_table_name,
+      referencedColumn: row2.foreign_column_name,
+      onDelete: row2.delete_rule
+    });
+  }
+  const fkConstraintNames = new Set(fkRows.map((r) => r.constraint_name));
+  const tableIndexMap = /* @__PURE__ */ new Map();
+  for (const row2 of indexRows) {
+    const tableName = row2.tablename;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    if (row2.indexdef.includes("PRIMARY KEY"))
+      continue;
+    if (fkConstraintNames.has(row2.indexname))
+      continue;
+    if (row2.indexname.endsWith("_pkey"))
+      continue;
+    if (!tableIndexMap.has(tableName)) {
+      tableIndexMap.set(tableName, []);
+    }
+    const columns = extractIndexColumns(row2.indexdef);
+    const unique = row2.indexdef.toUpperCase().includes("UNIQUE");
+    tableIndexMap.get(tableName).push({
+      name: row2.indexname,
+      columns,
+      unique
+    });
+  }
+  const tables = [];
+  for (const [tableName, columns] of tableColumnsMap) {
+    tables.push({
+      name: tableName,
+      columns,
+      foreignKeys: tableFkMap.get(tableName) ?? [],
+      indexes: tableIndexMap.get(tableName) ?? []
+    });
+  }
+  return createSchemaSnapshot("postgresql", tables);
+}
+function buildPgColumnType(row2) {
+  const dataType = row2.data_type.toUpperCase();
+  if (dataType === "CHARACTER VARYING") {
+    const len = row2.character_maximum_length ?? 255;
+    return `VARCHAR(${len})`;
+  }
+  if (dataType === "CHARACTER") {
+    const len = row2.character_maximum_length ?? 1;
+    return `CHAR(${len})`;
+  }
+  return dataType;
+}
+function extractIndexColumns(indexDef) {
+  const match = indexDef.match(/\(([^)]+)\)\s*$/);
+  if (!match)
+    return [];
+  return match[1].split(",").map((col) => col.trim().replace(/^"/, "").replace(/"$/, "")).filter((col) => col.length > 0);
+}
+
+// libs/migrations/src/lib/schema/introspect-sqlite.ts
+async function introspectSqlite(queryFn) {
+  const masterRows = await queryFn(
+    `SELECT name, type, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+  );
+  const tables = [];
+  for (const masterRow of masterRows) {
+    const tableName = masterRow.name;
+    if (INTERNAL_TABLES.has(tableName))
+      continue;
+    const columnRows = await queryFn(
+      `PRAGMA table_info("${tableName}")`
+    );
+    const columns = columnRows.map((row2) => ({
+      name: row2.name,
+      type: normalizeColumnType(row2.type || "TEXT", "sqlite"),
+      nullable: row2.notnull === 0,
+      defaultValue: row2.dflt_value,
+      isPrimaryKey: row2.pk > 0
+    }));
+    const fkRows = await queryFn(
+      `PRAGMA foreign_key_list("${tableName}")`
+    );
+    const foreignKeys = fkRows.map((row2) => ({
+      constraintName: `fk_${tableName}_${row2.from}`,
+      column: row2.from,
+      referencedTable: row2.table,
+      referencedColumn: row2.to,
+      onDelete: row2.on_delete
+    }));
+    const indexListRows = await queryFn(
+      `PRAGMA index_list("${tableName}")`
+    );
+    const indexes = [];
+    for (const idxRow of indexListRows) {
+      if (idxRow.origin === "pk")
+        continue;
+      const indexInfoRows = await queryFn(
+        `PRAGMA index_info("${idxRow.name}")`
+      );
+      const indexColumns = indexInfoRows.sort((a, b) => a.seqno - b.seqno).map((r) => r.name).filter((n) => n.length > 0);
+      if (indexColumns.length > 0) {
+        indexes.push({
+          name: idxRow.name,
+          columns: indexColumns,
+          unique: idxRow.unique === 1
+        });
+      }
+    }
+    tables.push({
+      name: tableName,
+      columns,
+      foreignKeys,
+      indexes
+    });
+  }
+  return createSchemaSnapshot("sqlite", tables);
+}
+
+// libs/migrations/src/cli/shared.ts
+function isResolvedConfig(value) {
+  return typeof value === "object" && value !== null && "collections" in value && "db" in value;
+}
+async function loadMomentumConfig(configPath) {
+  const configUrl = pathToFileURL(configPath).href;
+  const mod = await import(configUrl);
+  const raw = mod["default"] ?? mod;
+  if (!isResolvedConfig(raw)) {
+    throw new Error(`Config at ${configPath} is not a valid ResolvedMomentumConfig`);
+  }
+  if (!raw.db?.adapter) {
+    throw new Error(`Config at ${configPath} is missing db.adapter`);
+  }
+  if (!raw.collections || raw.collections.length === 0) {
+    throw new Error(`Config at ${configPath} has no collections`);
+  }
+  return raw;
+}
+function resolveDialect(adapter) {
+  if (!adapter.dialect) {
+    throw new Error(
+      "DatabaseAdapter.dialect is not set. Ensure your adapter factory (postgresAdapter/sqliteAdapter) sets the dialect property."
+    );
+  }
+  return adapter.dialect;
+}
+function buildIntrospector(adapter, dialect) {
+  if (!adapter.queryRaw) {
+    throw new Error("DatabaseAdapter must implement queryRaw for introspection");
+  }
+  const queryRaw = adapter.queryRaw.bind(adapter);
+  if (dialect === "postgresql") {
+    const queryFn2 = async (sql, params) => queryRaw(sql, params);
+    return () => introspectPostgres(queryFn2);
+  }
+  const queryFn = async (sql, params) => queryRaw(sql, params);
+  return () => introspectSqlite(queryFn);
+}
+function parseMigrationArgs(args) {
+  const configPath = args.find((a) => !a.startsWith("--"));
+  if (!configPath) {
+    throw new Error("Usage: npx tsx <command>.ts <configPath> [options]");
+  }
+  let name;
+  const nameIdx = args.indexOf("--name");
+  if (nameIdx !== -1 && args[nameIdx + 1]) {
+    name = args[nameIdx + 1];
+  }
+  return {
+    configPath,
+    name,
+    dryRun: args.includes("--dry-run"),
+    testOnly: args.includes("--test-only"),
+    skipCloneTest: args.includes("--skip-clone-test")
+  };
+}
+
+// libs/migrations/src/cli/generate.ts
+async function main() {
+  const args = parseMigrationArgs(process.argv.slice(2));
+  const config = await loadMomentumConfig(resolve(args.configPath));
+  const adapter = config.db.adapter;
+  const dialect = resolveDialect(adapter);
+  const migrationConfig = resolveMigrationConfig(config.migrations ?? {});
+  if (!migrationConfig) {
+    console.warn("No migration config found. Add migrations to your momentum.config.ts.");
+    process.exit(1);
+  }
+  const directory = resolve(migrationConfig.directory);
+  const desired = collectionsToSchema(config.collections, dialect);
+  let previous = readSnapshot(directory);
+  if (!previous) {
+    try {
+      const introspect = buildIntrospector(adapter, dialect);
+      previous = await introspect();
+    } catch {
+      previous = createSchemaSnapshot(dialect, []);
+    }
+  }
+  const diff = diffSchemas(desired, previous, dialect);
+  if (diff.operations.length === 0) {
+    console.warn("Schema up to date. No migration needed.");
+    if (!args.dryRun) {
+      writeSnapshot(directory, desired);
+    }
+    return;
+  }
+  if (migrationConfig.dangerDetection) {
+    const dangers = detectDangers(diff.operations, dialect);
+    if (dangers.warnings.length > 0) {
+      console.warn("\n--- Danger Detection ---");
+      for (const w of dangers.warnings) {
+        console.warn(`  [${w.severity}] ${w.message}`);
+        if (w.suggestion)
+          console.warn(`    Suggestion: ${w.suggestion}`);
+      }
+      if (dangers.hasErrors) {
+        console.error("\nBlocked: migration contains error-severity dangers.");
+        console.error(
+          "Review the operations and adjust your collections, or disable danger detection."
+        );
+        process.exit(1);
+      }
+      console.warn("");
+    }
+  }
+  const migrationName = args.name ?? "migration";
+  const timestampedName = generateMigrationName(migrationName);
+  const fileContent = generateMigrationFileContent(diff, {
+    name: timestampedName,
+    dialect
+  });
+  if (args.dryRun) {
+    console.warn("\n--- Dry Run (migration file content) ---\n");
+    console.warn(fileContent);
+    console.warn(`
+Would write: ${join2(directory, `${timestampedName}.ts`)}`);
+    console.warn(`Operations: ${diff.operations.length}`);
+    console.warn(`Summary: ${diff.summary.join("; ")}`);
+    return;
+  }
+  mkdirSync2(directory, { recursive: true });
+  const filePath = join2(directory, `${timestampedName}.ts`);
+  writeFileSync2(filePath, fileContent, "utf-8");
+  writeSnapshot(directory, desired);
+  console.warn(`
+Generated migration: ${filePath}`);
+  console.warn(`Operations: ${diff.operations.length}`);
+  console.warn(`Summary: ${diff.summary.join("; ")}`);
+}
+main().catch((err) => {
+  console.error("Migration generate failed:", err);
+  process.exit(1);
+});