@strapi/database 4.4.3 → 4.5.0-beta.0

package/lib/entity-manager/index.js

@@ -12,20 +12,38 @@ const {
   isEmpty,
   isArray,
   isNull,
+  uniqWith,
+  isEqual,
+  differenceWith,
+  isNumber,
+  map,
+  difference,
 } = require('lodash/fp');
 const types = require('../types');
 const { createField } = require('../fields');
 const { createQueryBuilder } = require('../query');
 const { createRepository } = require('./entity-repository');
-const { isBidirectional, isOneToAny } = require('../metadata/relations');
 const { deleteRelatedMorphOneRelationsAfterMorphToManyUpdate } = require('./morph-relations');
+const {
+  isBidirectional,
+  isAnyToOne,
+  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) => {
-  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
@@ -40,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 } = {}) => {
@@ -173,12 +211,24 @@ const createEntityManager = (db) => {
       }
 
       const dataToInsert = processData(metadata, data, { withDefaults: true });
+      let id;
 
-      const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
+      const trx = await strapi.db.transaction();
+      try {
+        const res = await this.createQueryBuilder(uid)
+          .insert(dataToInsert)
+          .transacting(trx)
+          .execute();
 
-      const id = res[0].id || res[0];
+        id = res[0].id || res[0];
 
-      await this.attachRelations(uid, id, data);
+        await this.attachRelations(uid, id, data, { transaction: trx });
+
+        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 ?
@@ -243,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, {
@@ -310,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);
 
@@ -342,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)) {
@@ -355,6 +424,8 @@ const createEntityManager = (db) => {
           continue;
         }
 
+        const cleanRelationData = toAssocs(data[attributeName]);
+
         if (attribute.relation === 'morphOne' || attribute.relation === 'morphMany') {
           const { target, morphBy } = attribute;
 
@@ -364,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;
@@ -374,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,
@@ -386,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;
@@ -403,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();
           }
 
@@ -449,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();
         }
 
@@ -466,17 +547,24 @@ const createEntityManager = (db) => {
           // need to set the column on the target
 
           const { joinTable } = attribute;
-          const { joinColumn, inverseJoinColumn } = joinTable;
-
-          if (isOneToAny(attribute) && isBidirectional(attribute)) {
-            await this.createQueryBuilder(joinTable.name)
-              .delete()
-              .where({ [inverseJoinColumn.name]: castArray(data[attributeName]) })
-              .where(joinTable.on || {})
-              .execute();
+          const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } =
+            joinTable;
+
+          const relsToAdd = cleanRelationData.set || cleanRelationData.connect;
+          const relIdsToadd = toIds(relsToAdd);
+
+          if (isBidirectional(attribute) && isOneToAny(attribute)) {
+            await deletePreviousOneToAnyRelations({
+              id,
+              attribute,
+              relIdsToadd,
+              db,
+              transaction: trx,
+            });
           }
 
-          const insert = toAssocs(data[attributeName]).map((data) => {
+          // prepare new relations to insert
+          const insert = relsToAdd.map((data) => {
             return {
               [joinColumn.name]: id,
               [inverseJoinColumn.name]: data.id,
@@ -485,12 +573,40 @@ const createEntityManager = (db) => {
             };
           });
 
-          // if there is nothing to insert
+          // add order value
+          if (hasOrderColumn(attribute)) {
+            insert.forEach((rel, idx) => {
+              rel[orderColumnName] = idx + 1;
+            });
+          }
+          // 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);
+
+            const maxMap = maxResults.reduce(
+              (acc, res) => Object.assign(acc, { [res[inverseJoinColumn.name]]: res.max }),
+              {}
+            );
+
+            insert.forEach((rel) => {
+              rel[inverseOrderColumnName] = (maxMap[rel[inverseJoinColumn.name]] || 0) + 1;
+            });
+          }
+
           if (insert.length === 0) {
             continue;
           }
 
-          await this.createQueryBuilder(joinTable.name).insert(insert).execute();
+          // insert new relations
+          await this.createQueryBuilder(joinTable.name).insert(insert).transacting(trx).execute();
         }
       }
     },
@@ -504,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)) {
@@ -514,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;
@@ -529,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') {
@@ -551,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,
@@ -563,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;
@@ -590,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;
         }
