@strapi/database 5.2.0 → 5.4.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import path from "path";
 import fse from "fs-extra";
 import createDebug from "debug";
-import _, { isNil, castArray, prop, omit, isInteger, snakeCase, partition, sumBy, cloneDeep, toString, toNumber, isString as isString$1, padCharsEnd, isArray, isPlainObject, isFinite, groupBy, pipe, mapValues, map, isEmpty, maxBy, pick, has, uniqBy, isNull, differenceWith, isEqual, compact, difference, isObject, isNumber as isNumber$1, isUndefined, uniqWith } from "lodash/fp";
+import _, { isNil, castArray, prop, omit, isInteger, snakeCase, partition, sumBy, cloneDeep, toString, toNumber, isString as isString$1, padCharsEnd, isArray, isPlainObject, isFinite, curry, groupBy, pipe, mapValues, map, isEmpty, maxBy, pick, has, uniqBy, isNull, compact, differenceWith, isEqual, difference, isObject, isNumber as isNumber$1, isUndefined, uniqWith } from "lodash/fp";
 import crypto from "crypto";
 import crypto$1 from "node:crypto";
 import * as dateFns from "date-fns";
@@ -4878,6 +4878,25 @@ const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate = async (rows, {
     await createQueryBuilder(joinTable.name, db).delete().where({ $or: orWhere }).transacting(trx).execute();
   }
 };
