@supacloud/cli 0.21.2 → 0.21.3

package/dist/index.js

@@ -7046,89 +7046,92 @@ function sortMigrationFiles(migrations) {
   }
   return sorted;
 }
-function appliedMigrationKeys(data) {
-  const rows = Array.isArray(data) ? data : data?.rows || [];
-  const keys = new Set;
-  for (const row of rows) {
-    if (!row || typeof row !== "object")
-      continue;
-    const migration = row;
-    if (migration.version != null)
-      keys.add(String(migration.version));
-    if (migration.name != null)
-      keys.add(String(migration.name));
-  }
-  return keys;
-}
 function migrationRows(data) {
-  const rows = Array.isArray(data) ? data : data?.rows || [];
-  return Array.isArray(rows) ? rows.filter((row) => Boolean(row && typeof row === "object")) : [];
+  if (Array.isArray(data))
+    return data;
+  if (data && typeof data === "object" && Array.isArray(data.rows)) {
+    return data.rows;
+  }
+  throw new Error("Invalid remote migration inventory");
 }
-function migrationIdentityKey(version, name) {
-  return `${version}\x00${name}`;
+function migrationIdentity(row) {
+  if (!row || typeof row !== "object" || Array.isArray(row)) {
+    throw new Error("Invalid remote migration identity");
+  }
+  const migration = row;
+  if (!isMigrationInventoryVersion(migration.version) || !isMigrationInventoryName(migration.name)) {
+    throw new Error("Invalid remote migration identity");
+  }
+  return { version: migration.version, name: migration.name, statements: migration.statements };
 }
 function migrationIdentities(data) {
-  return migrationRows(data).flatMap((row) => row.version == null || row.name == null ? [] : [{ version: String(row.version), name: String(row.name), statements: row.statements }]);
-}
-function isLegacyNameBoundMigration(local, remote, remoteMigrations) {
-  return remoteMigrations.filter((candidate) => candidate.name === local.name).length === 1 && local.name === remote.name && local.version !== remote.version && Array.isArray(remote.statements) && remote.statements.length === 1 && typeof remote.statements[0] === "string" && remote.statements[0].trim() === local.sql.trim();
-}
-function identityConflicts(local, remote, remoteMigrations) {
-  const reusesVersionOrName = local.version === remote.version || local.name === remote.name;
-  const exactlyMatches = local.version === remote.version && local.name === remote.name;
-  return reusesVersionOrName && !exactlyMatches && !isLegacyNameBoundMigration(local, remote, remoteMigrations);
-}
-function migrationIdentityConflicts(data, migrationFiles) {
-  const remoteMigrations = migrationIdentities(data);
-  return migrationFiles.flatMap((localMigration) => remoteMigrations.filter((remoteMigration) => identityConflicts(localMigration, remoteMigration, remoteMigrations)).map((remoteMigration) => ({ file: localMigration.file, local: localMigration, remote: remoteMigration })));
-}
-function legacyNameBoundMigrationKeys(data, migrationFiles) {
-  const remoteMigrations = migrationIdentities(data);
-  return new Set(migrationFiles.flatMap((localMigration) => remoteMigrations.some((remoteMigration) => isLegacyNameBoundMigration(localMigration, remoteMigration, remoteMigrations)) ? [migrationIdentityKey(localMigration.version, localMigration.name)] : []));
-}
-function assertNoMigrationIdentityConflicts(data, migrationFiles) {
-  const conflicts = migrationIdentityConflicts(data, migrationFiles);
-  if (!conflicts.length)
-    return;
-  throw new Error([
-    "Migration identity conflicts:",
-    ...conflicts.map(({ file, local, remote }) => `- ${file} (${local.version}) conflicts with remote ${remote.name} (${remote.version})`)
-  ].join(`
-`));
+  const identities = migrationRows(data).map(migrationIdentity);
+  const versions = new Set;
+  const names = new Set;
+  for (const identity of identities) {
+    if (versions.has(identity.version) || identity.name !== null && names.has(identity.name)) {
+      throw new Error("Invalid remote migration inventory");
+    }
+    versions.add(identity.version);
+    if (identity.name !== null)
+      names.add(identity.name);
+  }
+  return identities;
 }
-function nameBoundMigrationMarkerKeys(data) {
+function appliedMigrationKeys(data) {
   const keys = new Set;
-  for (const row of migrationRows(data)) {
-    if (row.version == null || row.name == null || !Array.isArray(row.statements))
-      continue;
-    if (row.statements.length !== 1)
-      continue;
-    const name = String(row.name);
-    const marker = row.statements[0];
-    if (marker !== `baseline:${name}` && marker !== `direct-apply:${name}`)
-      continue;
-    keys.add(migrationIdentityKey(String(row.version), String(row.name)));
+  for (const migration of migrationIdentities(data)) {
+    keys.add(migration.version);
+    if (migration.name !== null)
+      keys.add(migration.name);
   }
   return keys;
 }
-function historicalChecksumMarkerKeys(data, migrationFiles) {
-  const filesByKey = new Map(migrationFiles.map((migration) => [migrationIdentityKey(migration.version, migration.name), migration]));
-  const keys = new Set;
-  for (const row of migrationRows(data)) {
-    if (row.version == null || row.name == null || !Array.isArray(row.statements) || row.statements.length !== 1)
-      continue;
-    const marker = row.statements[0];
-    if (typeof marker !== "string" || !/^sha256:[0-9a-f]{64}$/.test(marker))
-      continue;
-    const key = migrationIdentityKey(String(row.version), String(row.name));
-    const migration = filesByKey.get(key);
-    if (!migration)
-      continue;
-    const checksum = createHash("sha256").update(migration.rawBytes).digest("hex");
-    if (marker === `sha256:${checksum}`)
-      keys.add(key);
+function singleRemoteStatement(remote) {
+  return Array.isArray(remote.statements) && remote.statements.length === 1 && typeof remote.statements[0] === "string" ? remote.statements[0] : null;
+}
+function exactIdentityIsApplied(local, remote) {
+  const statement = singleRemoteStatement(remote);
+  if (statement === null)
+    return false;
+  if (statement === `baseline:${local.name}` || statement === `direct-apply:${local.name}`)
+    return true;
+  const rawChecksum = createHash("sha256").update(local.rawBytes).digest("hex");
+  return statement === `sha256:${rawChecksum}` || statement.trim() === local.sql.trim();
+}
+function legacyIdentityIsApplied(local, remote) {
+  const statement = singleRemoteStatement(remote);
+  return remote.name === local.name && remote.version !== local.version && statement !== null && statement.trim() === local.sql.trim();
+}
+function migrationIdentityConflict(local) {
+  return new Error(`Migration identity conflicts:
+- ${local.file} (${local.version}) conflicts with remote inventory`);
+}
+function migrationDisposition(local, remoteMigrations) {
+  const sameVersion = remoteMigrations.filter((remote2) => remote2.version === local.version);
+  const sameName = remoteMigrations.filter((remote2) => remote2.name === local.name);
+  if (sameVersion.length > 1 || sameName.length > 1)
+    throw migrationIdentityConflict(local);
+  if (!sameVersion.length && !sameName.length)
+    return "pending";
+  if (sameVersion[0] && sameName[0] && sameVersion[0] !== sameName[0])
+    throw migrationIdentityConflict(local);
+  const remote = sameVersion[0] ?? sameName[0];
+  const exactIdentity = remote.version === local.version && remote.name === local.name;
+  if (exactIdentity && exactIdentityIsApplied(local, remote))
+    return "applied";
+  if (!sameVersion.length && legacyIdentityIsApplied(local, remote))
+    return "applied";
+  throw migrationIdentityConflict(local);
+}
+function migrationPushPlan(data, migrationFiles) {
+  const remoteMigrations = migrationIdentities(data);
+  const plan = { alreadyApplied: [], pending: [] };
+  for (const migration of migrationFiles) {
+    const disposition = migrationDisposition(migration, remoteMigrations);
+    plan[disposition === "applied" ? "alreadyApplied" : "pending"].push(migration);
   }
-  return keys;
+  return plan;
 }
 function isAlreadyAppliedMigrationResponse(response) {
   if (response.status !== 409 || !response.data || typeof response.data !== "object")
@@ -7356,14 +7359,13 @@ Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
         const migrationFiles = sortMigrationFiles(files.map((file) => readMigrationFile(dir, file)));
         const migrationsResult = await http.get(`/v1/projects/${ref}/database/migrations`);
         if (!migrationsResult.ok) {
-          text = `❌ Failed to load applied migrations (${migrationsResult.status}): ${JSON.stringify(migrationsResult.data)}`;
+          text = `❌ Failed to load applied migrations (${migrationsResult.status})`;
           break;
         }
-        assertNoMigrationIdentityConflicts(migrationsResult.data, migrationFiles);
+        const migrationPlan = migrationPushPlan(migrationsResult.data, migrationFiles);
         if (args.dry_run) {
-          const appliedKeys = appliedMigrationKeys(migrationsResult.data);
-          const pending = migrationFiles.filter(({ name, version }) => !appliedKeys.has(name) && !appliedKeys.has(String(version)));
-          const alreadyApplied = migrationFiles.filter(({ name, version }) => appliedKeys.has(name) || appliedKeys.has(String(version)));
+          const pending = migrationPlan.pending;
+          const alreadyApplied = migrationPlan.alreadyApplied;
           const pendingWithSql = pending;
           let vectorEnabled = null;
           if (pendingWithSql.some(({ sql }) => sqlReferencesVector(sql) || sqlCreatesVectorExtension(sql))) {
@@ -7386,16 +7388,8 @@ Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
           break;
         }
         const applied = [];
-        const skipped = [];
-        const nameBoundMarkerKeys = nameBoundMigrationMarkerKeys(migrationsResult.data);
-        const historicalChecksumKeys = historicalChecksumMarkerKeys(migrationsResult.data, migrationFiles);
-        const legacyNameBoundKeys = legacyNameBoundMigrationKeys(migrationsResult.data, migrationFiles);
-        for (const { file, name, version, sql } of migrationFiles) {
-          const migrationKey = migrationIdentityKey(version, name);
-          if (nameBoundMarkerKeys.has(migrationKey) || historicalChecksumKeys.has(migrationKey) || legacyNameBoundKeys.has(migrationKey)) {
-            skipped.push(file);
-            continue;
-          }
+        const skipped = migrationPlan.alreadyApplied.map(({ file }) => file);
+        for (const { file, name, version, sql } of migrationPlan.pending) {
           const r = await http.post(`/v1/projects/${ref}/database/migrations`, { name, sql, version });
           if (r.ok) {
             applied.push(file);
@@ -7404,8 +7398,6 @@ Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
           } else {
             text = [
               `❌ Failed to apply ${file} (${r.status})`,
-              JSON.stringify(r.data, null, 2),
-              "",
               `Applied before failure: ${applied.length}`,
               `Skipped before failure: ${skipped.length}`
             ].join(`
@@ -12047,7 +12039,7 @@ var MUTATION_TOOL_SCHEMA = {
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.21.2",
+  version: "0.21.3",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/cli",
-  "version": "0.21.2",
+  "version": "0.21.3",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",