@strapi/database 4.4.0-rc.0 → 4.5.0-alpha.0

package/lib/entity-manager/index.js

@@ -12,19 +12,35 @@ const {
   isEmpty,
   isArray,
   isNull,
+  uniqBy,
+  differenceBy,
+  groupBy,
 } = 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,
+  isOneToAny,
+  isManyToAny,
+  isAnyToOne,
+  isAnyToMany,
+} = require('../metadata/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)
     .filter((datum) => !isNil(datum))
     .map((datum) => {
@@ -466,17 +482,56 @@ const createEntityManager = (db) => {
           // need to set the column on the target
 
           const { joinTable } = attribute;
-          const { joinColumn, inverseJoinColumn } = joinTable;
+          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 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();
 
-          if (isOneToAny(attribute) && isBidirectional(attribute)) {
+              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]: castArray(data[attributeName]) })
+              .where({ [inverseJoinColumn.name]: relIdsToadd })
               .where(joinTable.on || {})
               .execute();
           }
 
-          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,11 +540,38 @@ const createEntityManager = (db) => {
             };
           });
 
-          // if there is nothing to insert
+          // add order value when relevant
+          if (isAnyToMany(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();
+
+                maxMap[relId] = max;
+              })
+            );
+
+            insert.forEach((rel) => {
+              rel[inverseOrderColumnName] = maxMap[rel[inverseJoinColumn.name]] + 1;
+            });
+          }
+
           if (insert.length === 0) {
             continue;
           }
 
+          // insert new relations
           await this.createQueryBuilder(joinTable.name).insert(insert).execute();
         }
       }
@@ -644,42 +726,434 @@ const createEntityManager = (db) => {
 
         if (attribute.joinTable) {
           const { joinTable } = attribute;
-          const { joinColumn, inverseJoinColumn } = joinTable;
+          const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } =
+            joinTable;
+          const select = [joinColumn.name, inverseJoinColumn.name];
+          if (isAnyToMany(attribute)) {
+            select.push(orderColumnName);
+          }
+          if (isBidirectional(attribute) && isManyToAny(attribute)) {
+            select.push(inverseOrderColumnName);
+          }
 
-          // clear previous associations in the joinTable
-          await this.createQueryBuilder(joinTable.name)
-            .delete()
-            .where({ [joinColumn.name]: id })
-            .where(joinTable.on || {})
-            .execute();
+          // 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);
+              }
+            }
 
-          if (
-            isBidirectional(attribute) &&
-            ['oneToOne', 'oneToMany'].includes(attribute.relation)
-          ) {
             await this.createQueryBuilder(joinTable.name)
               .delete()
-              .where({ [inverseJoinColumn.name]: toIds(data[attributeName]) })
+              .where({ [joinColumn.name]: id })
               .where(joinTable.on || {})
               .execute();
-          }
+          } else {
+            const cleanRelationData = toAssocs(data[attributeName]);
+            const isPartialUpdate =
+              has('connect', cleanRelationData) || has('disconnect', 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 = [];
+              }
+              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)
+                  .select(select)
+                  .where({
+                    [joinColumn.name]: id,
+                    [inverseJoinColumn.name]: { $in: relIdsToDelete },
+                  })
+                  .where(joinTable.on || {})
+                  .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();
 
-          if (!isNull(data[attributeName])) {
-            const insert = toAssocs(data[attributeName]).map((data) => {
-              return {
-                [joinColumn.name]: id,
-                [inverseJoinColumn.name]: data.id,
-                ...(joinTable.on || {}),
-                ...(data.__pivot || {}),
-              };
-            });
+              // 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);
+
+              if (isAnyToMany(attribute)) {
+                max = (
+                  await this.createQueryBuilder(joinTable.name)
+                    .max(orderColumnName)
+                    .where({ [joinColumn.name]: id })
+                    .where(joinTable.on || {})
+                    .first()
+                    .execute()
+                ).max;
+              }
+
+              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;
+                      }
+                    });
+                  }
+
+                  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;
+                }
+              }
+            } else {
+              // 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);
+                  }
+                }
+              }
+
+              // DELETE
+              await this.createQueryBuilder(joinTable.name)
+                .delete()
+                .where({
+                  [joinColumn.name]: id,
+                  [inverseJoinColumn.name]: { $notIn: relIdsToaddOrMove },
+                })
+                .where(joinTable.on || {})
+                .execute();
 
