@insforge/cli 0.1.53-dev.0 → 0.1.53-dev.1

package/dist/index.js

@@ -2678,7 +2678,7 @@ import { join as join8 } from "path";
 // src/lib/migrations.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { join as join7 } from "path";
-var MIGRATION_FILENAME_REGEX = /^([1-9][0-9]*)_([a-z0-9-]+)\.sql$/;
+var MIGRATION_FILENAME_REGEX = /^(\d{14})_([a-z0-9-]+)\.sql$/;
 function parseMigrationFilename(filename) {
   const match = MIGRATION_FILENAME_REGEX.exec(filename);
   if (!match) {
@@ -2686,10 +2686,32 @@ function parseMigrationFilename(filename) {
   }
   return {
     filename,
-    sequenceNumber: Number(match[1]),
+    version: match[1],
     name: match[2]
   };
 }
+function compareMigrationVersions(left, right) {
+  return left.localeCompare(right);
+}
+function formatMigrationVersion(date) {
+  const year = String(date.getUTCFullYear());
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hour = String(date.getUTCHours()).padStart(2, "0");
+  const minute = String(date.getUTCMinutes()).padStart(2, "0");
+  const second = String(date.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hour}${minute}${second}`;
+}
+function incrementMigrationVersion(version) {
+  const year = Number(version.slice(0, 4));
+  const month = Number(version.slice(4, 6)) - 1;
+  const day = Number(version.slice(6, 8));
+  const hour = Number(version.slice(8, 10));
+  const minute = Number(version.slice(10, 12));
+  const second = Number(version.slice(12, 14));
+  const nextTimestamp = Date.UTC(year, month, day, hour, minute, second + 1);
+  return formatMigrationVersion(new Date(nextTimestamp));
+}
 function getMigrationsDir(cwd = process.cwd()) {
   return join7(cwd, ".insforge", "migrations");
 }
@@ -2712,82 +2734,85 @@ function parseStrictLocalMigrations(filenames) {
     const parsedMigration = parseMigrationFilename(filename);
     if (!parsedMigration) {
       throw new CLIError(
-        `Invalid migration filename: ${filename}. Expected <sequence_number>_<migration-name>.sql.`
+        `Invalid migration filename: ${filename}. Expected <migration_version>_<migration-name>.sql.`
       );
     }
     return parsedMigration;
   });
-  assertNoDuplicateMigrationSequences(migrations);
-  return migrations.sort((left, right) => left.sequenceNumber - right.sequenceNumber);
+  assertNoDuplicateMigrationVersions(migrations);
+  return migrations.sort((left, right) => compareMigrationVersions(left.version, right.version));
 }
-function assertNoDuplicateMigrationSequences(migrations) {
+function assertNoDuplicateMigrationVersions(migrations) {
   const seen = /* @__PURE__ */ new Set();
   for (const migration of migrations) {
-    if (seen.has(migration.sequenceNumber)) {
-      throw new CLIError(`Duplicate local migration sequence found: ${migration.sequenceNumber}`);
+    if (seen.has(migration.version)) {
+      throw new CLIError(`Duplicate local migration version found: ${migration.version}`);
     }
-    seen.add(migration.sequenceNumber);
+    seen.add(migration.version);
   }
 }
-function getNextLocalMigrationSequence(migrations, latestRemoteSequenceNumber) {
-  const orderedMigrations = [...migrations].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
-  assertNoDuplicateMigrationSequences(orderedMigrations);
-  let expectedSequenceNumber = latestRemoteSequenceNumber + 1;
-  for (const migration of orderedMigrations) {
-    if (migration.sequenceNumber <= latestRemoteSequenceNumber) {
-      continue;
-    }
-    if (migration.sequenceNumber !== expectedSequenceNumber) {
-      throw new CLIError(
-        `Local pending migrations must be contiguous after remote sequence ${latestRemoteSequenceNumber}.`
-      );
-    }
-    expectedSequenceNumber += 1;
+function getNextLocalMigrationVersion(migrations, latestRemoteVersion, now = /* @__PURE__ */ new Date()) {
+  const orderedMigrations = [...migrations].sort(
+    (left, right) => compareMigrationVersions(left.version, right.version)
+  );
+  assertNoDuplicateMigrationVersions(orderedMigrations);
+  const latestKnownVersion = orderedMigrations.reduce(
+    (latestVersion, migration) => {
+      if (!latestVersion || compareMigrationVersions(migration.version, latestVersion) > 0) {
+        return migration.version;
+      }
+      return latestVersion;
+    },
+    latestRemoteVersion
+  );
+  const currentVersion = formatMigrationVersion(now);
+  if (!latestKnownVersion || compareMigrationVersions(currentVersion, latestKnownVersion) > 0) {
+    return currentVersion;
   }
-  return expectedSequenceNumber;
+  return incrementMigrationVersion(latestKnownVersion);
 }
 function formatMigrationSql(statements) {
   return statements.map((statement) => statement.trim().replace(/;\s*$/u, "")).filter(Boolean).join(";\n\n").concat(statements.length > 0 ? ";\n" : "");
 }
-function findLocalMigrationBySequence(sequenceNumber, filenames) {
+function findLocalMigrationByVersion(version, filenames) {
   const matches = filenames.map((filename) => parseMigrationFilename(filename)).filter(
-    (migration) => migration !== null && migration.sequenceNumber === sequenceNumber
+    (migration) => migration !== null && migration.version === version
   );
   if (matches.length === 0) {
-    throw new CLIError(`Local migration for sequence ${sequenceNumber} not found.`);
+    throw new CLIError(`Local migration for version ${version} not found.`);
   }
   if (matches.length > 1) {
     throw new CLIError(
-      `Multiple local migration files found for sequence ${sequenceNumber}.`
+      `Multiple local migration files found for version ${version}.`
     );
   }
   return matches[0];
 }
 function resolveMigrationTarget(target, filenames) {
-  if (/^[1-9][0-9]*$/u.test(target)) {
-    return findLocalMigrationBySequence(Number(target), filenames);
+  if (/^\d{14}$/u.test(target)) {
+    return findLocalMigrationByVersion(target, filenames);
   }
   const parsedTarget = parseMigrationFilename(target);
   if (!parsedTarget) {
     throw new CLIError(
-      "Migration file names must match <sequence_number>_<migration-name>.sql."
+      "Migration file names must match <migration_version>_<migration-name>.sql."
     );
   }
   if (!filenames.includes(target)) {
     throw new CLIError(`Local migration file not found: ${target}`);
   }
-  return findLocalMigrationBySequence(parsedTarget.sequenceNumber, filenames);
+  return findLocalMigrationByVersion(parsedTarget.version, filenames);
 }
 
 // src/commands/db/migrations.ts
-function getLatestRemoteSequenceNumber(migrations) {
+function getLatestRemoteVersion(migrations) {
   return migrations.reduce(
-    (latestSequenceNumber, migration) => Math.max(latestSequenceNumber, migration.sequenceNumber),
-    0
+    (latestVersion, migration) => !latestVersion || compareMigrationVersions(migration.version, latestVersion) > 0 ? migration.version : latestVersion,
+    null
   );
 }
-function buildMigrationFilename(sequenceNumber, name) {
-  return `${sequenceNumber}_${name}.sql`;
+function buildMigrationFilename(version, name) {
+  return `${version}_${name}.sql`;
 }
 function formatCreatedAt(createdAt) {
   const date = new Date(createdAt);
@@ -2803,6 +2828,24 @@ function assertValidMigrationName(name) {
     throw new CLIError("Migration name must use lowercase letters, numbers, and hyphens only.");
   }
 }
+async function applyMigration(targetMigration, sql) {
+  const body = {
+    version: targetMigration.version,
+    name: targetMigration.name,
+    sql
+  };
+  const res = await ossFetch("/api/database/migrations", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const createdMigration = await res.json();
+  if (createdMigration.version !== targetMigration.version) {
+    throw new CLIError(
+      `Applied migration version mismatch. Expected ${targetMigration.version}, received ${createdMigration.version}.`
+    );
+  }
+  return createdMigration;
+}
 function registerDbMigrationsCommand(dbCmd2) {
   const migrationsCmd = dbCmd2.command("migrations").description("Manage database migration files");
   migrationsCmd.command("list").description("List applied remote database migrations").action(async (_opts, cmd) => {
@@ -2816,9 +2859,9 @@ function registerDbMigrationsCommand(dbCmd2) {
         console.log("No database migrations found.");
       } else {
         outputTable(
-          ["Sequence", "Name", "Created At"],
+          ["Version", "Name", "Created At"],
           migrations.map((migration) => [
-            String(migration.sequenceNumber),
+            migration.version,
             migration.name,
             formatCreatedAt(migration.createdAt)
           ])
@@ -2839,10 +2882,10 @@ function registerDbMigrationsCommand(dbCmd2) {
       const createdFiles = [];
       const skippedFiles = [];
       for (const migration of [...migrations].sort(
-        (left, right) => left.sequenceNumber - right.sequenceNumber
+        (left, right) => compareMigrationVersions(left.version, right.version)
       )) {
         const filename = buildMigrationFilename(
-          migration.sequenceNumber,
+          migration.version,
           migration.name
         );
         const filePath = join8(migrationsDir, filename);
@@ -2879,13 +2922,13 @@ function registerDbMigrationsCommand(dbCmd2) {
       await requireAuth();
       assertValidMigrationName(migrationName);
       const migrations = await fetchRemoteMigrations();
-      const latestRemoteSequenceNumber = getLatestRemoteSequenceNumber(migrations);
+      const latestRemoteVersion = getLatestRemoteVersion(migrations);
       const localMigrations = parseStrictLocalMigrations(listLocalMigrationFilenames());
-      const nextSequenceNumber = getNextLocalMigrationSequence(
+      const nextVersion = getNextLocalMigrationVersion(
         localMigrations,
-        latestRemoteSequenceNumber
+        latestRemoteVersion
       );
-      const filename = buildMigrationFilename(nextSequenceNumber, migrationName);
+      const filename = buildMigrationFilename(nextVersion, migrationName);
       const migrationsDir = ensureMigrationsDir();
       const filePath = join8(migrationsDir, filename);
       if (existsSync4(filePath)) {
@@ -2893,7 +2936,7 @@ function registerDbMigrationsCommand(dbCmd2) {
       }
       writeFileSync3(filePath, "");
       if (json) {
-        outputJson({ filename, path: filePath, sequenceNumber: nextSequenceNumber });
+        outputJson({ filename, path: filePath, version: nextVersion });
       } else {
         outputSuccess(`Created migration file ${filename}`);
       }
@@ -2903,50 +2946,96 @@ function registerDbMigrationsCommand(dbCmd2) {
       handleError(err, json);
     }
   });
-  migrationsCmd.command("up <target>").description("Apply exactly one local migration file").action(async (target, _opts, cmd) => {
+  migrationsCmd.command("up [target]").description("Apply one or more local migration files").option("--all", "Apply all pending local migration files").option("--to <version-or-filename>", "Apply pending local migrations up to a version or file").action(async (target, options, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       await requireAuth();
       const migrations = await fetchRemoteMigrations();
-      const latestRemoteSequenceNumber = getLatestRemoteSequenceNumber(migrations);
+      const latestRemoteVersion = getLatestRemoteVersion(migrations);
       const filenames = listLocalMigrationFilenames();
-      const targetMigration = resolveMigrationTarget(target, filenames);
-      if (targetMigration.sequenceNumber <= latestRemoteSequenceNumber) {
+      const requestedModes = [Boolean(target), Boolean(options.all), Boolean(options.to)].filter(Boolean);
+      if (requestedModes.length !== 1) {
         throw new CLIError(
-          `Migration ${targetMigration.filename} is already applied remotely.`
+          "Use exactly one apply mode: `up <target>`, `up --to <version-or-filename>`, or `up --all`."
         );
       }
-      if (targetMigration.sequenceNumber !== latestRemoteSequenceNumber + 1) {
-        throw new CLIError(
-          `Migration ${targetMigration.filename} is not the next remote sequence. Expected ${latestRemoteSequenceNumber + 1}.`
+      const applySingleTarget = async (targetMigrationFilenameOrVersion) => {
+        const targetMigration = resolveMigrationTarget(targetMigrationFilenameOrVersion, filenames);
+        const validLocalMigrations = filenames.map((filename) => parseMigrationFilename(filename)).filter((migration) => migration !== null).sort((left, right) => compareMigrationVersions(left.version, right.version));
+        if (latestRemoteVersion && compareMigrationVersions(targetMigration.version, latestRemoteVersion) <= 0) {
+          throw new CLIError(
+            `Migration ${targetMigration.filename} is already applied remotely.`
+          );
+        }
+        const earlierPendingMigration = validLocalMigrations.find(
+          (migration) => migration.version !== targetMigration.version && (!latestRemoteVersion || compareMigrationVersions(migration.version, latestRemoteVersion) > 0) && compareMigrationVersions(migration.version, targetMigration.version) < 0
         );
-      }
-      const filePath = join8(getMigrationsDir(), targetMigration.filename);
-      if (!existsSync4(filePath)) {
-        throw new CLIError(`Local migration file not found: ${targetMigration.filename}`);
-      }
-      const sql = readFileSync4(filePath, "utf-8");
-      if (!sql.trim()) {
-        throw new CLIError(`Migration file is empty: ${targetMigration.filename}`);
-      }
-      const body = {
-        name: targetMigration.name,
-        sql
+        if (earlierPendingMigration) {
+          throw new CLIError(
+            `Migration ${targetMigration.filename} is not the next pending local migration. Apply ${earlierPendingMigration.filename} first.`
+          );
+        }
+        const filePath = join8(getMigrationsDir(), targetMigration.filename);
+        if (!existsSync4(filePath)) {
+          throw new CLIError(`Local migration file not found: ${targetMigration.filename}`);
+        }
+        const sql = readFileSync4(filePath, "utf-8");
+        if (!sql.trim()) {
+          throw new CLIError(`Migration file is empty: ${targetMigration.filename}`);
+        }
+        return applyMigration(targetMigration, sql);
       };
-      const res = await ossFetch("/api/database/migrations", {
-        method: "POST",
-        body: JSON.stringify(body)
-      });
-      const createdMigration = await res.json();
-      if (createdMigration.sequenceNumber !== targetMigration.sequenceNumber) {
-        throw new CLIError(
-          `Applied migration sequence mismatch. Expected ${targetMigration.sequenceNumber}, received ${createdMigration.sequenceNumber}.`
+      let appliedMigrations = [];
+      if (target) {
+        appliedMigrations = [await applySingleTarget(target)];
+      } else {
+        const localMigrations = parseStrictLocalMigrations(filenames);
+        const pendingMigrations = localMigrations.filter(
+          (migration) => !latestRemoteVersion || compareMigrationVersions(migration.version, latestRemoteVersion) > 0
         );
+        if (pendingMigrations.length === 0) {
+          if (json) {
+            outputJson({ appliedMigrations: [] });
+          } else {
+            outputSuccess("No pending local migrations to apply.");
+          }
+          await reportCliUsage("cli.db.migrations.up", true);
+          return;
+        }
+        let migrationsToApply = pendingMigrations;
+        if (options.to) {
+          const targetVersion = /^\d{14}$/u.test(options.to) ? options.to : resolveMigrationTarget(options.to, filenames).version;
+          if (latestRemoteVersion && compareMigrationVersions(targetVersion, latestRemoteVersion) <= 0) {
+            throw new CLIError(`Migration ${options.to} is already applied remotely.`);
+          }
+          migrationsToApply = pendingMigrations.filter(
+            (migration) => compareMigrationVersions(migration.version, targetVersion) <= 0
+          );
+          if (migrationsToApply.length === 0 || migrationsToApply[migrationsToApply.length - 1]?.version !== targetVersion) {
+            throw new CLIError(
+              `Pending local migration not found for target ${options.to}.`
+            );
+          }
+        }
+        for (const migration of migrationsToApply) {
+          const filePath = join8(getMigrationsDir(), migration.filename);
+          if (!existsSync4(filePath)) {
+            throw new CLIError(`Local migration file not found: ${migration.filename}`);
+          }
+          const sql = readFileSync4(filePath, "utf-8");
+          if (!sql.trim()) {
+            throw new CLIError(`Migration file is empty: ${migration.filename}`);
+          }
+          appliedMigrations.push(await applyMigration(migration, sql));
+        }
       }
       if (json) {
-        outputJson(createdMigration);
+        outputJson({ appliedMigrations });
       } else {
-        outputSuccess(`Applied migration ${targetMigration.filename}`);
+        outputSuccess(`Applied ${appliedMigrations.length} migration file(s).`);
+        for (const migration of appliedMigrations) {
+          console.log(`- ${buildMigrationFilename(migration.version, migration.name)}`);
+        }
       }
       await reportCliUsage("cli.db.migrations.up", true);
     } catch (err) {
@@ -5366,7 +5455,7 @@ function registerDiagnoseCommands(diagnoseCmd2) {
         const s = !json ? clack10.spinner() : null;
         s?.start("Collecting diagnostic data...");
         const data2 = await collectDiagnosticData(projectId, ossMode, apiUrl);
-        const cliVersion = "0.1.53-dev.0";
+        const cliVersion = "0.1.53-dev.1";
         s?.stop("Data collected");
         if (!json) {
           console.log(`