+const encodePolymorphicId = (id, __type) => {
+  return `${id}:::${__type}`;
+};
+const encodePolymorphicRelation = curry(({ idColumn, typeColumn }, relation) => {
+  const newRelation = {
+    ...relation,
+    [idColumn]: encodePolymorphicId(relation[idColumn], relation[typeColumn])
+  };
+  if (relation.position) {
+    const { before, after } = relation.position;
+    const __type = relation.position.__type || relation.__type;
+    newRelation.position = { ...relation.position };
+    if (before)
+      newRelation.position.before = encodePolymorphicId(before, __type);
+    if (after)
+      newRelation.position.after = encodePolymorphicId(after, __type);
+  }
+  return newRelation;
+});
 const getDocumentSiblingIdsQuery = (tableName, id) => {
   const models = Array.from(strapi.db.metadata.values());
   const isContentType = models.find((model) => {
@@ -5064,7 +5083,10 @@ const sortConnectArray = (connectArr, initialArr = [], strictSort = true) => {
       if (!adjacentRelId || !relationInInitialArray[adjacentRelId] && !mapper[adjacentRelId]) {
         needsSorting = true;
       }
-      if (mapper[relation.id]) {
+      const existingRelation = mapper[relation.id];
+      const hasNoComponent = existingRelation && !("__component" in existingRelation);
+      const hasSameComponent = existingRelation && existingRelation.__component === relation.__component;
+      if (existingRelation && (hasNoComponent || hasSameComponent)) {
         throw new InvalidRelationError(
           `The relation with id ${relation.id} is already connected. You cannot connect the same relation twice.`
         );
@@ -5205,7 +5227,7 @@ const toId = (value) => {
   if (isValidId(value)) {
     return value;
   }
-  throw new Error(`Invalid id, expected a string or integer, got ${value}`);
+  throw new Error(`Invalid id, expected a string or integer, got ${JSON.stringify(value)}`);
 };
 const toIds = (value) => castArray(value || []).map(toId);
 const isValidId = (value) => isString$1(value) || isInteger(value);
@@ -5240,7 +5262,8 @@ const toAssocs = (data) => {
     connect: toIdArray(data?.connect).map((elm) => ({
       id: elm.id,
       position: elm.position ? elm.position : { end: true },
-      __pivot: elm.__pivot ?? {}
+      __pivot: elm.__pivot ?? {},
+      __type: elm.__type
     })),
     disconnect: toIdArray(data?.disconnect)
   };
@@ -5515,23 +5538,33 @@ const createEntityManager = (db) => {
           const { joinTable } = attribute;
           const { joinColumn, morphColumn } = joinTable;
           const { idColumn, typeColumn, typeField = "__type" } = morphColumn;
-          if (isEmpty(cleanRelationData.set)) {
+          if (isEmpty(cleanRelationData.set) && isEmpty(cleanRelationData.connect)) {
             continue;
           }
-          const rows = cleanRelationData.set?.map((data2, idx) => ({
+          const dataset = cleanRelationData.set || cleanRelationData.connect || [];
+          const rows = dataset.map((data2, idx) => ({
             [joinColumn.name]: id,
             [idColumn.name]: data2.id,
             [typeColumn.name]: data2[typeField],
             ..."on" in joinTable && joinTable.on || {},
             ...data2.__pivot || {},
             order: idx + 1
-          })) ?? [];
-          await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
-            uid,
-            attributeName,
-            joinTable,
-            db,
-            transaction: trx
+          }));
+          const orderMap = relationsOrderer(
+            [],
+            morphColumn.idColumn.name,
+            "order",
+            true
+            // Always make a strict connect when inserting
+          ).connect(
+            // Merge id & __type to get a single id key
+            dataset.map(encodePolymorphicRelation({ idColumn: "id", typeColumn: "__type" }))
+          ).get().reduce((acc, rel, idx) => ({ ...acc, [rel.id]: idx }), {});
+          rows.forEach((row) => {
+            const rowId = row[morphColumn.idColumn.name];
+            const rowType = row[morphColumn.typeColumn.name];
+            const encodedId = encodePolymorphicId(rowId, rowType);
+            row.order = orderMap[encodedId];
           });
           await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
           continue;
@@ -5631,25 +5664,67 @@ const createEntityManager = (db) => {
             const { joinTable } = targetAttribute;
             const { joinColumn, morphColumn } = joinTable;
             const { idColumn, typeColumn } = morphColumn;
+            const hasSet = !isEmpty(cleanRelationData.set);
+            const hasConnect = !isEmpty(cleanRelationData.connect);
+            const hasDisconnect = !isEmpty(cleanRelationData.disconnect);
+            if (!hasSet && (hasConnect || hasDisconnect)) {
+              const idsToDelete = [
+                ...cleanRelationData.disconnect || [],
+                ...cleanRelationData.connect || []
+              ];
+              if (!isEmpty(idsToDelete)) {
+                const where = {
+                  $or: idsToDelete.map((item) => {
+                    return {
+                      [idColumn.name]: id,
+                      [typeColumn.name]: uid,
+                      [joinColumn.name]: item.id,
+                      ...joinTable.on || {},
+                      field: attributeName
+                    };
+                  })
+                };
+                await this.createQueryBuilder(joinTable.name).delete().where(where).transacting(trx).execute();
+              }
+              if (hasConnect) {
+                const start = await this.createQueryBuilder(joinTable.name).where({
+                  [idColumn.name]: id,
+                  [typeColumn.name]: uid,
+                  ...joinTable.on || {},
+                  ...data.__pivot || {}
+                }).max("order").first().transacting(trx).execute();
+                const startOrder = start?.max || 0;
+                const rows = (cleanRelationData.connect ?? []).map((data2, idx) => ({
+                  [joinColumn.name]: data2.id,
+                  [idColumn.name]: id,
+                  [typeColumn.name]: uid,
+                  ...joinTable.on || {},
+                  ...data2.__pivot || {},
+                  order: startOrder + idx + 1,
+                  field: attributeName
+                }));
+                await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+              }
+              continue;
+            }
             await this.createQueryBuilder(joinTable.name).delete().where({
               [idColumn.name]: id,
               [typeColumn.name]: uid,
               ...joinTable.on || {},
               field: attributeName
             }).transacting(trx).execute();
-            if (isEmpty(cleanRelationData.set)) {
-              continue;
+            if (hasSet) {
+              const rows = (cleanRelationData.set ?? []).map((data2, idx) => ({
+                [joinColumn.name]: data2.id,
+                [idColumn.name]: id,
+                [typeColumn.name]: uid,
+                ...joinTable.on || {},
+                ...data2.__pivot || {},
+                order: idx + 1,
+                field: attributeName
+              }));
+              await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
             }
-            const rows = cleanRelationData.set?.map((data2, idx) => ({
-              [joinColumn.name]: data2.id,
-              [idColumn.name]: id,
-              [typeColumn.name]: uid,
-              ...joinTable.on || {},
-              ...data2.__pivot || {},
-              order: idx + 1,
-              field: attributeName
-            }));
-            await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
           }
           continue;
         }
@@ -5660,29 +5735,129 @@ const createEntityManager = (db) => {
           const { joinTable } = attribute;
           const { joinColumn, morphColumn } = joinTable;
           const { idColumn, typeColumn, typeField = "__type" } = morphColumn;
-          await this.createQueryBuilder(joinTable.name).delete().where({
-            [joinColumn.name]: id,
-            ...joinTable.on || {}
-          }).transacting(trx).execute();
-          if (isEmpty(cleanRelationData.set)) {
+          const hasSet = !isEmpty(cleanRelationData.set);
+          const hasConnect = !isEmpty(cleanRelationData.connect);
+          const hasDisconnect = !isEmpty(cleanRelationData.disconnect);
+          if (!hasSet && (hasConnect || hasDisconnect)) {
+            const idsToDelete = [
+              ...cleanRelationData.disconnect || [],
+              ...cleanRelationData.connect || []
+            ];
+            const rowsToDelete = [
+              ...(cleanRelationData.disconnect ?? []).map((data2, idx) => ({
+                [joinColumn.name]: id,
+                [idColumn.name]: data2.id,
+                [typeColumn.name]: data2[typeField],
+                ..."on" in joinTable && joinTable.on || {},
+                ...data2.__pivot || {},
+                order: idx + 1
+              })),
+              ...(cleanRelationData.connect ?? []).map((data2, idx) => ({
+                [joinColumn.name]: id,
+                [idColumn.name]: data2.id,
+                // @ts-expect-error TODO
+                [typeColumn.name]: data2[typeField],
+                ..."on" in joinTable && joinTable.on || {},
+                ...data2.__pivot || {},
+                order: idx + 1
+              }))
+            ];
+            const adjacentRelations = await this.createQueryBuilder(joinTable.name).where({
+              $or: [
+                {
+                  [joinColumn.name]: id,
+                  [idColumn.name]: {
+                    $in: compact(
+                      cleanRelationData.connect?.map(
+                        (r) => r.position?.after || r.position?.before
+                      )
+                    )
+                  }
+                },
+                {
+                  [joinColumn.name]: id,
+                  order: this.createQueryBuilder(joinTable.name).max("order").where({ [joinColumn.name]: id }).where(joinTable.on || {}).transacting(trx).getKnexQuery()
+                }
+              ]
+            }).where(joinTable.on || {}).transacting(trx).execute();
+            if (!isEmpty(idsToDelete)) {
+              const where = {
+                $or: idsToDelete.map((item) => {
+                  return {
+                    [idColumn.name]: item.id,
+                    [typeColumn.name]: item[typeField],
+                    [joinColumn.name]: id,
+                    ...joinTable.on || {}
+                  };
+                })
+              };
+              await this.createQueryBuilder(joinTable.name).delete().where(where).transacting(trx).execute();
+              await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rowsToDelete, {
+                uid,
+                attributeName,
+                joinTable,
+                db,
+                transaction: trx
+              });
+            }
+            if (hasConnect) {
+              const dataset = cleanRelationData.connect || [];
+              const rows = dataset.map((data2) => ({
+                [joinColumn.name]: id,
+                [idColumn.name]: data2.id,
+                [typeColumn.name]: data2[typeField],
+                ...joinTable.on || {},
+                ...data2.__pivot || {},
+                field: attributeName
+              }));
+              const orderMap = relationsOrderer(
+                // Merge id & __type to get a single id key
+                adjacentRelations.map(
+                  encodePolymorphicRelation({
+                    idColumn: idColumn.name,
+                    typeColumn: typeColumn.name
+                  })
+                ),
+                idColumn.name,
+                "order",
+                cleanRelationData.options?.strict
+              ).connect(
+                // Merge id & __type to get a single id key
+                dataset.map(encodePolymorphicRelation({ idColumn: "id", typeColumn: "__type" }))
+              ).getOrderMap();
+              rows.forEach((row) => {
+                const rowId = row[idColumn.name];
+                const rowType = row[typeColumn.name];
+                const encodedId = encodePolymorphicId(rowId, rowType);
+                row.order = orderMap[encodedId];
+              });
+              await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+            }
             continue;
           }
-          const rows = (cleanRelationData.set ?? []).map((data2, idx) => ({
-            [joinColumn.name]: id,
-            [idColumn.name]: data2.id,
-            [typeColumn.name]: data2[typeField],
-            ...joinTable.on || {},
-            ...data2.__pivot || {},
-            order: idx + 1
-          }));
-          await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
-            uid,
-            attributeName,
-            joinTable,
-            db,
-            transaction: trx
-          });
-          await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+          if (hasSet) {
+            await this.createQueryBuilder(joinTable.name).delete().where({
+              [joinColumn.name]: id,
+              ...joinTable.on || {}
+            }).transacting(trx).execute();
+            const rows = (cleanRelationData.set ?? []).map((data2, idx) => ({
+              [joinColumn.name]: id,
+              [idColumn.name]: data2.id,
+              [typeColumn.name]: data2[typeField],
+              field: attributeName,
+              ...joinTable.on || {},
+              ...data2.__pivot || {},
+              order: idx + 1
+            }));
+            await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
+              uid,
+              attributeName,
+              joinTable,
+              db,
+              transaction: trx
+            });
+            await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+          }
           continue;
         }
         if ("joinColumn" in attribute && attribute.joinColumn && attribute.owner) {
@@ -6107,7 +6282,7 @@ const QUERIES = {
     FROM :tableName:
     LEFT JOIN :joinTableName: ON :tableName:.id = :joinTableName:.:joinColumn:
     WHERE document_id IS NULL
-    GROUP BY :tableName:.id, :joinColumn:
+    GROUP BY :tableName:.id, :joinTableName:.:joinColumn:
     LIMIT 1;
   `,
       params
@@ -6121,7 +6296,7 @@ const QUERIES = {
     FROM :tableName:
     LEFT JOIN :joinTableName: ON :tableName:.id = :joinTableName:.:joinColumn:
     WHERE document_id IS NULL
-    GROUP BY :tableName:.id, :joinColumn:
+    GROUP BY :tableName:.id, :joinTableName:.:joinColumn:
     LIMIT 1;
   `,
       params
@@ -6135,7 +6310,7 @@ const QUERIES = {
     FROM :tableName:
     LEFT JOIN :joinTableName: ON :tableName:.id = :joinTableName:.:joinColumn:
     WHERE document_id IS NULL
-    GROUP BY :joinColumn:
+    GROUP BY :joinTableName:.:joinColumn:
     LIMIT 1;
     `,
       params