-            // if there is nothing to insert
-            if (insert.length === 0) {
-              continue;
+              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;
+              }
+            }
+
+            // 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]: relIdsToaddOrMove,
+                    [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]: relIdsToaddOrMove,
+                  [joinColumn.name]: { $ne: id },
+                })
+                .where(joinTable.on || {})
+                .execute();
             }
 
-            await this.createQueryBuilder(joinTable.name).insert(insert).execute();
+            // 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();
+            }
           }
         }
       }
@@ -796,7 +1270,45 @@ const createEntityManager = (db) => {
 
         if (attribute.joinTable) {
           const { joinTable } = attribute;
-          const { joinColumn } = joinTable;
+          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()

package/lib/metadata/index.js

@@ -208,6 +208,7 @@ const createComponent = (attributeName, attribute, meta) => {
       orderBy: {
         order: 'asc',
       },
+      ...(attribute.repeatable === true ? { orderColumnName: 'order' } : {}),
     },
   });
 };

package/lib/metadata/relations.js

@@ -10,6 +10,9 @@ const hasInversedBy = _.has('inversedBy');
 const hasMappedBy = _.has('mappedBy');
 
 const isOneToAny = (attribute) => ['oneToOne', 'oneToMany'].includes(attribute.relation);
+const isManyToAny = (attribute) => ['manyToMany', 'manyToOne'].includes(attribute.relation);
+const isAnyToOne = (attribute) => ['oneToOne', 'manyToOne'].includes(attribute.relation);
+const isAnyToMany = (attribute) => ['oneToMany', 'manyToMany'].includes(attribute.relation);
 const isBidirectional = (attribute) => hasInversedBy(attribute) || hasMappedBy(attribute);
 const isOwner = (attribute) => !isBidirectional(attribute) || hasInversedBy(attribute);
 const shouldUseJoinTable = (attribute) => attribute.useJoinTable !== false;
@@ -398,12 +401,20 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   const joinColumnName = _.snakeCase(`${meta.singularName}_id`);
   let inverseJoinColumnName = _.snakeCase(`${targetMeta.singularName}_id`);
 
-  // if relation is slef referencing
+  // if relation is self referencing
   if (joinColumnName === inverseJoinColumnName) {
     inverseJoinColumnName = `inv_${inverseJoinColumnName}`;
   }
 
-  metadata.add({
+  const orderColumnName = _.snakeCase(`${meta.singularName}_order`);
+  let inverseOrderColumnName = _.snakeCase(`${targetMeta.singularName}_order`);
+
+  // if relation is self referencing
+  if (attribute.relation === 'manyToMany' && joinColumnName === inverseJoinColumnName) {
+    inverseOrderColumnName = `inv_${inverseOrderColumnName}`;
+  }
+
+  const metadataSchema = {
     uid: joinTableName,
     tableName: joinTableName,
     attributes: {
@@ -450,7 +461,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         onDelete: 'CASCADE',
       },
     ],
-  });
+  };
 
   const joinTable = {
     name: joinTableName,
@@ -464,6 +475,43 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
     },
   };
 
+  // order
+  if (isAnyToMany(attribute)) {
+    metadataSchema.attributes[orderColumnName] = {
+      type: 'integer',
+      column: {
+        unsigned: true,
+        defaultTo: null,
+      },
+    };
+    metadataSchema.indexes.push({
+      name: `${joinTableName}_order_fk`,
+      columns: [orderColumnName],
+    });
+    joinTable.orderColumnName = orderColumnName;
+    joinTable.orderBy = { [orderColumnName]: 'asc' };
+  }
+
+  // inv order
+  if (isBidirectional(attribute) && isManyToAny(attribute)) {
+    metadataSchema.attributes[inverseOrderColumnName] = {
+      type: 'integer',
+      column: {
+        unsigned: true,
+        defaultTo: null,
+      },
+    };
+
+    metadataSchema.indexes.push({
+      name: `${joinTableName}_order_inv_fk`,
+      columns: [inverseOrderColumnName],
+    });
+
+    joinTable.inverseOrderColumnName = inverseOrderColumnName;
+  }
+
+  metadata.add(metadataSchema);
+
   attribute.joinTable = joinTable;
 
   if (isBidirectional(attribute)) {
@@ -480,6 +528,14 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       joinColumn: joinTable.inverseJoinColumn,
       inverseJoinColumn: joinTable.joinColumn,
     };
