@strapi/database 4.5.0-alpha.0 → 4.5.0-beta.0

package/lib/entity-manager/index.js

@@ -12,9 +12,12 @@ const {
   isEmpty,
   isArray,
   isNull,
-  uniqBy,
-  differenceBy,
-  groupBy,
+  uniqWith,
+  isEqual,
+  differenceWith,
+  isNumber,
+  map,
+  difference,
 } = require('lodash/fp');
 const types = require('../types');
 const { createField } = require('../fields');
@@ -23,25 +26,24 @@ const { createRepository } = require('./entity-repository');
 const { deleteRelatedMorphOneRelationsAfterMorphToManyUpdate } = require('./morph-relations');
 const {
   isBidirectional,
-  isOneToAny,
-  isManyToAny,
   isAnyToOne,
-  isAnyToMany,
+  isOneToAny,
+  hasOrderColumn,
+  hasInverseOrderColumn,
 } = require('../metadata/relations');
+const {
+  deletePreviousOneToAnyRelations,
+  deletePreviousAnyToOneRelations,
+  deleteRelations,
+  cleanOrderColumns,
+} = require('./regular-relations');
 
 const toId = (value) => value.id || value;
 const toIds = (value) => castArray(value || []).map(toId);
 
 const isValidId = (value) => isString(value) || isInteger(value);