@@ -631,55 +754,243 @@ 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();
           }
         }
 
         if (attribute.joinTable) {
           const { joinTable } = attribute;
-          const { joinColumn, inverseJoinColumn } = joinTable;
-
-          // clear previous associations in the joinTable
-          await this.createQueryBuilder(joinTable.name)
-            .delete()
-            .where({ [joinColumn.name]: id })
-            .where(joinTable.on || {})
-            .execute();
-
-          if (
-            isBidirectional(attribute) &&
-            ['oneToOne', 'oneToMany'].includes(attribute.relation)
-          ) {
-            await this.createQueryBuilder(joinTable.name)
-              .delete()
-              .where({ [inverseJoinColumn.name]: toIds(data[attributeName]) })
-              .where(joinTable.on || {})
-              .execute();
+          const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } =
+            joinTable;
+          const select = [joinColumn.name, inverseJoinColumn.name];
+          if (hasOrderColumn(attribute)) {
+            select.push(orderColumnName);
+          }
+          if (hasInverseOrderColumn(attribute)) {
+            select.push(inverseOrderColumnName);
           }
 
-          if (!isNull(data[attributeName])) {
-            const insert = toAssocs(data[attributeName]).map((data) => {
-              return {
+          // only delete relations
+          if (isNull(cleanRelationData.set)) {
+            await deleteRelations({ id, attribute, db, relIdsToDelete: 'all', transaction: trx });
+          } else {
+            const isPartialUpdate = !has('set', cleanRelationData);
+            let relIdsToaddOrMove;
+
+            if (isPartialUpdate) {
+              if (isAnyToOne(attribute)) {
+                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;
+              }
+
+              // 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: relIdsToaddOrMove },
+                  })
+                  .where(joinTable.on || {})
+                  .transacting(trx)
+                  .execute();
+              }
+
+              // prepare relations to insert
+              const insert = cleanRelationData.connect.map((relToAdd) => ({
                 [joinColumn.name]: id,
-                [inverseJoinColumn.name]: data.id,
+                [inverseJoinColumn.name]: relToAdd.id,
                 ...(joinTable.on || {}),
-                ...(data.__pivot || {}),
-              };
-            });
+                ...(relToAdd.__pivot || {}),
+              }));
+
+              // 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;
+                });
+              }
+
+              // 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;
+                });
+              }
+
+              // 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
+              relIdsToaddOrMove = toIds(cleanRelationData.set);
+              await deleteRelations({
+                id,
+                attribute,
+                db,
+                relIdsToDelete: 'all',
+                relIdsToNotDelete: relIdsToaddOrMove,
+                transaction: trx,
+              });
+
+              if (isEmpty(cleanRelationData.set)) {
+                continue;
+              }
+
+              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;
+                });
+              }
+
+              // add inv order value
+              if (hasInverseOrderColumn(attribute)) {
+                const existingRels = await this.createQueryBuilder(joinTable.name)
+                  .select(inverseJoinColumn.name)
+                  .where({
+                    [joinColumn.name]: id,
+                    [inverseJoinColumn.name]: { $in: relIdsToaddOrMove },
+                  })
+                  .where(joinTable.on || {})
+                  .transacting(trx)
+                  .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();
+              }
+
+              await query.execute();
+            }
 
-            // if there is nothing to insert
-            if (insert.length === 0) {
-              continue;
+            // Delete the previous relations for oneToAny relations
+            if (isBidirectional(attribute) && isOneToAny(attribute)) {
+              await deletePreviousOneToAnyRelations({
+                id,
+                attribute,
+                relIdsToadd: relIdsToaddOrMove,
+                db,
+                transaction: trx,
+              });
             }
 
-            await this.createQueryBuilder(joinTable.name).insert(insert).execute();
+            // Delete the previous relations for anyToOne relations
+            if (isBidirectional(attribute) && isAnyToOne(attribute)) {
+              await deletePreviousAnyToOneRelations({
+                id,
+                attribute,
+                relIdToadd: relIdsToaddOrMove[0],
+                db,
+                transaction: trx,
+              });
+            }
           }
         }
       }
@@ -694,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)) {
@@ -724,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;
@@ -739,6 +1050,7 @@ const createEntityManager = (db) => {
                 ...(joinTable.on || {}),
                 field: attributeName,
               })
+              .transacting(trx)
               .execute();
           }
 
@@ -767,6 +1079,7 @@ const createEntityManager = (db) => {
               [joinColumn.name]: id,
               ...(joinTable.on || {}),
             })
+            .transacting(trx)
             .execute();
 
           continue;
@@ -791,18 +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 } = joinTable;
-
-          await this.createQueryBuilder(joinTable.name)
-            .delete()
-            .where({ [joinColumn.name]: id })
-            .where(joinTable.on || {})
-            .execute();
+          await deleteRelations({ id, attribute, db, relIdsToDelete: 'all', transaction: trx });
         }
       }
     },