+
+    if (isManyToAny(attribute)) {
+      inverseAttribute.joinTable.orderColumnName = inverseOrderColumnName;
+      inverseAttribute.joinTable.orderBy = { [inverseOrderColumnName]: 'asc' };
+    }
+    if (isAnyToMany(attribute)) {
+      inverseAttribute.joinTable.inverseOrderColumnName = orderColumnName;
+    }
   }
 };
 
@@ -488,4 +544,7 @@ module.exports = {
 
   isBidirectional,
   isOneToAny,
+  isManyToAny,
+  isAnyToOne,
+  isAnyToMany,
 };

package/lib/query/helpers/join.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const createPivotJoin = (qb, joinTable, alias, tragetMeta) => {
+const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
+  const { qb } = ctx;
   const joinAlias = qb.getAlias();
   qb.join({
     alias: joinAlias,
@@ -11,10 +12,10 @@ const createPivotJoin = (qb, joinTable, alias, tragetMeta) => {
     on: joinTable.on,
   });
 
-  const subAlias = qb.getAlias();
+  const subAlias = refAlias || qb.getAlias();
   qb.join({
     alias: subAlias,
-    referencedTable: tragetMeta.tableName,
+    referencedTable: targetMeta.tableName,
     referencedColumn: joinTable.inverseJoinColumn.referencedColumn,
     rootColumn: joinTable.inverseJoinColumn.name,
     rootTable: joinAlias,
@@ -23,22 +24,22 @@ const createPivotJoin = (qb, joinTable, alias, tragetMeta) => {
   return subAlias;
 };
 
-const createJoin = (ctx, { alias, attributeName, attribute }) => {
+const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
   const { db, qb } = ctx;
 
   if (attribute.type !== 'relation') {
     throw new Error(`Cannot join on non relational field ${attributeName}`);
   }
 
-  const tragetMeta = db.metadata.get(attribute.target);
+  const targetMeta = db.metadata.get(attribute.target);
 
   const { joinColumn } = attribute;
 
   if (joinColumn) {
-    const subAlias = qb.getAlias();
+    const subAlias = refAlias || qb.getAlias();
     qb.join({
       alias: subAlias,
-      referencedTable: tragetMeta.tableName,
+      referencedTable: targetMeta.tableName,
       referencedColumn: joinColumn.referencedColumn,
       rootColumn: joinColumn.name,
       rootTable: alias,
@@ -48,7 +49,7 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
 
   const { joinTable } = attribute;
   if (joinTable) {
-    return createPivotJoin(qb, joinTable, alias, tragetMeta);
+    return createPivotJoin(ctx, { alias, refAlias, joinTable, targetMeta });
   }
 
   return alias;

package/lib/query/helpers/where.js

@@ -6,6 +6,7 @@ const types = require('../../types');
 const { createField } = require('../../fields');
 const { createJoin } = require('./join');
 const { toColumnName } = require('./transform');
+const { isKnexQuery } = require('../../utils/knex');
 
 const GROUP_OPERATORS = ['$and', '$or'];
 const OPERATORS = [
@@ -206,12 +207,12 @@ const applyOperator = (qb, column, operator, value) => {
     }
 
     case '$in': {
-      qb.whereIn(column, _.castArray(value));
+      qb.whereIn(column, isKnexQuery(value) ? value : _.castArray(value));
       break;
     }
 
     case '$notIn': {
-      qb.whereNotIn(column, _.castArray(value));
+      qb.whereNotIn(column, isKnexQuery(value) ? value : _.castArray(value));
       break;
     }
 

package/lib/query/query-builder.js

@@ -4,33 +4,38 @@ const _ = require('lodash/fp');
 
 const helpers = require('./helpers');
 
-const createQueryBuilder = (uid, db) => {
+const createQueryBuilder = (uid, db, initialState = {}) => {
   const meta = db.metadata.get(uid);
   const { tableName } = meta;
 
-  const state = {
-    type: 'select',
-    select: [],
-    count: null,
-    max: null,
-    first: false,
-    data: null,
-    where: [],
-    joins: [],
-    populate: null,
-    limit: null,
-    offset: null,
-    transaction: null,
-    forUpdate: false,
-    orderBy: [],
-    groupBy: [],
-  };
+  const state = _.defaults(
+    {
+      type: 'select',
+      select: [],
+      count: null,
+      max: null,
+      first: false,
+      data: null,
+      where: [],
+      joins: [],
+      populate: null,
+      limit: null,
+      offset: null,
+      transaction: null,
+      forUpdate: false,
+      orderBy: [],
+      groupBy: [],
+      increments: [],
+      decrements: [],
+      aliasCounter: 0,
+    },
+    initialState
+  );
 
-  let counter = 0;
   const getAlias = () => {
-    const alias = `t${counter}`;
+    const alias = `t${state.aliasCounter}`;
 
-    counter += 1;
+    state.aliasCounter += 1;
 
     return alias;
   };
@@ -40,6 +45,10 @@ const createQueryBuilder = (uid, db) => {
     getAlias,
     state,
 
+    clone() {
+      return createQueryBuilder(uid, db, state);
+    },
+
     select(args) {
       state.type = 'select';
       state.select = _.uniq(_.castArray(args));
@@ -77,6 +86,20 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
+    increment(column, amount = 1) {
+      state.type = 'update';
+      state.increments.push({ column, amount });
+
+      return this;
+    },
+
+    decrement(column, amount = 1) {
+      state.type = 'update';
+      state.decrements.push({ column, amount });
+
+      return this;
+    },
+
     count(count = 'id') {
       state.type = 'count';
       state.count = count;
@@ -195,7 +218,24 @@ const createQueryBuilder = (uid, db) => {
     },
 
     join(join) {
-      state.joins.push(join);
+      if (!join.targetField) {
+        state.joins.push(join);
+        return this;
+      }
+
+      const model = db.metadata.get(uid);
+      const attribute = model.attributes[join.targetField];
+
+      helpers.createJoin(
+        { db, qb: this },
+        {
+          alias: this.alias,
+          refAlias: join.alias,
+          attributeName: join.targetField,
+          attribute,
+        }
+      );
+
       return this;
     },
 
@@ -325,7 +365,9 @@ const createQueryBuilder = (uid, db) => {
           break;
         }
         case 'update': {
-          qb.update(state.data);
+          if (state.data) {
+            qb.update(state.data);
+          }
           break;
         }
         case 'delete': {
@@ -350,6 +392,14 @@ const createQueryBuilder = (uid, db) => {
         qb.forUpdate();
       }
 
+      if (!_.isEmpty(state.increments)) {
+        state.increments.forEach((incr) => qb.increment(incr.column, incr.amount));
+      }
+
+      if (!_.isEmpty(state.decrements)) {
+        state.decrements.forEach((decr) => qb.decrement(decr.column, decr.amount));
+      }
+
       if (state.limit) {
         qb.limit(state.limit);
       }

package/lib/tests/knex-utils.test.e2e.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { createStrapiInstance } = require('../../../../../test/helpers/strapi');
+const { isKnexQuery } = require('../utils/knex');
+
+let strapi;
+
+describe('knex', () => {
+  beforeAll(async () => {
+    strapi = await createStrapiInstance();
+  });
+
+  afterAll(async () => {
+    await strapi.destroy();
+  });
+
+  describe('isKnexQuery', () => {
+    test('knex query: true', () => {
+      const res = isKnexQuery(strapi.db.connection('strapi_core_store_settings'));
+      expect(res).toBe(true);
+    });
+
+    test('knex raw: true', () => {
+      const res = isKnexQuery(strapi.db.connection.raw('SELECT * FROM strapi_core_store_settings'));
+      expect(res).toBe(true);
+    });
+
+    test.each([[''], [{}], [[]], [2], [new Date()]])('%s: false', (value) => {
+      const res = isKnexQuery(value);
+      expect(res).toBe(false);
+    });
+  });
+});

package/lib/utils/knex.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const KnexBuilder = require('knex/lib/query/querybuilder');
+const KnexRaw = require('knex/lib/raw');
+
+const isKnexQuery = (value) => {
+  return value instanceof KnexBuilder || value instanceof KnexRaw;
+};
+
+module.exports = {
+  isKnexQuery,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.4.0-rc.0",
+  "version": "4.5.0-alpha.0",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -42,5 +42,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "57635b60c9a7815830734d85fe76df3ce8ed5898"
+  "gitHead": "c9a98c4dbcf3c4f2a449f8d96e7cbe4cd9b1e0f5"
 }