-const toAssocs = (data) => {
-  if (data?.connect || data?.disconnect || (isPlainObject(data) && !data.id)) {
-    return {
-      connect: toAssocs(data.connect),
-      disconnect: toAssocs(data.disconnect),
-    };
-  }
-
-  return castArray(data)
+const toIdArray = (data) => {
+  const array = castArray(data)
     .filter((datum) => !isNil(datum))
     .map((datum) => {
       // if it is a string or an integer return an obj with id = to datum
@@ -56,6 +58,26 @@ const toAssocs = (data) => {
 
       return datum;
     });
+  return uniqWith(isEqual, array);
+};
+
+const toAssocs = (data) => {
+  if (isArray(data) || isString(data) || isNumber(data) || isNull(data) || data?.id) {
+    return {
+      set: isNull(data) ? data : toIdArray(data),
+    };
+  }
+
+  if (data?.set) {
+    return {
+      set: isNull(data.set) ? data.set : toIdArray(data.set),
+    };
+  }
+
+  return {
+    connect: toIdArray(data?.connect),
+    disconnect: toIdArray(data?.disconnect),
+  };
 };
 
 const processData = (metadata, data = {}, { withDefaults = false } = {}) => {
@@ -189,12 +211,24 @@ const createEntityManager = (db) => {
       }
 
       const dataToInsert = processData(metadata, data, { withDefaults: true });
+      let id;
+
+      const trx = await strapi.db.transaction();
+      try {
+        const res = await this.createQueryBuilder(uid)
+          .insert(dataToInsert)
+          .transacting(trx)
+          .execute();
 
-      const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
+        id = res[0].id || res[0];
 
-      const id = res[0].id || res[0];
+        await this.attachRelations(uid, id, data, { transaction: trx });
 
-      await this.attachRelations(uid, id, data);
+        await trx.commit();
+      } catch (e) {
+        await trx.rollback();
+        throw e;
+      }
 
       // TODO: in case there is no select or populate specified return the inserted data ?
       // TODO: do not trigger the findOne lifecycles ?
@@ -259,13 +293,25 @@ const createEntityManager = (db) => {
 
       const { id } = entity;
 
-      const dataToUpdate = processData(metadata, data);
+      const trx = await strapi.db.transaction();
+      try {
+        const dataToUpdate = processData(metadata, data);
 
-      if (!isEmpty(dataToUpdate)) {
-        await this.createQueryBuilder(uid).where({ id }).update(dataToUpdate).execute();
-      }
+        if (!isEmpty(dataToUpdate)) {
+          await this.createQueryBuilder(uid)
+            .where({ id })
+            .update(dataToUpdate)
+            .transacting(trx)
+            .execute();
+        }
 
-      await this.updateRelations(uid, id, data);
+        await this.updateRelations(uid, id, data, { transaction: trx });
+
+        await trx.commit();
+      } catch (e) {
+        await trx.rollback();
+        throw e;
+      }
 
       // TODO: do not trigger the findOne lifecycles ?
       const result = await this.findOne(uid, {
@@ -326,9 +372,17 @@ const createEntityManager = (db) => {
 
       const { id } = entity;
 
-      await this.createQueryBuilder(uid).where({ id }).delete().execute();
+      const trx = await strapi.db.transaction();
+      try {
+        await this.createQueryBuilder(uid).where({ id }).delete().transacting(trx).execute();
 
-      await this.deleteRelations(uid, id);
+        await this.deleteRelations(uid, id, { transaction: trx });
+
+        await trx.commit();
+      } catch (e) {
+        await trx.rollback();
+        throw e;
+      }
 
       await db.lifecycles.run('afterDelete', uid, { params, result: entity }, states);
 
@@ -358,8 +412,7 @@ const createEntityManager = (db) => {
      * @param {ID} id - entity ID
      * @param {object} data - data received for creation
      */
-    // TODO: wrap Transaction
-    async attachRelations(uid, id, data) {
+    async attachRelations(uid, id, data, { transaction: trx }) {
       const { attributes } = db.metadata.get(uid);
 
       for (const attributeName of Object.keys(attributes)) {
@@ -371,6 +424,8 @@ const createEntityManager = (db) => {
           continue;
         }
 
+        const cleanRelationData = toAssocs(data[attributeName]);
+
         if (attribute.relation === 'morphOne' || attribute.relation === 'morphMany') {
           const { target, morphBy } = attribute;
 
@@ -380,9 +435,12 @@ const createEntityManager = (db) => {
             // set columns
             const { idColumn, typeColumn } = targetAttribute.morphColumn;
 
+            const relId = toId(cleanRelationData.set[0]);
+
             await this.createQueryBuilder(target)
               .update({ [idColumn.name]: id, [typeColumn.name]: uid })
-              .where({ id: toId(data[attributeName]) })
+              .where({ id: relId })
+              .transacting(trx)
               .execute();
           } else if (targetAttribute.relation === 'morphToMany') {
             const { joinTable } = targetAttribute;
@@ -390,7 +448,11 @@ const createEntityManager = (db) => {
 
             const { idColumn, typeColumn } = morphColumn;
 
-            const rows = toAssocs(data[attributeName]).map((data, idx) => {
+            if (isEmpty(cleanRelationData.set)) {
+              continue;
+            }
+
+            const rows = cleanRelationData.set.map((data, idx) => {
               return {
                 [joinColumn.name]: data.id,
                 [idColumn.name]: id,
@@ -402,11 +464,7 @@ const createEntityManager = (db) => {
               };
             });
 
-            if (isEmpty(rows)) {
-              continue;
-            }
-
-            await this.createQueryBuilder(joinTable.name).insert(rows).execute();
+            await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
           }
 
           continue;
@@ -419,40 +477,44 @@ const createEntityManager = (db) => {
 
           const { idColumn, typeColumn, typeField = '__type' } = morphColumn;
 
-          const rows = toAssocs(data[attributeName]).map((data) => ({
+          if (isEmpty(cleanRelationData.set)) {
+            continue;
+          }
+
+          const rows = cleanRelationData.set.map((data, idx) => ({
             [joinColumn.name]: id,
             [idColumn.name]: data.id,
             [typeColumn.name]: data[typeField],
             ...(joinTable.on || {}),
             ...(data.__pivot || {}),
+            order: idx + 1,
           }));
 
-          if (isEmpty(rows)) {
-            continue;
-          }
-
           // delete previous relations
           await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
             uid,
             attributeName,
             joinTable,
             db,
+            transaction: trx,
           });
 
-          await this.createQueryBuilder(joinTable.name).insert(rows).execute();
+          await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
 
           continue;
         }
 
         if (attribute.joinColumn && attribute.owner) {
+          const relIdsToAdd = toIds(cleanRelationData.set);
           if (
             attribute.relation === 'oneToOne' &&
             isBidirectional(attribute) &&
-            data[attributeName]
+            relIdsToAdd.length
           ) {
             await this.createQueryBuilder(uid)
-              .where({ [attribute.joinColumn.name]: data[attributeName], id: { $ne: id } })
+              .where({ [attribute.joinColumn.name]: relIdsToAdd, id: { $ne: id } })
               .update({ [attribute.joinColumn.name]: null })
+              .transacting(trx)
               .execute();
           }
 
@@ -465,16 +527,19 @@ const createEntityManager = (db) => {
           const { target } = attribute;
 
           // TODO: check it is an id & the entity exists (will throw due to FKs otherwise so not a big pbl in SQL)
+          const relIdsToAdd = toIds(cleanRelationData.set);
 
           await this.createQueryBuilder(target)
             .where({ [attribute.joinColumn.referencedColumn]: id })
             .update({ [attribute.joinColumn.referencedColumn]: null })
+            .transacting(trx)
             .execute();
 
           await this.createQueryBuilder(target)
             .update({ [attribute.joinColumn.referencedColumn]: id })
             // NOTE: works if it is an array or a single id
-            .where({ id: data[attributeName] })
+            .where({ id: relIdsToAdd })
+            .transacting(trx)
             .execute();
         }
 
@@ -484,50 +549,18 @@ const createEntityManager = (db) => {
           const { joinTable } = attribute;
           const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } =
             joinTable;
-          const select = [joinColumn.name];
-          if (isAnyToMany(attribute)) {
-            select.push(orderColumnName);
-          }
 
-          const cleanRelationData = toAssocs(data[attributeName]);
-          const relsToAdd = uniqBy('id', cleanRelationData.connect || cleanRelationData);
+          const relsToAdd = cleanRelationData.set || cleanRelationData.connect;
           const relIdsToadd = toIds(relsToAdd);
 
-          // need to delete the previous relations for oneToAny relations
           if (isBidirectional(attribute) && isOneToAny(attribute)) {
-            // update orders for previous oneToAny relations that will be deleted if it has order (oneToMany)
-            if (isAnyToMany(attribute)) {
-              const currentRelsToDelete = await this.createQueryBuilder(joinTable.name)
-                .select(select)
-                .where({
-                  [inverseJoinColumn.name]: relIdsToadd,
-                  [joinColumn.name]: { $ne: id },
-                })
-                .where(joinTable.on || {})
-                .execute();
-
-              currentRelsToDelete.sort((a, b) => b[orderColumnName] - a[orderColumnName]);
-
-              for (const relToDelete of currentRelsToDelete) {
-                if (relToDelete[orderColumnName] !== null) {
-                  await this.createQueryBuilder(joinTable.name)
-                    .decrement(orderColumnName, 1)
-                    .where({
-                      [joinColumn.name]: relToDelete[joinColumn.name],
-                      [orderColumnName]: { $gt: relToDelete[orderColumnName] },
-                    })
-                    .where(joinTable.on || {})
-                    .execute();
-                }
-              }
-            }
-
-            // delete previous oneToAny relations
-            await this.createQueryBuilder(joinTable.name)
-              .delete()
-              .where({ [inverseJoinColumn.name]: relIdsToadd })
-              .where(joinTable.on || {})
-              .execute();
+            await deletePreviousOneToAnyRelations({
+              id,
+              attribute,
+              relIdsToadd,
+              db,
+              transaction: trx,
+            });
           }
 
           // prepare new relations to insert
@@ -540,30 +573,31 @@ const createEntityManager = (db) => {
             };
           });
 
-          // add order value when relevant
-          if (isAnyToMany(attribute)) {
+          // add order value
+          if (hasOrderColumn(attribute)) {
             insert.forEach((rel, idx) => {
               rel[orderColumnName] = idx + 1;
             });
           }
-          // add inv_order value when relevant
-          if (isBidirectional(attribute) && isManyToAny(attribute)) {
-            const maxMap = {};
-            await Promise.all(
-              relIdsToadd.map(async (relId) => {
-                const { max } = await this.createQueryBuilder(joinTable.name)
-                  .max(inverseOrderColumnName)
-                  .where({ [inverseJoinColumn.name]: relId })
-                  .where(joinTable.on || {})
-                  .first()
-                  .execute();
+          // add inv_order value
+          if (hasInverseOrderColumn(attribute)) {
+            const maxResults = await db
+              .getConnection()
+              .select(inverseJoinColumn.name)
+              .max(inverseOrderColumnName, { as: 'max' })
+              .whereIn(inverseJoinColumn.name, relIdsToadd)
+              .where(joinTable.on || {})
+              .groupBy(inverseJoinColumn.name)
+              .from(joinTable.name)
+              .transacting(trx);
 
-                maxMap[relId] = max;
-              })
+            const maxMap = maxResults.reduce(
+              (acc, res) => Object.assign(acc, { [res[inverseJoinColumn.name]]: res.max }),
+              {}
             );
 
             insert.forEach((rel) => {
-              rel[inverseOrderColumnName] = maxMap[rel[inverseJoinColumn.name]] + 1;
+              rel[inverseOrderColumnName] = (maxMap[rel[inverseJoinColumn.name]] || 0) + 1;
             });
           }
 
@@ -572,7 +606,7 @@ const createEntityManager = (db) => {
           }
 
           // insert new relations
-          await this.createQueryBuilder(joinTable.name).insert(insert).execute();
+          await this.createQueryBuilder(joinTable.name).insert(insert).transacting(trx).execute();
         }
       }
     },
@@ -586,8 +620,7 @@ const createEntityManager = (db) => {
      * @param {object} data - data received for creation
      */
     // TODO: check relation exists (handled by FKs except for polymorphics)
-    // TODO: wrap Transaction
-    async updateRelations(uid, id, data) {
+    async updateRelations(uid, id, data, { transaction: trx }) {
       const { attributes } = db.metadata.get(uid);
 
       for (const attributeName of Object.keys(attributes)) {
@@ -596,6 +629,7 @@ const createEntityManager = (db) => {
         if (attribute.type !== 'relation' || !has(attributeName, data)) {
           continue;
         }
+        const cleanRelationData = toAssocs(data[attributeName]);
 
         if (attribute.relation === 'morphOne' || attribute.relation === 'morphMany') {
           const { target, morphBy } = attribute;
@@ -611,12 +645,15 @@ const createEntityManager = (db) => {
             await this.createQueryBuilder(target)
               .update({ [idColumn.name]: null, [typeColumn.name]: null })
               .where({ [idColumn.name]: id, [typeColumn.name]: uid })
+              .transacting(trx)
               .execute();
 
-            if (!isNull(data[attributeName])) {
+            if (!isNull(cleanRelationData.set)) {
+              const relId = toIds(cleanRelationData.set[0]);
               await this.createQueryBuilder(target)
                 .update({ [idColumn.name]: id, [typeColumn.name]: uid })
-                .where({ id: toId(data[attributeName]) })
+                .where({ id: relId })
+                .transacting(trx)
                 .execute();
             }
           } else if (targetAttribute.relation === 'morphToMany') {
@@ -633,9 +670,14 @@ const createEntityManager = (db) => {
                 ...(joinTable.on || {}),
                 field: attributeName,
               })
+              .transacting(trx)
               .execute();
 
-            const rows = toAssocs(data[attributeName]).map((data, idx) => ({
+            if (isEmpty(cleanRelationData.set)) {
+              continue;
+            }
+
+            const rows = cleanRelationData.set.map((data, idx) => ({
               [joinColumn.name]: data.id,
               [idColumn.name]: id,
               [typeColumn.name]: uid,
@@ -645,11 +687,7 @@ const createEntityManager = (db) => {
               field: attributeName,
             }));
 
-            if (isEmpty(rows)) {
-              continue;
-            }
-
-            await this.createQueryBuilder(joinTable.name).insert(rows).execute();
+            await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
           }
 
           continue;
@@ -672,29 +710,32 @@ const createEntityManager = (db) => {
               [joinColumn.name]: id,
               ...(joinTable.on || {}),
             })
+            .transacting(trx)
             .execute();
 
-          const rows = toAssocs(data[attributeName]).map((data) => ({
+          if (isEmpty(cleanRelationData.set)) {
+            continue;
+          }
+
+          const rows = cleanRelationData.set.map((data, idx) => ({
             [joinColumn.name]: id,
             [idColumn.name]: data.id,
             [typeColumn.name]: data[typeField],
             ...(joinTable.on || {}),
             ...(data.__pivot || {}),
+            order: idx + 1,
           }));
 
-          if (isEmpty(rows)) {
-            continue;
-          }
-
           // delete previous relations
           await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
             uid,
             attributeName,
             joinTable,
             db,
+            transaction: trx,
           });
 
-          await this.createQueryBuilder(joinTable.name).insert(rows).execute();
+          await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
 
           continue;
         }
@@ -713,13 +754,15 @@ const createEntityManager = (db) => {
           await this.createQueryBuilder(target)
             .where({ [attribute.joinColumn.referencedColumn]: id })
             .update({ [attribute.joinColumn.referencedColumn]: null })
+            .transacting(trx)
             .execute();
 
-          if (!isNull(data[attributeName])) {
+          if (!isNull(cleanRelationData.set)) {
+            const relIdsToAdd = toIds(cleanRelationData.set);
             await this.createQueryBuilder(target)
-              // NOTE: works if it is an array or a single id
-              .where({ id: data[attributeName] })
+              .where({ id: relIdsToAdd })
               .update({ [attribute.joinColumn.referencedColumn]: id })
+              .transacting(trx)
               .execute();
           }
         }
@@ -729,430 +772,224 @@ const createEntityManager = (db) => {
           const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } =
             joinTable;
           const select = [joinColumn.name, inverseJoinColumn.name];
-          if (isAnyToMany(attribute)) {
+          if (hasOrderColumn(attribute)) {
             select.push(orderColumnName);
           }
-          if (isBidirectional(attribute) && isManyToAny(attribute)) {
+          if (hasInverseOrderColumn(attribute)) {
             select.push(inverseOrderColumnName);
           }
 
           // only delete relations
-          if (isNull(data[attributeName])) {
-            // INVERSE ORDER UPDATE
-            if (isBidirectional(attribute) && isManyToAny(attribute)) {
-              let lastId = 0;
-              let done = false;
-              const batchSize = 100;
-              while (!done) {
-                const relsToDelete = await this.createQueryBuilder(joinTable.name)
-                  .select(select)
-                  .where({
-                    [joinColumn.name]: id,
-                    id: { $gt: lastId },
-                  })
-                  .where(joinTable.on || {})
-                  .orderBy('id')
-                  .limit(batchSize)
-                  .execute();
-                // TODO: cannot put pivot here...
-                done = relsToDelete.length < batchSize;
-                lastId = relsToDelete[relsToDelete.length - 1]?.id;
-
-                const updateInverseOrderPromises = [];
-                for (const relToDelete of relsToDelete) {
-                  if (relToDelete[inverseOrderColumnName] !== null) {
-                    const updatePromise = this.createQueryBuilder(joinTable.name)
-                      .decrement(inverseOrderColumnName, 1)
-                      .where({
-                        [inverseJoinColumn.name]: relToDelete[inverseJoinColumn.name],
-                        [inverseOrderColumnName]: { $gt: relToDelete[inverseOrderColumnName] },
-                      })
-                      .where(joinTable.on || {})
-                      .execute();
-                    updateInverseOrderPromises.push(updatePromise);
-                  }
-                }
-
-                await Promise.all(updateInverseOrderPromises);
-              }
-            }
-
-            await this.createQueryBuilder(joinTable.name)
-              .delete()
-              .where({ [joinColumn.name]: id })
-              .where(joinTable.on || {})
-              .execute();
+          if (isNull(cleanRelationData.set)) {
+            await deleteRelations({ id, attribute, db, relIdsToDelete: 'all', transaction: trx });
           } else {
-            const cleanRelationData = toAssocs(data[attributeName]);
-            const isPartialUpdate =
-              has('connect', cleanRelationData) || has('disconnect', cleanRelationData);
+            const isPartialUpdate = !has('set', cleanRelationData);
             let relIdsToaddOrMove;
 
             if (isPartialUpdate) {
-              // does not support pivot
-              let connect = uniqBy('id', cleanRelationData.connect || []);
-              let disconnect = uniqBy('id', cleanRelationData.disconnect || []);
               if (isAnyToOne(attribute)) {
-                connect = connect.slice(-1);
-                disconnect = [];
+                cleanRelationData.connect = cleanRelationData.connect.slice(-1);
+              }
+              relIdsToaddOrMove = toIds(cleanRelationData.connect);
+              const relIdsToDelete = toIds(
+                differenceWith(isEqual, cleanRelationData.disconnect, cleanRelationData.connect)
+              );
+
+              if (!isEmpty(relIdsToDelete)) {
+                await deleteRelations({ id, attribute, db, relIdsToDelete, transaction: trx });
+              }
+
+              if (isEmpty(cleanRelationData.connect)) {
+                continue;
               }
-              relIdsToaddOrMove = toIds(connect);
-              // DELETE relations in disconnect
-              const relIdsToDelete = toIds(differenceBy('id', disconnect, connect));
-
-              // UPDATE RELEVANT ORDERS
-              if (
-                isAnyToMany(attribute) ||
-                (isBidirectional(attribute) && isManyToAny(attribute))
-              ) {
-                const relsToDelete = await this.createQueryBuilder(joinTable.name)
+
+              // Fetch current relations to handle ordering
+              let currentMovingRels;
+              if (hasOrderColumn(attribute) || hasInverseOrderColumn(attribute)) {
+                currentMovingRels = await this.createQueryBuilder(joinTable.name)
                   .select(select)
                   .where({
                     [joinColumn.name]: id,
-                    [inverseJoinColumn.name]: { $in: relIdsToDelete },
+                    [inverseJoinColumn.name]: { $in: relIdsToaddOrMove },
                   })
                   .where(joinTable.on || {})
+                  .transacting(trx)
                   .execute();
-
-                // ORDER UPDATE
-                if (isAnyToMany(attribute)) {
-                  // sort by order DESC so that the order updates are done in the correct order
-                  // avoiding one to interfere with the others
-                  relsToDelete.sort((a, b) => b[orderColumnName] - a[orderColumnName]);
-
-                  for (const relToDelete of relsToDelete) {
-                    if (relToDelete[orderColumnName] !== null) {
-                      await this.createQueryBuilder(joinTable.name)
-                        .decrement(orderColumnName, 1)
-                        .where({
-                          [joinColumn.name]: id,
-                          [orderColumnName]: { $gt: relToDelete[orderColumnName] },
-                        })
-                        .where(joinTable.on || {})
-                        .execute();
-                    }
-                  }
-                }
-
-                // INVERSE ORDER UPDATE
-                if (isBidirectional(attribute) && isManyToAny(attribute)) {
-                  const updateInverseOrderPromises = [];
-                  for (const relToDelete of relsToDelete) {
-                    if (relToDelete[inverseOrderColumnName] !== null) {
-                      const updatePromise = this.createQueryBuilder(joinTable.name)
-                        .decrement(inverseOrderColumnName, 1)
-                        .where({
-                          [inverseJoinColumn.name]: relToDelete[inverseJoinColumn.name],
-                          [inverseOrderColumnName]: { $gt: relToDelete[inverseOrderColumnName] },
-                        })
-                        .where(joinTable.on || {})
-                        .execute();
-                      updateInverseOrderPromises.push(updatePromise);
-                    }
-                  }
-
-                  await Promise.all(updateInverseOrderPromises);
-                }
               }
 
-              // DELETE
-              await this.createQueryBuilder(joinTable.name)
-                .delete()
-                .where({
-                  [joinColumn.name]: id,
-                  [inverseJoinColumn.name]: { $in: relIdsToDelete },
-                })
-                .where(joinTable.on || {})
-                .execute();
-
-              // add/move
-              let max;
-              const currentMovingRels = await this.createQueryBuilder(joinTable.name)
-                .select(select)
-                .where({
-                  [joinColumn.name]: id,
-                  [inverseJoinColumn.name]: { $in: relIdsToaddOrMove },
-                })
-                .where(joinTable.on || {})
-                .execute();
-              const currentMovingRelsMap = groupBy(inverseJoinColumn.name, currentMovingRels);
+              // prepare relations to insert
+              const insert = cleanRelationData.connect.map((relToAdd) => ({
+                [joinColumn.name]: id,
+                [inverseJoinColumn.name]: relToAdd.id,
+                ...(joinTable.on || {}),
+                ...(relToAdd.__pivot || {}),
+              }));
 
-              if (isAnyToMany(attribute)) {
-                max = (
+              // add order value
+              if (hasOrderColumn(attribute)) {
+                const orderMax = (
                   await this.createQueryBuilder(joinTable.name)
                     .max(orderColumnName)
                     .where({ [joinColumn.name]: id })
                     .where(joinTable.on || {})
                     .first()
+                    .transacting(trx)
                     .execute()
                 ).max;
+
+                insert.forEach((row, idx) => {
+                  row[orderColumnName] = orderMax + idx + 1;
+                });
               }
 
-              for (const relToAddOrMove of connect) {
-                // const currentRel = currentMovingRelsMap[relToAddOrMove.id]?.[0];
-                const currentRel = currentMovingRelsMap[relToAddOrMove.id]?.[0];
-                if (currentRel && isAnyToMany(attribute)) {
-                  const currentOrderIsNull = currentRel[orderColumnName] === null;
-                  if (!currentOrderIsNull) {
-                    await this.createQueryBuilder(joinTable.name)
-                      .decrement(orderColumnName, 1)
-                      .where({
-                        [joinColumn.name]: id,
-                        [orderColumnName]: { $gt: currentRel[orderColumnName] },
-                      })
-                      .where(joinTable.on || {})
-                      .execute();
-
-                    currentMovingRels.forEach((rel) => {
-                      if (rel[orderColumnName] > currentRel[orderColumnName]) {
-                        rel[orderColumnName] -= 1;
-                      }
-                    });
-                  }
+              // add inv order value
+              if (hasInverseOrderColumn(attribute)) {
+                const nonExistingRelsIds = difference(
+                  relIdsToaddOrMove,
+                  map(inverseJoinColumn.name, currentMovingRels)
+                );
+
+                const maxResults = await db
+                  .getConnection()
+                  .select(inverseJoinColumn.name)
+                  .max(inverseOrderColumnName, { as: 'max' })
+                  .whereIn(inverseJoinColumn.name, nonExistingRelsIds)
+                  .where(joinTable.on || {})
+                  .groupBy(inverseJoinColumn.name)
+                  .from(joinTable.name)
+                  .transacting(trx);
+
+                const maxMap = maxResults.reduce(
+                  (acc, res) => Object.assign(acc, { [res[inverseJoinColumn.name]]: res.max }),
+                  {}
+                );
+
+                insert.forEach((row) => {
+                  row[inverseOrderColumnName] = (maxMap[row[inverseJoinColumn.name]] || 0) + 1;
+                });
+              }
 
-                  await this.createQueryBuilder(joinTable.name)
-                    .update({
-                      [orderColumnName]: currentOrderIsNull ? max + 1 : max,
-                    })
-                    .where({
-                      [joinColumn.name]: id,
-                      [inverseJoinColumn.name]: relToAddOrMove.id,
-                    })
-                    .where(joinTable.on || {})
-                    .execute();
-                } else if (!currentRel) {
-                  const insert = {
-                    [joinColumn.name]: id,
-                    [inverseJoinColumn.name]: relToAddOrMove.id,
-                    ...(relToAddOrMove.__pivot || {}),
-                  };
-
-                  if (isAnyToMany(attribute)) {
-                    insert[orderColumnName] = max + 1;
-                  }
-
-                  if (isBidirectional(attribute) && isManyToAny(attribute)) {
-                    const { max: reverseMax } = await this.createQueryBuilder(joinTable.name)
-                      .max(inverseOrderColumnName)
-                      .where({ [inverseJoinColumn.name]: relToAddOrMove.id })
-                      .where(joinTable.on || {})
-                      .first()
-                      .execute();
-
-                    insert[inverseOrderColumnName] = reverseMax + 1;
-                  }
-
-                  await this.createQueryBuilder(joinTable.name).insert(insert).execute();
-                  max += 1;
-                }
+              // insert rows
+              const query = this.createQueryBuilder(joinTable.name)
+                .insert(insert)
+                .onConflict(joinTable.pivotColumns)
+                .transacting(trx);
+
+              if (hasOrderColumn(attribute)) {
+                query.merge([orderColumnName]);
+              } else {
+                query.ignore();
               }
+
+              await query.execute();
+
+              // remove gap between orders
+              await cleanOrderColumns({ attribute, db, id, transaction: trx });
             } else {
+              if (isAnyToOne(attribute)) {
+                cleanRelationData.set = cleanRelationData.set.slice(-1);
+              }
               // overwrite all relations
-              const relsToAdd = uniqBy('id', cleanRelationData);
-              relIdsToaddOrMove = toIds(relsToAdd);
-
-              // UPDATE RELEVANT ORDERS BEFORE DELETE
-              if (isAnyToMany(attribute) || isManyToAny(attribute)) {
-                let lastId = 0;
-                let done = false;
-                const batchSize = 100;
-                while (!done) {
-                  const relsToDelete = await this.createQueryBuilder(joinTable.name)
-                    .select(select)
-                    .where({
-                      [joinColumn.name]: id,
-                      [inverseJoinColumn.name]: { $notIn: relIdsToaddOrMove },
-                      id: { $gt: lastId },
-                    })
-                    .where(joinTable.on || {})
-                    .orderBy('id')
-                    .limit(batchSize)
-                    .execute();
-
-                  done = relsToDelete.length < batchSize;
-                  lastId = relsToDelete[relsToDelete.length - 1]?.id;
-
-                  // ORDER UPDATE
-                  if (isAnyToMany(attribute)) {
-                    // sort by order DESC so that the order updates are done in the correct order
-                    // avoiding one to interfere with the others
-                    relsToDelete.sort((a, b) => b[orderColumnName] - a[orderColumnName]);
-
-                    for (const relToDelete of relsToDelete) {
-                      if (relToDelete[orderColumnName] !== null) {
-                        await this.createQueryBuilder(joinTable.name)
-                          .decrement(orderColumnName, 1)
-                          .where({
-                            [joinColumn.name]: id,
-                            [orderColumnName]: { $gt: relToDelete[orderColumnName] },
-                          })
-                          .where(joinTable.on || {})
-                          // manque le pivot ici
-                          .execute();
-                      }
-                    }
-                  }
-
-                  // INVERSE ORDER UPDATE
-                  if (isBidirectional(attribute) && isManyToAny(attribute)) {
-                    const updateInverseOrderPromises = [];
-                    for (const relToDelete of relsToDelete) {
-                      if (relToDelete[inverseOrderColumnName] !== null) {
-                        const updatePromise = this.createQueryBuilder(joinTable.name)
-                          .decrement(inverseOrderColumnName, 1)
-                          .where({
-                            [inverseJoinColumn.name]: relToDelete[inverseJoinColumn.name],
-                            [inverseOrderColumnName]: { $gt: relToDelete[inverseOrderColumnName] },
-                          })
-                          .where(joinTable.on || {})
-                          .execute();
-                        updateInverseOrderPromises.push(updatePromise);
-                      }
-                    }
-
-                    await Promise.all(updateInverseOrderPromises);
-                  }
-                }
+              relIdsToaddOrMove = toIds(cleanRelationData.set);
+              await deleteRelations({
+                id,
+                attribute,
+                db,
+                relIdsToDelete: 'all',
+                relIdsToNotDelete: relIdsToaddOrMove,
+                transaction: trx,
+              });
+
+              if (isEmpty(cleanRelationData.set)) {
+                continue;
               }
 
-              // DELETE
-              await this.createQueryBuilder(joinTable.name)
-                .delete()
-                .where({
-                  [joinColumn.name]: id,
-                  [inverseJoinColumn.name]: { $notIn: relIdsToaddOrMove },
-                })
-                .where(joinTable.on || {})
-                .execute();
-
-              const currentMovingRels = await this.createQueryBuilder(joinTable.name)
-                .select(select)
-                .where({
-                  [joinColumn.name]: id,
-                  [inverseJoinColumn.name]: { $in: relIdsToaddOrMove },
-                })
-                .where(joinTable.on || {})
-                .execute();
-              const currentMovingRelsMap = groupBy(inverseJoinColumn.name, currentMovingRels);
-
-              let max = 0;
-              for (const relToAdd of relsToAdd) {
-                const currentRel = currentMovingRelsMap[relToAdd.id]?.[0];
-
-                if (currentRel && isAnyToMany(attribute)) {
-                  const update = { [orderColumnName]: max + 1 };
-                  await this.createQueryBuilder(joinTable.name)
-                    .update(update)
-                    .where({
-                      [joinColumn.name]: id,
-                      [inverseJoinColumn.name]: relToAdd.id,
-                    })
-                    .where(joinTable.on || {})
-                    .execute();
-                } else if (!currentRel) {
-                  const insert = {
-                    [joinColumn.name]: id,
-                    [inverseJoinColumn.name]: relToAdd.id,
-                    ...(relToAdd.__pivot || {}),
-                  };
-
-                  if (isAnyToMany(attribute)) {
-                    insert[orderColumnName] = max + 1;
-                  }
-                  // can be optimized in one query
-                  if (isBidirectional(attribute) && isManyToAny(attribute)) {
-                    const { max: reverseMax } = await this.createQueryBuilder(joinTable.name)
-                      .max(inverseOrderColumnName)
-                      .where({ [inverseJoinColumn.name]: id })
-                      .where(joinTable.on || {})
-                      .first()
-                      .execute();
-
-                    insert[inverseOrderColumnName] = reverseMax + 1;
-                  }
-
-                  await this.createQueryBuilder(joinTable.name).insert(insert).execute();
-                }
-                max += 1;
+              const insert = cleanRelationData.set.map((relToAdd) => ({
+                [joinColumn.name]: id,
+                [inverseJoinColumn.name]: relToAdd.id,
+                ...(joinTable.on || {}),
+                ...(relToAdd.__pivot || {}),
+              }));
+
+              // add order value
+              if (hasOrderColumn(attribute)) {
+                insert.forEach((row, idx) => {
+                  row[orderColumnName] = idx + 1;
+                });
               }
-            }
 
-            // Delete the previous relations for oneToAny relations
-            if (isBidirectional(attribute) && isOneToAny(attribute)) {
-              // update orders for previous oneToAny relations that will be deleted if it has order (oneToMany)
-              if (isAnyToMany(attribute)) {
-                const currentRelsToDelete = await this.createQueryBuilder(joinTable.name)
-                  .select(select)
+              // add inv order value
+              if (hasInverseOrderColumn(attribute)) {
+                const existingRels = await this.createQueryBuilder(joinTable.name)
+                  .select(inverseJoinColumn.name)
                   .where({
-                    [inverseJoinColumn.name]: relIdsToaddOrMove,
-                    [joinColumn.name]: { $ne: id },
+                    [joinColumn.name]: id,
+                    [inverseJoinColumn.name]: { $in: relIdsToaddOrMove },
                   })
                   .where(joinTable.on || {})
+                  .transacting(trx)
                   .execute();
 
-                currentRelsToDelete.sort((a, b) => b[orderColumnName] - a[orderColumnName]);
-
-                for (const relToDelete of currentRelsToDelete) {
-                  if (relToDelete[orderColumnName] !== null) {
-                    await this.createQueryBuilder(joinTable.name)
-                      .decrement(orderColumnName, 1)
-                      .where({
-                        [joinColumn.name]: relToDelete[joinColumn.name],
-                        [orderColumnName]: { $gt: relToDelete[orderColumnName] },
-                      })
-                      .where(joinTable.on || {})
-                      .execute();
-                  }
-                }
+                const nonExistingRelsIds = difference(
+                  relIdsToaddOrMove,
+                  map(inverseJoinColumn.name, existingRels)
+                );
+
+                const maxResults = await db
+                  .getConnection()
+                  .select(inverseJoinColumn.name)
+                  .max(inverseOrderColumnName, { as: 'max' })
+                  .whereIn(inverseJoinColumn.name, nonExistingRelsIds)
+                  .where(joinTable.on || {})
+                  .groupBy(inverseJoinColumn.name)
+                  .from(joinTable.name)
+                  .transacting(trx);
+
+                const maxMap = maxResults.reduce(
+                  (acc, res) => Object.assign(acc, { [res[inverseJoinColumn.name]]: res.max }),
+                  {}
+                );
+
+                insert.forEach((row) => {
+                  row[inverseOrderColumnName] = (maxMap[row[inverseJoinColumn.name]] || 0) + 1;
+                });
+              }
+
+              // insert rows
+              const query = this.createQueryBuilder(joinTable.name)
+                .insert(insert)
+                .onConflict(joinTable.pivotColumns)
+                .transacting(trx);
+
+              if (hasOrderColumn(attribute)) {
+                query.merge([orderColumnName]);
+              } else {
+                query.ignore();
               }
 
-              // delete previous oneToAny relations
-              await this.createQueryBuilder(joinTable.name)
-                .delete()
-                .where({
-                  [inverseJoinColumn.name]: relIdsToaddOrMove,
-                  [joinColumn.name]: { $ne: id },
-                })
-                .where(joinTable.on || {})
-                .execute();
+              await query.execute();
+            }
+
+            // Delete the previous relations for oneToAny relations
+            if (isBidirectional(attribute) && isOneToAny(attribute)) {
+              await deletePreviousOneToAnyRelations({
+                id,
+                attribute,
+                relIdsToadd: relIdsToaddOrMove,
+                db,
+                transaction: trx,
+              });
             }
 
             // Delete the previous relations for anyToOne relations
             if (isBidirectional(attribute) && isAnyToOne(attribute)) {
-              // update orders for previous anyToOne relations that will be deleted if it has order (manyToOne)
-              if (isManyToAny(attribute)) {
-                const currentRelsToDelete = await this.createQueryBuilder(joinTable.name)
-                  .select(select)
-                  .where({
-                    [joinColumn.name]: id,
-                    [inverseJoinColumn.name]: { $notIn: relIdsToaddOrMove },
-                  })
-                  .where(joinTable.on || {})
-                  .execute();
-
-                for (const relToDelete of currentRelsToDelete) {
-                  if (relToDelete[inverseOrderColumnName] !== null) {
-                    await this.createQueryBuilder(joinTable.name)
-                      .decrement(inverseOrderColumnName, 1)
-                      .where({
-                        [inverseJoinColumn.name]: relToDelete[inverseJoinColumn.name],
-                        [inverseOrderColumnName]: { $gt: relToDelete[inverseOrderColumnName] },
-                      })
-                      .where(joinTable.on || {})
-                      .execute();
-                  }
-                }
-              }
-
-              // delete previous oneToAny relations
-              await this.createQueryBuilder(joinTable.name)
-                .delete()
-                .where({
-                  [joinColumn.name]: id,
-                  [inverseJoinColumn.name]: { $notIn: relIdsToaddOrMove },
-                })
-                .where(joinTable.on || {})
-                .execute();
+              await deletePreviousAnyToOneRelations({
+                id,
+                attribute,
+                relIdToadd: relIdsToaddOrMove[0],
+                db,
+                transaction: trx,
+              });
             }
           }
         }
@@ -1168,8 +1005,7 @@ const createEntityManager = (db) => {
      * @param {Metadata} metadata - model metadta
      * @param {ID} id - entity ID
      */
-    // TODO: wrap Transaction
-    async deleteRelations(uid, id) {
+    async deleteRelations(uid, id, { transaction: trx }) {
       const { attributes } = db.metadata.get(uid);
 
       for (const attributeName of Object.keys(attributes)) {
@@ -1198,6 +1034,7 @@ const createEntityManager = (db) => {
             await this.createQueryBuilder(target)
               .update({ [idColumn.name]: null, [typeColumn.name]: null })
               .where({ [idColumn.name]: id, [typeColumn.name]: uid })
+              .transacting(trx)
               .execute();
           } else if (targetAttribute.relation === 'morphToMany') {
             const { joinTable } = targetAttribute;
@@ -1213,6 +1050,7 @@ const createEntityManager = (db) => {
                 ...(joinTable.on || {}),
                 field: attributeName,
               })
+              .transacting(trx)
               .execute();
           }
 
@@ -1241,6 +1079,7 @@ const createEntityManager = (db) => {
               [joinColumn.name]: id,
               ...(joinTable.on || {}),
             })
+            .transacting(trx)
             .execute();
 
           continue;
@@ -1265,56 +1104,12 @@ const createEntityManager = (db) => {
           await this.createQueryBuilder(target)
             .where({ [attribute.joinColumn.referencedColumn]: id })
             .update({ [attribute.joinColumn.referencedColumn]: null })
+            .transacting(trx)
             .execute();
         }
 
         if (attribute.joinTable) {
-          const { joinTable } = attribute;
-          const { joinColumn, inverseJoinColumn, inverseOrderColumnName } = joinTable;
-
-          // INVERSE ORDER UPDATE
-          if (isBidirectional(attribute) && isManyToAny(attribute)) {
-            let lastId = 0;
-            let done = false;
-            const batchSize = 100;
-            while (!done) {
-              const relsToDelete = await this.createQueryBuilder(joinTable.name)
-                .select(inverseJoinColumn.name, inverseOrderColumnName)
-                .where({
-                  [joinColumn.name]: id,
-                  id: { $gt: lastId },
-                })
-                .where(joinTable.on || {})
-                .orderBy('id')
-                .limit(batchSize)
-                .execute();
-              done = relsToDelete.length < batchSize;
-              lastId = relsToDelete[relsToDelete.length - 1]?.id;
-
-              const updateInverseOrderPromises = [];
-              for (const relToDelete of relsToDelete) {
-                if (relToDelete[inverseOrderColumnName] !== null) {
-                  const updatePromise = this.createQueryBuilder(joinTable.name)
-                    .decrement(inverseOrderColumnName, 1)
-                    .where({
-                      [inverseJoinColumn.name]: relToDelete[inverseJoinColumn.name],
-                      [inverseOrderColumnName]: { $gt: relToDelete[inverseOrderColumnName] },
-                    })
-                    .where(joinTable.on || {})
-                    .execute();
-                  updateInverseOrderPromises.push(updatePromise);
-                }
-              }
-
-              await Promise.all(updateInverseOrderPromises);
-            }
-          }
-
-          await this.createQueryBuilder(joinTable.name)
-            .delete()
-            .where({ [joinColumn.name]: id })
-            .where(joinTable.on || {})
-            .execute();
+          await deleteRelations({ id, attribute, db, relIdsToDelete: 'all', transaction: trx });
         }
       }
     },