@momentumcms/migrations 0.3.0 → 0.4.0

package/src/cli/rollback.cjs

@@ -0,0 +1,640 @@
+"use strict";
+
+// libs/migrations/src/cli/rollback.ts
+var import_node_path2 = require("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;
+}
+
+// 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/loader/migration-loader.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var MIGRATION_FILE_PATTERN = /^\d{14}_.+\.ts$/;
+function isMigrationFile(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return "meta" in obj && typeof obj["meta"] === "object" && obj["meta"] !== null && "up" in obj && typeof obj["up"] === "function" && "down" in obj && typeof obj["down"] === "function";
+}
+function validateMigrationModule(mod, filePath) {
+  const file = mod["default"] ?? mod;
+  if (!isMigrationFile(file)) {
+    if (typeof file !== "object" || file === null) {
+      throw new Error(`Migration file ${filePath} does not export a valid module`);
+    }
+    if (!("meta" in file) || typeof file["meta"] !== "object") {
+      throw new Error(`Migration file ${filePath} is missing a valid 'meta' export`);
+    }
+    if (!("up" in file) || typeof file["up"] !== "function") {
+      throw new Error(`Migration file ${filePath} is missing an 'up' function export`);
+    }
+    if (!("down" in file) || typeof file["down"] !== "function") {
+      throw new Error(`Migration file ${filePath} is missing a 'down' function export`);
+    }
+    throw new Error(`Migration file ${filePath} does not conform to MigrationFile interface`);
+  }
+  return file;
+}
+async function loadMigrationsFromDisk(directory) {
+  if (!(0, import_node_fs.existsSync)(directory))
+    return [];
+  const files = (0, import_node_fs.readdirSync)(directory).filter((f) => MIGRATION_FILE_PATTERN.test(f)).sort();
+  if (files.length === 0)
+    return [];
+  const migrations = [];
+  for (const filename of files) {
+    const filePath = (0, import_node_path.join)(directory, filename);
+    const fileUrl = (0, import_node_url.pathToFileURL)(filePath).href;
+    const mod = await import(fileUrl);
+    const file = validateMigrationModule(mod, filePath);
+    const name = filename.replace(/\.ts$/, "");
+    migrations.push({ name, file });
+  }
+  return migrations;
+}
+
+// libs/migrations/src/lib/migration.types.ts
+var MIGRATION_TRACKING_TABLE = "_momentum_migrations";
+
+// libs/migrations/src/lib/tracking/migration-tracker.ts
+async function ensureTrackingTable(db, dialect) {
+  if (dialect === "postgresql") {
+    await db.execute(`
+			CREATE TABLE IF NOT EXISTS "${MIGRATION_TRACKING_TABLE}" (
+				"id" VARCHAR(36) PRIMARY KEY,
+				"name" VARCHAR(255) NOT NULL UNIQUE,
+				"batch" INTEGER NOT NULL,
+				"checksum" VARCHAR(64) NOT NULL,
+				"appliedAt" TIMESTAMPTZ NOT NULL,
+				"executionMs" INTEGER NOT NULL
+			)
+		`);
+  } else {
+    await db.execute(`
+			CREATE TABLE IF NOT EXISTS "${MIGRATION_TRACKING_TABLE}" (
+				"id" TEXT PRIMARY KEY,
+				"name" TEXT NOT NULL UNIQUE,
+				"batch" INTEGER NOT NULL,
+				"checksum" TEXT NOT NULL,
+				"appliedAt" TEXT NOT NULL,
+				"executionMs" INTEGER NOT NULL
+			)
+		`);
+  }
+}
+async function removeMigrationRecord(db, name, dialect) {
+  const placeholder = dialect === "postgresql" ? "$1" : "?";
+  const affected = await db.execute(
+    `DELETE FROM "${MIGRATION_TRACKING_TABLE}" WHERE "name" = ${placeholder}`,
+    [name]
+  );
+  return affected > 0;
+}
+async function getMigrationsByBatch(db, batch, dialect) {
+  const placeholder = dialect === "postgresql" ? "$1" : "?";
+  const rows = await db.query(
+    `SELECT * FROM "${MIGRATION_TRACKING_TABLE}" WHERE "batch" = ${placeholder} ORDER BY "name" DESC`,
+    [batch]
+  );
+  return rows.map(toTrackingRecord);
+}
+async function getLatestBatchNumber(db) {
+  const rows = await db.query(
+    `SELECT MAX("batch") as max_batch FROM "${MIGRATION_TRACKING_TABLE}"`
+  );
+  return typeof rows[0]?.max_batch === "number" ? rows[0].max_batch : 0;
+}
+function toTrackingRecord(row2) {
+  return {
+    id: String(row2["id"]),
+    name: String(row2["name"]),
+    batch: Number(row2["batch"]),
+    checksum: String(row2["checksum"]),
+    appliedAt: String(row2["appliedAt"]),
+    executionMs: Number(row2["executionMs"])
+  };
+}
+
+// libs/migrations/src/lib/runner/migrate-runner.ts
+async function rollbackBatch(options) {
+  const { migrations, dialect, tracker, buildContext, log } = options;
+  const noop = {
+    info: () => {
+    },
+    warn: () => {
+    }
+  };
+  const logger = log ?? noop;
+  await ensureTrackingTable(tracker, dialect);
+  const latestBatch = await getLatestBatchNumber(tracker);
+  if (latestBatch === 0) {
+    logger.info("Nothing to rollback.");
+    return { batch: 0, results: [], successCount: 0, failCount: 0, dangers: null };
+  }
+  const batchMigrations = await getMigrationsByBatch(tracker, latestBatch, dialect);
+  if (batchMigrations.length === 0) {
+    logger.info("No migrations in latest batch.");
+    return { batch: 0, results: [], successCount: 0, failCount: 0, dangers: null };
+  }
+  logger.info(`Rolling back batch ${latestBatch} (${batchMigrations.length} migration(s))...`);
+  const migrationMap = new Map(migrations.map((m) => [m.name, m]));
+  const results = [];
+  const ctx = buildContext();
+  for (const record of batchMigrations) {
+    const migration = migrationMap.get(record.name);
+    if (!migration) {
+      results.push({
+        name: record.name,
+        success: false,
+        executionMs: 0,
+        error: `Migration file "${record.name}" not found`
+      });
+      logger.warn(`  MISSING: ${record.name}`);
+      break;
+    }
+    const start = Date.now();
+    try {
+      await migration.file.down(ctx);
+      const executionMs = Date.now() - start;
+      await removeMigrationRecord(tracker, record.name, dialect);
+      results.push({ name: record.name, success: true, executionMs });
+      logger.info(`  Rolled back: ${record.name} (${executionMs}ms)`);
+    } catch (err) {
+      const executionMs = Date.now() - start;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const errorCode = extractErrorCode(err);
+      results.push({ name: record.name, success: false, executionMs, error: errMsg, errorCode });
+      logger.warn(`  FAILED rollback: ${record.name} \u2014 ${errMsg}`);
+      break;
+    }
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  return { batch: latestBatch, results, successCount, failCount, dangers: null };
+}
+function extractErrorCode(err) {
+  if (err !== null && typeof err === "object" && "code" in err && typeof err.code === "string") {
+    return err.code;
+  }
+  return void 0;
+}
+
+// libs/migrations/src/cli/shared.ts
+var import_node_url2 = require("node:url");
+
+// libs/migrations/src/lib/helpers/data-helpers.ts
+function createDataHelpers(db, dialect) {
+  const ph = (index) => dialect === "postgresql" ? `$${index}` : "?";
+  return {
+    async backfill(table, column, value, options) {
+      const where = options?.where ? ` AND (${options.where})` : "";
+      const batchSize = options?.batchSize ?? 1e3;
+      let totalAffected = 0;
+      if (dialect === "postgresql") {
+        let affected;
+        do {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${ph(1)}
+						 WHERE ctid IN (
+							SELECT ctid FROM "${table}"
+							WHERE "${column}" IS NULL${where}
+							LIMIT ${batchSize}
+						 )`,
+            [value]
+          );
+          totalAffected += affected;
+        } while (affected >= batchSize);
+      } else {
+        let affected;
+        do {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${ph(1)}
+						 WHERE rowid IN (
+							SELECT rowid FROM "${table}"
+							WHERE "${column}" IS NULL${where}
+							LIMIT ${batchSize}
+						 )`,
+            [value]
+          );
+          totalAffected += affected;
+        } while (affected >= batchSize);
+      }
+      return totalAffected;
+    },
+    async transform(table, column, sqlExpression, options) {
+      const where = options?.where ? ` WHERE ${options.where}` : "";
+      const batchSize = options?.batchSize ?? 0;
+      if (batchSize <= 0) {
+        return db.execute(
+          `UPDATE "${table}" SET "${column}" = ${sqlExpression}${where}`
+        );
+      }
+      let totalAffected = 0;
+      let affected;
+      do {
+        if (dialect === "postgresql") {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${sqlExpression}
+						 WHERE ctid IN (
+							SELECT ctid FROM "${table}"${where}
+							LIMIT ${batchSize}
+						 )`
+          );
+        } else {
+          affected = await db.execute(
+            `UPDATE "${table}" SET "${column}" = ${sqlExpression}
+						 WHERE rowid IN (
+							SELECT rowid FROM "${table}"${where}
+							LIMIT ${batchSize}
+						 )`
+          );
+        }
+        totalAffected += affected;
+      } while (affected >= batchSize);
+      return totalAffected;
+    },
+    async renameColumn(table, from, to, columnType) {
+      await db.execute(
+        `ALTER TABLE "${table}" ADD COLUMN "${to}" ${columnType}`
+      );
+      await db.execute(
+        `UPDATE "${table}" SET "${to}" = "${from}"`
+      );
+      await db.execute(
+        `ALTER TABLE "${table}" DROP COLUMN "${from}"`
+      );
+    },
+    async splitColumn(table, _sourceColumn, targets) {
+      for (const target of targets) {
+        await db.execute(
+          `ALTER TABLE "${table}" ADD COLUMN "${target.name}" ${target.type}`
+        );
+        await db.execute(
+          `UPDATE "${table}" SET "${target.name}" = ${target.expression}`
+        );
+      }
+    },
+    async mergeColumns(table, _sourceColumns, targetColumn, targetType, mergeExpression) {
+      await db.execute(
+        `ALTER TABLE "${table}" ADD COLUMN "${targetColumn}" ${targetType}`
+      );
+      await db.execute(
+        `UPDATE "${table}" SET "${targetColumn}" = ${mergeExpression}`
+      );
+    },
+    async copyData(sourceTable, targetTable, columnMapping, options) {
+      const targetCols = [];
+      const sourceCols = [];
+      for (const [target, source] of Object.entries(columnMapping)) {
+        targetCols.push(`"${target}"`);
+        if (typeof source === "string") {
+          sourceCols.push(`"${source}"`);
+        } else {
+          sourceCols.push(source.expression);
+        }
+      }
+      const where = options?.where ? ` WHERE ${options.where}` : "";
+      const affected = await db.execute(
+        `INSERT INTO "${targetTable}" (${targetCols.join(", ")})
+				 SELECT ${sourceCols.join(", ")} FROM "${sourceTable}"${where}`
+      );
+      return affected;
+    },
+    async columnToJson(table, sourceColumn, jsonColumn, jsonKey) {
+      if (dialect === "postgresql") {
+        await db.execute(
+          `UPDATE "${table}" SET "${jsonColumn}" = COALESCE("${jsonColumn}", '{}'::jsonb) || jsonb_build_object('${jsonKey}', "${sourceColumn}")`
+        );
+      } else {
+        await db.execute(
+          `UPDATE "${table}" SET "${jsonColumn}" = json_set(COALESCE("${jsonColumn}", '{}'), '$.${jsonKey}', "${sourceColumn}")`
+        );
+      }
+    },
+    async jsonToColumn(table, jsonColumn, jsonKey, targetColumn, targetType) {
+      await db.execute(
+        `ALTER TABLE "${table}" ADD COLUMN "${targetColumn}" ${targetType}`
+      );
+      if (dialect === "postgresql") {
+        await db.execute(
+          `UPDATE "${table}" SET "${targetColumn}" = "${jsonColumn}"->>'${jsonKey}'`
+        );
+      } else {
+        await db.execute(
+          `UPDATE "${table}" SET "${targetColumn}" = json_extract("${jsonColumn}", '$.${jsonKey}')`
+        );
+      }
+    },
+    async dedup(table, columns, keepStrategy = "latest") {
+      const colList = columns.map((c) => `"${c}"`).join(", ");
+      let orderBy;
+      switch (keepStrategy) {
+        case "earliest":
+          orderBy = '"createdAt" ASC';
+          break;
+        case "first":
+          orderBy = dialect === "postgresql" ? "ctid ASC" : "rowid ASC";
+          break;
+        default:
+          orderBy = '"createdAt" DESC';
+          break;
+      }
+      if (dialect === "postgresql") {
+        return db.execute(
+          `DELETE FROM "${table}" WHERE ctid NOT IN (
+						SELECT DISTINCT ON (${colList}) ctid
+						FROM "${table}"
+						ORDER BY ${colList}, ${orderBy}
+					)`
+        );
+      }
+      return db.execute(
+        `DELETE FROM "${table}" WHERE rowid NOT IN (
+					SELECT MIN(rowid) FROM "${table}"
+					GROUP BY ${colList}
+				)`
+      );
+    }
+  };
+}
+
+// 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 = (0, import_node_url2.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 buildTrackerFromAdapter(adapter) {
+  if (!adapter.queryRaw || !adapter.executeRaw) {
+    throw new Error("DatabaseAdapter must implement queryRaw and executeRaw for migration tracking");
+  }
+  const queryRaw = adapter.queryRaw.bind(adapter);
+  const executeRaw = adapter.executeRaw.bind(adapter);
+  return {
+    async query(sql, params) {
+      return queryRaw(sql, params);
+    },
+    async execute(sql, params) {
+      return executeRaw(sql, params);
+    }
+  };
+}
+function buildContextFromAdapter(adapter, dialect) {
+  if (!adapter.queryRaw || !adapter.executeRaw) {
+    throw new Error("DatabaseAdapter must implement queryRaw and executeRaw for migration context");
+  }
+  const queryRaw = adapter.queryRaw.bind(adapter);
+  const executeRaw = adapter.executeRaw.bind(adapter);
+  const dataDb = {
+    async execute(sql, params) {
+      return executeRaw(sql, params);
+    },
+    async query(sql, params) {
+      return queryRaw(sql, params);
+    }
+  };
+  const helpers = createDataHelpers(dataDb, dialect);
+  return {
+    async sql(query, params) {
+      await executeRaw(query, params);
+    },
+    async query(sql, params) {
+      return queryRaw(sql, params);
+    },
+    data: helpers,
+    dialect,
+    log: {
+      info: (msg) => {
+        console.warn(`[migration] ${msg}`);
+      },
+      warn: (msg) => {
+        console.warn(`[migration:warn] ${msg}`);
+      }
+    }
+  };
+}
+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/rollback.ts
+async function main() {
+  const args = parseMigrationArgs(process.argv.slice(2));
+  const config = await loadMomentumConfig((0, import_node_path2.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.");
+    process.exit(1);
+  }
+  const directory = (0, import_node_path2.resolve)(migrationConfig.directory);
+  const migrations = await loadMigrationsFromDisk(directory);
+  if (migrations.length === 0) {
+    console.warn("No migration files found in", directory);
+    return;
+  }
+  const tracker = buildTrackerFromAdapter(adapter);
+  const buildContext = () => buildContextFromAdapter(adapter, dialect);
+  const log = {
+    info: (msg) => console.warn(`[migration] ${msg}`),
+    warn: (msg) => console.warn(`[migration:warn] ${msg}`)
+  };
+  const result = await rollbackBatch({
+    migrations,
+    dialect,
+    tracker,
+    buildContext,
+    log
+  });
+  if (result.batch === 0) {
+    console.warn("Nothing to rollback.");
+    return;
+  }
+  console.warn(`
+Rolled back batch ${result.batch}: ${result.successCount} migration(s)`);
+  if (result.failCount > 0) {
+    console.error(`Failed: ${result.failCount} migration(s)`);
+    for (const r of result.results) {
+      if (!r.success) {
+        console.error(`  ${r.name}: ${r.error}`);
+      }
+    }
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Migration rollback failed:", err);
+  process.exit(1);
+});