@strapi/database 5.3.0 → 5.4.1

package/dist/entity-manager/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entity-manager/index.ts"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAGnC,OAAO,EAAE,aAAa,EAAsB,MAAM,SAAS,CAAC;AAE5D,cAAc,SAAS,CAAC;AAyLxB,eAAO,MAAM,mBAAmB,OAAQ,QAAQ,KAAG,aA2kClD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entity-manager/index.ts"],"names":[],"mappings":"AA8CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAGnC,OAAO,EAAE,aAAa,EAAsB,MAAM,SAAS,CAAC;AAE5D,cAAc,SAAS,CAAC;AA2LxB,eAAO,MAAM,mBAAmB,OAAQ,QAAQ,KAAG,aA0yClD,CAAC"}

package/dist/entity-manager/morph-relations.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="lodash" />
 import type { Knex } from 'knex';
 import type { Database } from '..';
 import type { MorphJoinTable } from '../types';
@@ -9,5 +10,16 @@ export declare const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate: (rows
     db: Database;
     transaction?: Knex.Transaction;
 }) => Promise<void>;
+/**
+ * Encoding utilities for polymorphic relations.
+ *
+ * In some scenarios is useful to encode both the id & __type of the relation
+ * to have a unique identifier for the relation. (e.g. relations reordering)
+ */
+export declare const encodePolymorphicId: (id: number | string, __type: string) => string;
+export declare const encodePolymorphicRelation: import("lodash").CurriedFunction2<{
+    idColumn: any;
+    typeColumn: any;
+}, any, any>;
 export {};
 //# sourceMappingURL=morph-relations.d.ts.map

package/dist/entity-manager/morph-relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"morph-relations.d.ts","sourceRoot":"","sources":["../../src/entity-manager/morph-relations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAY,MAAM,UAAU,CAAC;AAEzD,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;AA8BtC,eAAO,MAAM,oDAAoD,yEAQ5D;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,cAAc,CAAC;IAC1B,EAAE,EAAE,QAAQ,CAAC;IACb,WAAW,CAAC,EAAE,KAAK,WAAW,CAAC;CAChC,kBAoCF,CAAC"}
+{"version":3,"file":"morph-relations.d.ts","sourceRoot":"","sources":["../../src/entity-manager/morph-relations.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAY,MAAM,UAAU,CAAC;AAEzD,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;AA8BtC,eAAO,MAAM,oDAAoD,yEAQ5D;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,cAAc,CAAC;IAC1B,EAAE,EAAE,QAAQ,CAAC;IACb,WAAW,CAAC,EAAE,KAAK,WAAW,CAAC;CAChC,kBAoCF,CAAC;AAEF;;;;;GAKG;AAEH,eAAO,MAAM,mBAAmB,OAAQ,MAAM,GAAG,MAAM,UAAU,MAAM,WAEtE,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;YAkBpC,CAAC"}

package/dist/entity-manager/relations-orderer.d.ts

@@ -8,6 +8,7 @@ interface Link {
         end?: true;
     };
     order?: number;
+    __component?: string;
 }
 interface OrderedLink extends Link {
     init?: boolean;

package/dist/entity-manager/relations-orderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relations-orderer.d.ts","sourceRoot":"","sources":["../../src/entity-manager/relations-orderer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC,UAAU,IAAI;IACZ,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,WAAY,SAAQ,IAAI;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,gBAAgB,eAAgB,IAAI,EAAE,eAAc,IAAI,EAAE,iCAwF/D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,QAAA,MAAM,gBAAgB,yDACX,SAAS,EAAE,YACV,MAAM,SAAS,eACZ,MAAM,SAAS,WACnB,OAAO;0BAuDQ,IAAI,GAAG,IAAI,EAAE;uBAMhB,IAAI,GAAG,IAAI,EAAE;;IAqBhC;;OAEG;;CAgBN,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"relations-orderer.d.ts","sourceRoot":"","sources":["../../src/entity-manager/relations-orderer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC,UAAU,IAAI;IACZ,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,WAAY,SAAQ,IAAI;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,gBAAgB,eAAgB,IAAI,EAAE,eAAc,IAAI,EAAE,iCA0G/D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,QAAA,MAAM,gBAAgB,yDACX,SAAS,EAAE,YACV,MAAM,SAAS,eACZ,MAAM,SAAS,WACnB,OAAO;0BAuDQ,IAAI,GAAG,IAAI,EAAE;uBAMhB,IAAI,GAAG,IAAI,EAAE;;IAqBhC;;OAEG;;CAgBN,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/index.js

@@ -4910,6 +4910,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) => {
@@ -5096,7 +5115,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.`
         );
@@ -5237,7 +5259,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(value) || _.isInteger(value);
@@ -5272,7 +5294,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)
   };
@@ -5547,23 +5570,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;
@@ -5663,25 +5696,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;
         }
@@ -5692,29 +5767,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) {
@@ -6139,7 +6314,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
@@ -6153,7 +6328,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
@@ -6167,7 +6342,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