@strapi/database 5.7.0-beta.0 → 5.8.0

package/dist/index.mjs

@@ -1039,6 +1039,13 @@ const createSchemaBuilder = (db) => {
     async updateSchema(schemaDiff) {
       const forceMigration = db.config.settings?.forceMigration;
       await db.dialect.startSchemaUpdate();
+      const existingMetadata = {};
+      for (const table of schemaDiff.tables.updated) {
+        existingMetadata[table.name] = {
+          indexes: await db.dialect.schemaInspector.getIndexes(table.name),
+          foreignKeys: await db.dialect.schemaInspector.getForeignKeys(table.name)
+        };
+      }
       await db.connection.transaction(async (trx) => {
         await this.createTables(schemaDiff.tables.added, trx);
         if (forceMigration) {
@@ -1056,7 +1063,8 @@ const createSchemaBuilder = (db) => {
         for (const table of schemaDiff.tables.updated) {
           debug$2(`Updating table: ${table.name}`);
           const schemaBuilder = this.getSchemaBuilder(trx);
-          await helpers2.alterTable(schemaBuilder, table);
+          const { indexes, foreignKeys } = existingMetadata[table.name];
+          await helpers2.alterTable(schemaBuilder, table, { indexes, foreignKeys });
         }
       });
       await db.dialect.endSchemaUpdate();
@@ -1074,29 +1082,37 @@ const createHelpers = (db) => {
       constraint.onUpdate(onUpdate);
     }
   };
-  const dropForeignKey = (tableBuilder, foreignKey) => {
+  const dropForeignKey = (tableBuilder, foreignKey, existingForeignKeys) => {
     const { name, columns } = foreignKey;
+    if (existingForeignKeys && !existingForeignKeys.some((existingIndex) => existingIndex?.name === name)) {
+      debug$2(`Foreign Key ${name} not found in existing foreign keys. Skipping drop.`);
+      return;
+    }
     tableBuilder.dropForeign(columns, name);
   };
   const createIndex = (tableBuilder, index2) => {
     const { type, columns, name } = index2;
     switch (type) {
       case "primary": {
-        return tableBuilder.primary(columns, name);
+        return tableBuilder.primary(columns, { constraintName: name });
       }
       case "unique": {
-        return tableBuilder.unique(columns, name);
+        return tableBuilder.unique(columns, { indexName: name });
       }
       default: {
         return tableBuilder.index(columns, name, type);
       }
     }
   };
-  const dropIndex2 = (tableBuilder, index2) => {
+  const dropIndex2 = (tableBuilder, index2, existingIndexes) => {
     if (!db.config.settings?.forceMigration) {
       return;
     }
     const { type, columns, name } = index2;
+    if (existingIndexes && !existingIndexes.some((existingIndex) => existingIndex?.name === name)) {
+      debug$2(`Index ${index2.name} not found in existingIndexes. Skipping drop.`);
+      return;
+    }
     switch (type) {
       case "primary": {
         return tableBuilder.dropPrimary(name);
@@ -1147,32 +1163,36 @@ const createHelpers = (db) => {
       }
     });
   };
-  const alterTable = async (schemaBuilder, table) => {
-    await schemaBuilder.alterTable(table.name, (tableBuilder) => {
+  const alterTable = async (schemaBuilder, table, existingMetadata = {
+    indexes: [],
+    foreignKeys: []
+  }) => {
+    let existingIndexes = [...existingMetadata.indexes];
+    const existingForeignKeys = [...existingMetadata.foreignKeys];
+    const droppedForeignKeyNames = [];
+    await schemaBuilder.alterTable(table.name, async (tableBuilder) => {
       for (const removedForeignKey of table.foreignKeys.removed) {
         debug$2(`Dropping foreign key ${removedForeignKey.name} on ${table.name}`);
-        dropForeignKey(tableBuilder, removedForeignKey);
+        dropForeignKey(tableBuilder, removedForeignKey, existingForeignKeys);
+        droppedForeignKeyNames.push(removedForeignKey.name);
       }
       for (const updatedForeignKey of table.foreignKeys.updated) {
         debug$2(`Dropping updated foreign key ${updatedForeignKey.name} on ${table.name}`);
-        dropForeignKey(tableBuilder, updatedForeignKey.object);
+        dropForeignKey(tableBuilder, updatedForeignKey.object, existingForeignKeys);
+        droppedForeignKeyNames.push(updatedForeignKey.object.name);
+      }
+      if (db.config.connection.client === "mysql") {
+        existingIndexes = existingIndexes.filter(
+          (index2) => !droppedForeignKeyNames.includes(index2.name)
+        );
       }
-      const isMySQL = db.config.connection.client === "mysql";
-      const ignoreForeignKeyNames = isMySQL ? [
-        ...table.foreignKeys.removed.map((fk) => fk.name),
-        ...table.foreignKeys.updated.map((fk) => fk.name)
-      ] : [];
       for (const removedIndex of table.indexes.removed) {
-        if (!ignoreForeignKeyNames.includes(removedIndex.name)) {
-          debug$2(`Dropping index ${removedIndex.name} on ${table.name}`);
-          dropIndex2(tableBuilder, removedIndex);
-        }
+        debug$2(`Dropping index ${removedIndex.name} on ${table.name}`);
+        dropIndex2(tableBuilder, removedIndex, existingIndexes);
       }
       for (const updatedIndex of table.indexes.updated) {
-        if (!ignoreForeignKeyNames.includes(updatedIndex.name)) {
-          debug$2(`Dropping updated index ${updatedIndex.name} on ${table.name}`);
-          dropIndex2(tableBuilder, updatedIndex.object);
-        }
+        debug$2(`Dropping updated index ${updatedIndex.name} on ${table.name}`);
+        dropIndex2(tableBuilder, updatedIndex.object, existingIndexes);
       }
       for (const removedColumn of table.columns.removed) {
         debug$2(`Dropping column ${removedColumn.name} on ${table.name}`);
@@ -1205,7 +1225,7 @@ const createHelpers = (db) => {
         createIndex(tableBuilder, updatedIndex.object);
       }
       for (const addedForeignKey of table.foreignKeys.added) {
-        debug$2(`Creating foreign keys ${addedForeignKey.name} on ${table.name}`);
+        debug$2(`Creating foreign key ${addedForeignKey.name} on ${table.name}`);
         createForeignKey(tableBuilder, addedForeignKey);
       }
       for (const addedIndex of table.indexes.added) {