@vibeorm/migrate 2.3.0 → 2.5.0

package/dist/fs.js

@@ -116,10 +116,10 @@ function parseMigrationMetadata(params) {
 }
 
 // packages/migrate/src/object-ownership.ts
-import { VibeError as VibeError6, sqlObjectKey as sqlObjectKey2, enumStorageOf as enumStorageOf2 } from "@vibeorm/schema";
+import { VibeError as VibeError6, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, sqlObjectKey as sqlObjectKey2 } from "@vibeorm/schema";
 
 // packages/migrate/src/normalize.ts
-import { VibeError as VibeError5, enumStorageOf, isEnumType as isEnumType5, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { VibeError as VibeError5, defaultForeignKeyName, defaultIndexName, enumStorageOf, isEnumType as isEnumType5, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
 
 // packages/migrate/src/relations.ts
 import { implicitJoinTable, isImplicitManyToManyRelation } from "@vibeorm/schema";
@@ -169,6 +169,49 @@ var SCALAR_TO_PG = {
 var CANONICAL_EQUIVALENTS = {
   DateTime: ["timestamptz(3)", "timestamptz(6)"]
 };
+var CANONICAL_UDT = {
+  text: "String",
+  bool: "Boolean",
+  int4: "Int",
+  int8: "BigInt",
+  float8: "Float",
+  numeric: "Decimal",
+  timestamptz: "DateTime",
+  jsonb: "Json",
+  bytea: "Bytes"
+};
+var NON_CANONICAL_UDT = {
+  varchar: "String",
+  bpchar: "String",
+  uuid: "String",
+  bit: "String",
+  varbit: "String",
+  xml: "String",
+  inet: "String",
+  citext: "String",
+  int2: "Int",
+  oid: "Int",
+  float4: "Float",
+  money: "Decimal",
+  timestamp: "DateTime",
+  date: "DateTime",
+  time: "DateTime",
+  timetz: "DateTime",
+  json: "Json"
+};
+var SPELLING_TO_UDT = {
+  integer: "int4",
+  bigint: "int8",
+  smallint: "int2",
+  boolean: "bool",
+  doubleprecision: "float8",
+  real: "float4",
+  char: "bpchar"
+};
+function scalarForBuiltinType(params) {
+  const udt = SPELLING_TO_UDT[params.name] ?? params.name;
+  return CANONICAL_UDT[udt] ?? NON_CANONICAL_UDT[udt];
+}
 var NATIVE_ALIASES = {
   charactervarying: "varchar",
   character: "char",
@@ -188,7 +231,11 @@ var NATIVE_ALIASES = {
   timestampwithtimezone: "timestamptz",
   timestampwithouttimezone: "timestamp",
   timewithtimezone: "timetz",
-  timewithouttimezone: "time"
+  timewithouttimezone: "time",
+  bitvarying: "varbit"
+};
+var IMPLICIT_MODIFIERS = {
+  bit: "(1)"
 };
 function normalizeNativeType(params) {
   const compact = params.raw.toLowerCase().replace(/\s+/g, "");
@@ -196,7 +243,7 @@ function normalizeNativeType(params) {
   if (match === null)
     return compact;
   const base = NATIVE_ALIASES[match[1]] ?? match[1];
-  return `${base}${match[2] ?? ""}${match[3] ?? ""}`;
+  return `${base}${match[2] ?? IMPLICIT_MODIFIERS[base] ?? ""}${match[3] ?? ""}`;
 }
 function parseUnsupportedPostgresType(params) {
   const temporal = /^\s*(time(?:stamp)?)\s*(\(\s*\d+\s*\))?\s+(with|without)\s+time\s+zone\s*((?:\[\s*\]\s*)*)$/i.exec(params.raw);
@@ -217,6 +264,11 @@ function columnTypeKey(params) {
       return `u:${field.nativeType ?? ""}`;
     const evidence = field.nativeTypeIdentity;
     const namespace = evidence !== undefined && evidence.source === field.nativeType ? evidence.namespace : parsed.namespace;
+    const scalar = namespace === undefined || namespace === "pg_catalog" ? scalarForBuiltinType({ name: parsed.name }) : undefined;
+    if (scalar !== undefined) {
+      const { isUnsupported: _unsupported, nativeTypeIdentity: _identity, ...rest } = field;
+      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList } });
+    }
     return `u:${JSON.stringify([namespace ?? null, parsed.name, parsed.modifier, parsed.array || field.isList])}`;
   }
   if (isEnumType(field.type)) {
@@ -305,8 +357,12 @@ function defaultFingerprint(params) {
     }
     case "enumValue":
       return `enum:${def.value}`;
-    case "dbgenerated":
-      return `db:${def.sql.trim()}`;
+    case "dbgenerated": {
+      const sql = def.sql.trim();
+      if (/^now\(\)$/i.test(sql) || /^current_timestamp(\(\d\))?$/i.test(sql))
+        return "now";
+      return `db:${sql}`;
+    }
   }
 }
 function defaultSql(params) {
@@ -797,8 +853,8 @@ function normalizeModel(params) {
     });
   }
   const pk = normalizePk({ model });
-  const indexes = normalizeIndexes({ model, table });
-  const fks = normalizeFks({ model, table, schema });
+  const indexes = normalizeIndexes({ model, table, dialect });
+  const fks = normalizeFks({ model, table, schema, dialect });
   const checks = new Map;
   for (const check of model.checks ?? [])
     checks.set(check.name, check.expression);
@@ -812,7 +868,7 @@ function normalizePk(params) {
   return model.fields.filter((field) => field.isId).map((field) => field.dbName ?? field.name);
 }
 function normalizeIndexes(params) {
-  const { model, table } = params;
+  const { model, table, dialect } = params;
   const result = new Map;
   const add = (index) => {
     const unique = index.kind === "unique";
@@ -831,7 +887,7 @@ function normalizeIndexes(params) {
     const key = indexComparisonKey({ unique, kind, columns, where, nullsNotDistinct });
     if (result.has(key))
       return;
-    const name = index.name ?? `${table}_${columns.map((column) => column.name).join("_")}_${unique ? "key" : "idx"}`;
+    const name = index.name ?? defaultIndexName({ table, columns: columns.map((column) => column.name), unique, dialect });
     result.set(key, {
       key,
       name,
@@ -1037,7 +1093,7 @@ function normalizeFks(params) {
       continue;
     result.set(key, {
       key,
-      constraintName: relation.constraintName ?? `${table}_${columns.join("_")}_fkey`,
+      constraintName: relation.constraintName ?? defaultForeignKeyName({ table, columns, dialect: params.dialect }),
       columns,
       refTable,
       refColumns,
@@ -1180,7 +1236,7 @@ function removalIdentity(params) {
     case "dropForeignKey":
       return { kind: "constraint", constraintType: "foreignKey", table, name: step.constraintName };
     case "dropPrimaryKey":
-      return { kind: "constraint", constraintType: "primaryKey", table, name: step.constraintName ?? `${step.table}_pkey` };
+      return { kind: "constraint", constraintType: "primaryKey", table, name: step.constraintName ?? defaultPrimaryKeyName({ table: step.table, dialect: "postgres" }) };
     default:
       return;
   }
@@ -1199,7 +1255,7 @@ function schemaObjectIdentities(params) {
       if (definition.defaultKey !== null)
         result.push({ kind: "columnDefault", table, column });
       if (params.dialect === "postgres" && definition.field.default?.kind === "autoincrement")
-        result.push({ kind: "sequence", name: { namespace: params.namespace, name: `${name}_${column}_seq` } });
+        result.push({ kind: "sequence", name: { namespace: params.namespace, name: postgresGeneratedObjectName({ name1: name, name2: column, label: "seq" }) } });
     }
     for (const exclusion of model.model.exclusions ?? [])
       result.push({ kind: "constraint", constraintType: "exclusion", table, name: exclusion.name });
@@ -1213,15 +1269,15 @@ function schemaObjectIdentities(params) {
     for (const fk of model.fks.values())
       result.push({ kind: "constraint", constraintType: "foreignKey", table, name: fk.constraintName });
     if (model.pk.length > 0)
-      result.push({ kind: "constraint", constraintType: "primaryKey", table, name: model.model.primaryKeyConstraintName ?? (params.dialect === "mysql" ? "PRIMARY" : `${name}_pkey`) });
+      result.push({ kind: "constraint", constraintType: "primaryKey", table, name: model.model.primaryKeyConstraintName ?? (params.dialect === "mysql" ? "PRIMARY" : defaultPrimaryKeyName({ table: name, dialect: params.dialect })) });
   }
   for (const name of normalized.joinTables.keys()) {
     const table = { namespace: params.namespace, name };
     result.push({ kind: "table", name: table });
-    for (const column of ["A", "B"])
-      result.push({ kind: "column", table, column }, { kind: "constraint", constraintType: "foreignKey", table, name: `${name}_${column}_fkey` });
-    for (const suffix of ["AB_unique", "B_index"])
-      result.push({ kind: "index", table, name: `${name}_${suffix}` });
+    const derived = implicitJoinTableObjectNames({ table: name });
+    result.push({ kind: "column", table, column: "A" }, { kind: "constraint", constraintType: "foreignKey", table, name: derived.foreignKeyA });
+    result.push({ kind: "column", table, column: "B" }, { kind: "constraint", constraintType: "foreignKey", table, name: derived.foreignKeyB });
+    result.push({ kind: "index", table, name: derived.uniqueIndex }, { kind: "index", table, name: derived.indexB });
   }
   for (const name of normalized.views.keys())
     result.push({ kind: "view", name: { namespace: params.namespace, name } });
@@ -1296,7 +1352,7 @@ function assertRemovalAuthorization(params) {
 }
 
 // packages/migrate/src/inventory.ts
-import { VibeError as VibeError16, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
+import { VibeError as VibeError16, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect2, renderMigrationInventory, renderSqliteColumnInventory as renderSqliteColumnInventory2, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/exclusions.ts
@@ -2042,18 +2098,17 @@ async function introspectPostgres(params) {
   if (params.inTransaction !== true)
     await executor({ text: "BEGIN" });
   try {
-    const savedPath = params.inTransaction === true ? await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "readSearchPath" })) : undefined;
-    const searchPath = savedPath?.[0]?.searchPath;
-    if (params.inTransaction === true && typeof searchPath !== "string")
+    const savedPath = await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "readSearchPath" }));
+    const searchPath = savedPath[0]?.searchPath;
+    if (typeof searchPath !== "string")
       throw new VibeError12({ code: "VIBE_MIGRATION", message: "Cannot read the migration search_path" });
     const matched = await verifyPostgresRls({ executor, ...params.rlsSchema === undefined ? {} : { schema: params.rlsSchema }, ...params.requireInstalledRls === undefined ? {} : { requireInstalled: params.requireInstalledRls } }).then((verified) => verified, (error) => {
       if (error instanceof VibeError12)
         throw error;
       throw new VibeError12({ code: "VIBE_MIGRATION", message: "Native RLS verification could not complete. Check migration privileges and supply the deployed schema as previousSchema/rlsSchema before changing referenced columns.", meta: { reason: "rls-verification-unavailable" }, cause: error });
     });
+    await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "setSearchPath", searchPath }));
     const physical = await introspectPhysicalPostgres({ executor });
-    if (typeof searchPath === "string")
-      await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "setSearchPath", searchPath }));
     return projectPostgresRls({ physical, ...params.rlsSchema === undefined ? {} : { declared: params.rlsSchema }, matched });
   } finally {
     if (params.inTransaction !== true)
@@ -2330,27 +2385,6 @@ function buildField(params) {
     ...mapped.isUnsupported === true ? { isUnsupported: true } : {}
   };
 }
-var CANONICAL_UDT = {
-  text: "String",
-  bool: "Boolean",
-  int4: "Int",
-  int8: "BigInt",
-  float8: "Float",
-  numeric: "Decimal",
-  timestamptz: "DateTime",
-  jsonb: "Json",
-  bytea: "Bytes"
-};
-var NON_CANONICAL_UDT = {
-  varchar: "String",
-  bpchar: "String",
-  uuid: "String",
-  int2: "Int",
-  float4: "Float",
-  timestamp: "DateTime",
-  date: "DateTime",
-  json: "Json"
-};
 function reverseMapType(params) {
   const { column, enumNames } = params;
   const isList = column.dataType === "ARRAY";
@@ -2406,8 +2440,10 @@ function withModifier(params) {
   }
   if (udt === "bpchar")
     return "char";
-  if (udt === "timestamp" && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
-    return `timestamp(${column.datetimePrecision})`;
+  if ((udt === "bit" || udt === "varbit") && column.charMaxLength !== null)
+    return `${udt}(${column.charMaxLength})`;
+  if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
+    return `${udt}(${column.datetimePrecision})`;
   }
   return udt;
 }
@@ -4157,7 +4193,7 @@ async function inspectMigrationInventory(params) {
       for (const constraint of clauses) {
         if (constraint.type === "check")
           continue;
-        const name = constraint.named ? constraint.name : constraint.type === "primaryKey" ? `${qualified.name}_pkey` : constraint.type === "foreignKey" ? `${qualified.name}_${constraint.columns.join("_")}_fkey` : constraint.name;
+        const name = constraint.named ? constraint.name : constraint.type === "primaryKey" ? defaultPrimaryKeyName2({ table: qualified.name, dialect: "sqlite" }) : constraint.type === "foreignKey" ? defaultForeignKeyName2({ table: qualified.name, columns: constraint.columns, dialect: "sqlite" }) : constraint.name;
         objects.push({ identity: { kind: "constraint", constraintType: constraint.type, table: qualified, name }, ...constraint.type === "unique" && !constraint.named ? { inspectionUnavailable: "sqlite-anonymous-unique-constraint" } : {} });
       }
       const checks = parseSqliteNamedChecks({ tableSql: row.definition });
@@ -4168,7 +4204,7 @@ async function inspectMigrationInventory(params) {
       const query = renderSqliteColumnInventory2({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
       const columns = await params.executor({ text: query.text, values: [...query.values] });
       if (columns.some((column) => Number(column.pk) > 0) && !clauses.some((clause) => clause.type === "primaryKey"))
-        objects.push({ identity: { kind: "constraint", constraintType: "primaryKey", table: qualified, name: `${qualified.name}_pkey` } });
+        objects.push({ identity: { kind: "constraint", constraintType: "primaryKey", table: qualified, name: defaultPrimaryKeyName2({ table: qualified.name, dialect: "sqlite" }) } });
       const fkQuery = renderSqliteForeignKeyInventory({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
       const foreignKeys = await params.executor({ text: fkQuery.text, values: [...fkQuery.values] });
       const groups = new Map;
@@ -4177,7 +4213,7 @@ async function inspectMigrationInventory(params) {
       for (const fields of groups.values()) {
         if (clauses.some((clause) => clause.type === "foreignKey" && JSON.stringify(clause.columns) === JSON.stringify(fields)))
           continue;
-        objects.push({ identity: { kind: "constraint", constraintType: "foreignKey", table: qualified, name: `${qualified.name}_${fields.join("_")}_fkey` }, inspectionUnavailable: "sqlite-inline-foreign-key-definition-unavailable" });
+        objects.push({ identity: { kind: "constraint", constraintType: "foreignKey", table: qualified, name: defaultForeignKeyName2({ table: qualified.name, columns: fields, dialect: "sqlite" }) }, inspectionUnavailable: "sqlite-inline-foreign-key-definition-unavailable" });
       }
       for (const column of columns) {
         objects.push({ identity: { kind: "column", table: qualified, column: String(column.name) } });
@@ -5638,7 +5674,7 @@ import { VibeError as VibeError31, sqlObjectKey as sqlObjectKey9 } from "@vibeor
 
 // packages/migrate/src/ddl/postgres.ts
 import { renderExclusionSetup } from "@vibeorm/sql";
-import { VibeError as VibeError28, isEnumType as isEnumType7 } from "@vibeorm/schema";
+import { VibeError as VibeError28, defaultPrimaryKeyName as defaultPrimaryKeyName3, implicitJoinTableObjectNames as implicitJoinTableObjectNames2, isEnumType as isEnumType7 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect8, renderRlsPolicyPath } from "@vibeorm/sql";
 function renderPostgresSteps(params) {
   refuseSameTransactionEnumUse({ steps: params.steps });
@@ -5710,7 +5746,7 @@ function renderStep(params) {
       const lines = step.columns.map((column) => `  ${columnDefSql({ field: column })}`);
       if (step.primaryKey.length > 0) {
         const pkCols = step.primaryKey.map((column) => q2(column)).join(", ");
-        lines.push(`  CONSTRAINT ${q2(step.primaryKeyConstraintName ?? `${step.table}_pkey`)} PRIMARY KEY (${pkCols})`);
+        lines.push(`  CONSTRAINT ${q2(step.primaryKeyConstraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))} PRIMARY KEY (${pkCols})`);
       }
       for (const check of step.checks ?? []) {
         lines.push(`  CONSTRAINT ${q2(check.name)} CHECK (${check.expression})`);
@@ -5783,25 +5819,26 @@ ${lines.join(`,
     case "createJoinTable": {
       const aType = columnTypeSql({ field: { ...step.a.field, isList: false } });
       const bType = columnTypeSql({ field: { ...step.b.field, isList: false } });
+      const names = implicitJoinTableObjectNames2({ table: step.table });
       return [
         `CREATE TABLE ${publicName(step.table)} (
   "A" ${aType} NOT NULL,
   "B" ${bType} NOT NULL
 );`,
-        `CREATE UNIQUE INDEX ${q2(`${step.table}_AB_unique`)} ON ${publicName(step.table)} ("A", "B");`,
-        `CREATE INDEX ${q2(`${step.table}_B_index`)} ON ${publicName(step.table)} ("B");`,
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(`${step.table}_A_fkey`)} FOREIGN KEY ("A") REFERENCES ${publicName(step.a.table)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(`${step.table}_B_fkey`)} FOREIGN KEY ("B") REFERENCES ${publicName(step.b.table)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+        `CREATE UNIQUE INDEX ${q2(names.uniqueIndex)} ON ${publicName(step.table)} ("A", "B");`,
+        `CREATE INDEX ${q2(names.indexB)} ON ${publicName(step.table)} ("B");`,
+        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(names.foreignKeyA)} FOREIGN KEY ("A") REFERENCES ${publicName(step.a.table)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(names.foreignKeyB)} FOREIGN KEY ("B") REFERENCES ${publicName(step.b.table)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
       ];
     }
     case "addPrimaryKey": {
       const cols = step.columns.map((column) => q2(column)).join(", ");
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName ?? `${step.table}_pkey`)} PRIMARY KEY (${cols});`
+        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))} PRIMARY KEY (${cols});`
       ];
     }
     case "dropPrimaryKey":
-      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName ?? `${step.table}_pkey`)};`];
+      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))};`];
   }
 }
 function columnDefSql(params) {
@@ -5863,7 +5900,7 @@ function q2(name) {
 }
 
 // packages/migrate/src/ddl/sqlite.ts
-import { VibeError as VibeError29, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError29, implicitJoinTableObjectNames as implicitJoinTableObjectNames3, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { sqliteDialect as sqliteDialect3 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/drop-order.ts
@@ -6061,12 +6098,13 @@ function renderSqliteSteps(params) {
       case "createJoinTable": {
         const aType = sqliteStorageType({ field: { ...step.a.field, isList: false } });
         const bType = sqliteStorageType({ field: { ...step.b.field, isList: false } });
+        const names = implicitJoinTableObjectNames3({ table: step.table });
         statements.push(`CREATE TABLE ${q3(step.table)} (
   "A" ${aType} NOT NULL,
   "B" ${bType} NOT NULL,
-  CONSTRAINT ${q3(`${step.table}_A_fkey`)} FOREIGN KEY ("A") REFERENCES ${q3(step.a.table)} (${q3(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE,
-  CONSTRAINT ${q3(`${step.table}_B_fkey`)} FOREIGN KEY ("B") REFERENCES ${q3(step.b.table)} (${q3(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE
-);`, `CREATE UNIQUE INDEX ${q3(`${step.table}_AB_unique`)} ON ${q3(step.table)} ("A", "B");`, `CREATE INDEX ${q3(`${step.table}_B_index`)} ON ${q3(step.table)} ("B");`);
+  CONSTRAINT ${q3(names.foreignKeyA)} FOREIGN KEY ("A") REFERENCES ${q3(step.a.table)} (${q3(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT ${q3(names.foreignKeyB)} FOREIGN KEY ("B") REFERENCES ${q3(step.b.table)} (${q3(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE
+);`, `CREATE UNIQUE INDEX ${q3(names.uniqueIndex)} ON ${q3(step.table)} ("A", "B");`, `CREATE INDEX ${q3(names.indexB)} ON ${q3(step.table)} ("B");`);
         break;
       }
       case "addColumn":
@@ -6432,7 +6470,7 @@ function q3(name) {
 }
 
 // packages/migrate/src/ddl/mysql.ts
-import { VibeError as VibeError30, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError30, implicitJoinTableObjectNames as implicitJoinTableObjectNames4, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect3 } from "@vibeorm/sql";
 function renderMysqlSteps(params) {
   for (const step of params.steps) {
@@ -6611,15 +6649,16 @@ ${lines.join(`,
     case "createJoinTable": {
       const aType = mysqlColumnTypeSql({ field: { ...step.a.field, isList: false }, enums });
       const bType = mysqlColumnTypeSql({ field: { ...step.b.field, isList: false }, enums });
+      const names = implicitJoinTableObjectNames4({ table: step.table });
       return [
         `CREATE TABLE ${q4(step.table)} (
   \`A\` ${aType} NOT NULL,
   \`B\` ${bType} NOT NULL
 );`,
-        `CREATE UNIQUE INDEX ${q4(`${step.table}_AB_unique`)} ON ${q4(step.table)} (\`A\`, \`B\`);`,
-        `CREATE INDEX ${q4(`${step.table}_B_index`)} ON ${q4(step.table)} (\`B\`);`,
-        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(`${step.table}_A_fkey`)} FOREIGN KEY (\`A\`) REFERENCES ${q4(step.a.table)} (${q4(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
-        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(`${step.table}_B_fkey`)} FOREIGN KEY (\`B\`) REFERENCES ${q4(step.b.table)} (${q4(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+        `CREATE UNIQUE INDEX ${q4(names.uniqueIndex)} ON ${q4(step.table)} (\`A\`, \`B\`);`,
+        `CREATE INDEX ${q4(names.indexB)} ON ${q4(step.table)} (\`B\`);`,
+        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(names.foreignKeyA)} FOREIGN KEY (\`A\`) REFERENCES ${q4(step.a.table)} (${q4(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${q4(step.table)} ADD CONSTRAINT ${q4(names.foreignKeyB)} FOREIGN KEY (\`B\`) REFERENCES ${q4(step.b.table)} (${q4(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
       ];
     }
     case "addPrimaryKey":
@@ -6756,6 +6795,7 @@ function collectExtensionArtifacts(params) {
   const { schema, dialect, extensions } = params;
   const setup = [];
   const objects = [];
+  const groups = [];
   for (const extension of extensions) {
     const artifactsHook = extension.migrate?.artifacts;
     if (artifactsHook === undefined)
@@ -6763,6 +6803,7 @@ function collectExtensionArtifacts(params) {
     const declarations = extensionDeclarations({ schema, name: extension.name });
     if (Object.keys(declarations).length === 0 && extension.schema?.configOnly !== true)
       continue;
+    const contributed = [];
     for (const artifact of artifactsHook({
       schema,
       dialect,
@@ -6770,10 +6811,19 @@ function collectExtensionArtifacts(params) {
       options: extension.options,
       declarations
     })) {
-      (artifact.owns.kind === "postgresExtension" ? setup : objects).push(artifact);
+      if (artifact.owns.kind === "postgresExtension")
+        setup.push(artifact);
+      else {
+        objects.push(artifact);
+        contributed.push(artifact);
+      }
     }
+    groups.push({ extension: extension.name, objects: contributed });
   }
-  return { setup, objects };
+  return { setup, objects, groups };
+}
+function lastDeclaredSchema(params) {
+  return [...params.migrations].reverse().find((migration) => migration.desiredState !== undefined)?.desiredState?.to.schema;
 }
 function ownedTableNames(params) {
   const exact = new Set;
@@ -6875,6 +6925,36 @@ async function probeInstalledExtensionState(params) {
 function artifactCreateSql(params) {
   return params.artifacts.flatMap((artifact) => [...artifact.create]);
 }
+function planChangedArtifacts(params) {
+  const previousById = new Map((params.previous?.objects ?? []).map((artifact) => [artifact.id, artifact]));
+  const probedIds = new Set((params.probed ?? []).map((artifact) => artifact.id));
+  const missingIds = new Set(params.missing.map((artifact) => artifact.id));
+  const rebuilt = new Set;
+  for (const group of params.current.groups) {
+    const changed = group.objects.filter((artifact) => {
+      if (missingIds.has(artifact.id))
+        return false;
+      if (probedIds.has(artifact.id))
+        return true;
+      const before = previousById.get(artifact.id);
+      return before !== undefined && JSON.stringify(before.owns) === JSON.stringify(artifact.owns) && JSON.stringify(before.create) !== JSON.stringify(artifact.create);
+    });
+    if (changed.length === 0)
+      continue;
+    const rebuiltColumnTables = new Set(changed.flatMap((artifact) => artifact.owns.kind === "column" ? [artifact.owns.table] : []));
+    for (const artifact of group.objects) {
+      if (missingIds.has(artifact.id))
+        continue;
+      const dependent = (artifact.owns.kind === "index" || artifact.owns.kind === "trigger") && rebuiltColumnTables.has(artifact.owns.table);
+      if (changed.includes(artifact) || dependent)
+        rebuilt.add(artifact.id);
+    }
+  }
+  return params.current.objects.filter((artifact) => rebuilt.has(artifact.id));
+}
+function artifactDropSql(params) {
+  return [...params.artifacts].reverse().flatMap((artifact) => [...artifact.drop]);
+}
 // packages/migrate/src/runner.ts
 function migrationRlsSecurityChanges(params) {
   const source = params.migration.rls;
@@ -7025,6 +7105,7 @@ function generateMigration(params) {
     extensions: params.extensions ?? []
   });
   const allArtifacts = [...artifacts.setup, ...artifacts.objects];
+  const rebuilt = planChangedArtifacts({ previous: collectExtensionArtifacts({ schema: from, dialect, extensions: params.extensions ?? [] }), current: artifacts, missing: [] });
   assertRetainedMigrationObjects({ from: from.migrationObjects ?? [], to: to.migrationObjects ?? [] });
   const strippedFrom = preserveMigrationObjects({ from: stripExtensionArtifacts({ schema: from, artifacts: allArtifacts }), to, objects: [...from.migrationObjects ?? [], ...to.migrationObjects ?? []] });
   const steps = diffSchemas({ from: strippedFrom, to, dialect, ...params.renames === undefined ? {} : { renames: params.renames } });
@@ -7035,6 +7116,7 @@ function generateMigration(params) {
       artifacts: missing.filter((artifact) => artifact.owns.kind === "postgresExtension")
     }),
     ...coreSql,
+    ...artifactDropSql({ artifacts: rebuilt }),
     ...artifactCreateSql({
       artifacts: missing.filter((artifact) => artifact.owns.kind !== "postgresExtension")
     }),
@@ -8020,4 +8102,4 @@ export {
   splitSqlStatements
 };
 
-//# debugId=F0D645556CA0676064756E2164756E21
+//# debugId=B0F3289A0E0F6E5B64756E2164756E21