@strapi/core 0.0.0-experimental.fc1ac2acd58c8a5a858679956b6d102ac5ee4011 → 0.0.0-next.504076d2165a82f124620a3f1f3e3a6017e97f3f

package/dist/services/document-service/utils/populate.mjs

@@ -1,13 +1,19 @@
 import { contentTypes } from "@strapi/utils";
-const getDeepPopulate = (uid) => {
+const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = contentTypes.constants;
+const getDeepPopulate = (uid, opts = {}) => {
   const model = strapi.getModel(uid);
   const attributes = Object.entries(model.attributes);
   return attributes.reduce((acc, [attributeName, attribute]) => {
     switch (attribute.type) {
       case "relation": {
+        const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+        if (isMorphRelation) {
+          break;
+        }
         const isVisible = contentTypes.isVisibleAttribute(model, attributeName);
-        if (isVisible) {
-          acc[attributeName] = { select: ["document_id", "locale"] };
+        const isCreatorField = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(attributeName);
+        if (isVisible || isCreatorField) {
+          acc[attributeName] = { select: opts.relationalFields };
         }
         break;
       }
@@ -16,14 +22,14 @@ const getDeepPopulate = (uid) => {
         break;
       }
       case "component": {
-        const populate = getDeepPopulate(attribute.component);
+        const populate = getDeepPopulate(attribute.component, opts);
         acc[attributeName] = { populate };
         break;
       }
       case "dynamiczone": {
         const populatedComponents = (attribute.components || []).reduce(
           (acc2, componentUID) => {
-            acc2[componentUID] = { populate: getDeepPopulate(componentUID) };
+            acc2[componentUID] = { populate: getDeepPopulate(componentUID, opts) };
             return acc2;
           },
           {}

package/dist/services/document-service/utils/populate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"populate.mjs","sources":["../../../../src/services/document-service/utils/populate.ts"],"sourcesContent":["import { Common } from '@strapi/types';\nimport { contentTypes } from '@strapi/utils';\n\n// We want to build a populate object based on the schema\nexport const getDeepPopulate = (uid: Common.UID.Schema) => {\n  const model = strapi.getModel(uid);\n  const attributes = Object.entries(model.attributes);\n\n  return attributes.reduce((acc: any, [attributeName, attribute]) => {\n    switch (attribute.type) {\n      case 'relation': {\n        // TODO: Should this just be a plain list?\n        // Ignore createdBy, updatedBy, ...\n        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);\n        if (isVisible) {\n          acc[attributeName] = { select: ['document_id', 'locale'] };\n        }\n        break;\n      }\n\n      case 'media': {\n        acc[attributeName] = { select: ['id'] };\n        break;\n      }\n\n      case 'component': {\n        const populate = getDeepPopulate(attribute.component);\n        acc[attributeName] = { populate };\n        break;\n      }\n\n      case 'dynamiczone': {\n        // Use fragments to populate the dynamic zone components\n        const populatedComponents = (attribute.components || []).reduce(\n          (acc: any, componentUID: Common.UID.Component) => {\n            acc[componentUID] = { populate: getDeepPopulate(componentUID) };\n            return acc;\n          },\n          {}\n        );\n\n        acc[attributeName] = { on: populatedComponents };\n        break;\n      }\n      default:\n        break;\n    }\n\n    return acc;\n  }, {});\n};\n"],"names":["acc"],"mappings":";AAIa,MAAA,kBAAkB,CAAC,QAA2B;AACnD,QAAA,QAAQ,OAAO,SAAS,GAAG;AACjC,QAAM,aAAa,OAAO,QAAQ,MAAM,UAAU;AAElD,SAAO,WAAW,OAAO,CAAC,KAAU,CAAC,eAAe,SAAS,MAAM;AACjE,YAAQ,UAAU,MAAM;AAAA,MACtB,KAAK,YAAY;AAGf,cAAM,YAAY,aAAa,mBAAmB,OAAO,aAAa;AACtE,YAAI,WAAW;AACb,cAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,eAAe,QAAQ;QACzD;AACA;AAAA,MACF;AAAA,MAEA,KAAK,SAAS;AACZ,YAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE;AACtC;AAAA,MACF;AAAA,MAEA,KAAK,aAAa;AACV,cAAA,WAAW,gBAAgB,UAAU,SAAS;AAChD,YAAA,aAAa,IAAI,EAAE;AACvB;AAAA,MACF;AAAA,MAEA,KAAK,eAAe;AAElB,cAAM,uBAAuB,UAAU,cAAc,CAAI,GAAA;AAAA,UACvD,CAACA,MAAU,iBAAuC;AAChDA,iBAAI,YAAY,IAAI,EAAE,UAAU,gBAAgB,YAAY;AACrDA,mBAAAA;AAAAA,UACT;AAAA,UACA,CAAC;AAAA,QAAA;AAGH,YAAI,aAAa,IAAI,EAAE,IAAI,oBAAoB;AAC/C;AAAA,MACF;AAAA,IAGF;AAEO,WAAA;AAAA,EACT,GAAG,CAAE,CAAA;AACP;"}
+{"version":3,"file":"populate.mjs","sources":["../../../../src/services/document-service/utils/populate.ts"],"sourcesContent":["import { UID } from '@strapi/types';\nimport { contentTypes } from '@strapi/utils';\n\ninterface Options {\n  /**\n   * Fields to select when populating relations\n   */\n  relationalFields?: string[];\n}\n\nconst { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = contentTypes.constants;\n\n// We want to build a populate object based on the schema\nexport const getDeepPopulate = (uid: UID.Schema, opts: Options = {}) => {\n  const model = strapi.getModel(uid);\n  const attributes = Object.entries(model.attributes);\n\n  return attributes.reduce((acc: any, [attributeName, attribute]) => {\n    switch (attribute.type) {\n      case 'relation': {\n        // TODO: Support polymorphic relations\n        const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');\n        if (isMorphRelation) {\n          break;\n        }\n\n        // Ignore not visible fields other than createdBy and updatedBy\n        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);\n        const isCreatorField = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(attributeName);\n\n        if (isVisible || isCreatorField) {\n          acc[attributeName] = { select: opts.relationalFields };\n        }\n\n        break;\n      }\n\n      case 'media': {\n        acc[attributeName] = { select: ['id'] };\n        break;\n      }\n\n      case 'component': {\n        const populate = getDeepPopulate(attribute.component, opts);\n        acc[attributeName] = { populate };\n        break;\n      }\n\n      case 'dynamiczone': {\n        // Use fragments to populate the dynamic zone components\n        const populatedComponents = (attribute.components || []).reduce(\n          (acc: any, componentUID: UID.Component) => {\n            acc[componentUID] = { populate: getDeepPopulate(componentUID, opts) };\n            return acc;\n          },\n          {}\n        );\n\n        acc[attributeName] = { on: populatedComponents };\n        break;\n      }\n      default:\n        break;\n    }\n\n    return acc;\n  }, {});\n};\n"],"names":["acc"],"mappings":";AAUA,MAAM,EAAE,sBAAsB,yBAAyB,aAAa;AAG7D,MAAM,kBAAkB,CAAC,KAAiB,OAAgB,OAAO;AAChE,QAAA,QAAQ,OAAO,SAAS,GAAG;AACjC,QAAM,aAAa,OAAO,QAAQ,MAAM,UAAU;AAElD,SAAO,WAAW,OAAO,CAAC,KAAU,CAAC,eAAe,SAAS,MAAM;AACjE,YAAQ,UAAU,MAAM;AAAA,MACtB,KAAK,YAAY;AAEf,cAAM,kBAAkB,UAAU,SAAS,YAAY,EAAE,WAAW,OAAO;AAC3E,YAAI,iBAAiB;AACnB;AAAA,QACF;AAGA,cAAM,YAAY,aAAa,mBAAmB,OAAO,aAAa;AACtE,cAAM,iBAAiB,CAAC,sBAAsB,oBAAoB,EAAE,SAAS,aAAa;AAE1F,YAAI,aAAa,gBAAgB;AAC/B,cAAI,aAAa,IAAI,EAAE,QAAQ,KAAK,iBAAiB;AAAA,QACvD;AAEA;AAAA,MACF;AAAA,MAEA,KAAK,SAAS;AACZ,YAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE;AACtC;AAAA,MACF;AAAA,MAEA,KAAK,aAAa;AAChB,cAAM,WAAW,gBAAgB,UAAU,WAAW,IAAI;AACtD,YAAA,aAAa,IAAI,EAAE;AACvB;AAAA,MACF;AAAA,MAEA,KAAK,eAAe;AAElB,cAAM,uBAAuB,UAAU,cAAc,CAAI,GAAA;AAAA,UACvD,CAACA,MAAU,iBAAgC;AACzCA,iBAAI,YAAY,IAAI,EAAE,UAAU,gBAAgB,cAAc,IAAI;AAC3DA,mBAAAA;AAAAA,UACT;AAAA,UACA,CAAC;AAAA,QAAA;AAGH,YAAI,aAAa,IAAI,EAAE,IAAI,oBAAoB;AAC/C;AAAA,MACF;AAAA,IAGF;AAEO,WAAA;AAAA,EACT,GAAG,CAAE,CAAA;AACP;"}

package/dist/services/document-service/utils/unidirectional-relations.d.ts

@@ -0,0 +1,33 @@
+import { UID } from '@strapi/types';
+/**
+ * Loads lingering relations that need to be updated when overriding a published or draft entry.
+ * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.
+ * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.
+ *
+ * @param uid The content type uid
+ * @param oldEntries The old entries that are being overridden
+ * @returns An array of relations that need to be updated with the join table reference.
+ */
+declare const load: (uid: UID.ContentType, oldEntries: {
+    id: string;
+    locale: string;
+}[]) => Promise<any>;
+/**
+ * Updates uni directional relations to target the right entries when overriding published or draft entries.
+ *
+ * @param oldEntries The old entries that are being overridden
+ * @param newEntries The new entries that are overriding the old ones
+ * @param oldRelations The relations that were previously loaded with `load` @see load
+ */
+declare const sync: (oldEntries: {
+    id: string;
+    locale: string;
+}[], newEntries: {
+    id: string;
+    locale: string;
+}[], oldRelations: {
+    joinTable: any;
+    relations: any[];
+}[]) => Promise<void>;
+export { load, sync };
+//# sourceMappingURL=unidirectional-relations.d.ts.map

package/dist/services/document-service/utils/unidirectional-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unidirectional-relations.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAU,MAAM,eAAe,CAAC;AAE5C;;;;;;;;GAQG;AACH,QAAA,MAAM,IAAI,QAAe,IAAI,WAAW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,iBA2CrF,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,IAAI,eACI;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,cAChC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,gBAC9B;IAAE,SAAS,EAAE,GAAG,CAAC;IAAC,SAAS,EAAE,GAAG,EAAE,CAAA;CAAE,EAAE,kBAkCrD,CAAC;AAEF,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC"}

package/dist/services/document-service/utils/unidirectional-relations.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fp = require("lodash/fp");
+const load = async (uid, oldEntries) => {
+  const updates = [];
+  await strapi.db.transaction(async ({ trx }) => {
+    const contentTypes = Object.values(strapi.contentTypes);
+    const components = Object.values(strapi.components);
+    for (const model of [...contentTypes, ...components]) {
+      const dbModel = strapi.db.metadata.get(model.uid);
+      for (const attribute of Object.values(dbModel.attributes)) {
+        if (attribute.type !== "relation")
+          continue;
+        if (attribute.target !== uid)
+          continue;
+        if (attribute.inversedBy || attribute.mappedBy)
+          continue;
+        const joinTable = attribute.joinTable;
+        if (!joinTable)
+          continue;
+        const { name } = joinTable.inverseJoinColumn;
+        const oldEntriesIds = oldEntries.map((entry) => entry.id);
+        const relations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(name, oldEntriesIds).transacting(trx);
+        if (relations.length === 0)
+          continue;
+        updates.push({ joinTable, relations });
+      }
+    }
+  });
+  return updates;
+};
+const sync = async (oldEntries, newEntries, oldRelations) => {
+  const newEntryByLocale = fp.keyBy("locale", newEntries);
+  const oldEntriesMap = oldEntries.reduce(
+    (acc, entry) => {
+      const newEntry = newEntryByLocale[entry.locale];
+      if (!newEntry)
+        return acc;
+      acc[entry.id] = newEntry.id;
+      return acc;
+    },
+    {}
+  );
+  await strapi.db.transaction(async ({ trx }) => {
+    const con = strapi.db.getConnection();
+    for (const { joinTable, relations } of oldRelations) {
+      const newRelations = relations.map((relation) => {
+        const column = joinTable.inverseJoinColumn.name;
+        const newId = oldEntriesMap[relation[column]];
+        return { ...relation, [column]: newId };
+      });
+      await con.batchInsert(joinTable.name, newRelations).transacting(trx);
+    }
+  });
+};
+exports.load = load;
+exports.sync = sync;
+//# sourceMappingURL=unidirectional-relations.js.map

package/dist/services/document-service/utils/unidirectional-relations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unidirectional-relations.js","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy } from 'lodash/fp';\n\nimport { UID, Schema } from '@strapi/types';\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n *\n * @param uid The content type uid\n * @param oldEntries The old entries that are being overridden\n * @returns An array of relations that need to be updated with the join table reference.\n */\nconst load = async (uid: UID.ContentType, oldEntries: { id: string; locale: string }[]) => {\n  const updates = [] as any;\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (attribute.type !== 'relation') continue;\n        if (attribute.target !== uid) continue;\n        if (attribute.inversedBy || attribute.mappedBy) continue;\n        const joinTable = attribute.joinTable;\n        // TODO: joinColumn relations\n        if (!joinTable) continue;\n\n        const { name } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        const oldEntriesIds = oldEntries.map((entry) => entry.id);\n        const relations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(name, oldEntriesIds)\n          .transacting(trx);\n\n        if (relations.length === 0) continue;\n\n        updates.push({ joinTable, relations });\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    const con = strapi.db.getConnection();\n\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const newRelations = relations.map((relation) => {\n        const column = joinTable.inverseJoinColumn.name;\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await con.batchInsert(joinTable.name, newRelations).transacting(trx);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["keyBy"],"mappings":";;;AAcM,MAAA,OAAO,OAAO,KAAsB,eAAiD;AACzF,QAAM,UAAU,CAAA;AAGhB,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAC7C,UAAM,eAAe,OAAO,OAAO,OAAO,YAAY;AACtD,UAAM,aAAa,OAAO,OAAO,OAAO,UAAU;AAElD,eAAW,SAAS,CAAC,GAAG,cAAc,GAAG,UAAU,GAAG;AACpD,YAAM,UAAU,OAAO,GAAG,SAAS,IAAI,MAAM,GAAG;AAEhD,iBAAW,aAAa,OAAO,OAAO,QAAQ,UAAU,GAAU;AAIhE,YAAI,UAAU,SAAS;AAAY;AACnC,YAAI,UAAU,WAAW;AAAK;AAC1B,YAAA,UAAU,cAAc,UAAU;AAAU;AAChD,cAAM,YAAY,UAAU;AAE5B,YAAI,CAAC;AAAW;AAEV,cAAA,EAAE,KAAK,IAAI,UAAU;AAK3B,cAAM,gBAAgB,WAAW,IAAI,CAAC,UAAU,MAAM,EAAE;AACxD,cAAM,YAAY,MAAM,OAAO,GAC5B,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,MAAM,aAAa,EAC3B,YAAY,GAAG;AAElB,YAAI,UAAU,WAAW;AAAG;AAE5B,gBAAQ,KAAK,EAAE,WAAW,UAAW,CAAA;AAAA,MACvC;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA;AACT;AASA,MAAM,OAAO,OACX,YACA,YACA,iBACG;AAMG,QAAA,mBAAmBA,GAAAA,MAAM,UAAU,UAAU;AACnD,QAAM,gBAAgB,WAAW;AAAA,IAC/B,CAAC,KAAK,UAAU;AACR,YAAA,WAAW,iBAAiB,MAAM,MAAM;AAC9C,UAAI,CAAC;AAAiB,eAAA;AAClB,UAAA,MAAM,EAAE,IAAI,SAAS;AAClB,aAAA;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EAAA;AAGH,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AACvC,UAAA,MAAM,OAAO,GAAG,cAAc;AAGpC,eAAW,EAAE,WAAW,UAAU,KAAK,cAAc;AAEnD,YAAM,eAAe,UAAU,IAAI,CAAC,aAAa;AACzC,cAAA,SAAS,UAAU,kBAAkB;AAC3C,cAAM,QAAQ,cAAc,SAAS,MAAM,CAAC;AAC5C,eAAO,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM;AAAA,MAAA,CACvC;AAGD,YAAM,IAAI,YAAY,UAAU,MAAM,YAAY,EAAE,YAAY,GAAG;AAAA,IACrE;AAAA,EAAA,CACD;AACH;;;"}

package/dist/services/document-service/utils/unidirectional-relations.mjs

@@ -0,0 +1,58 @@
+import { keyBy } from "lodash/fp";
+const load = async (uid, oldEntries) => {
+  const updates = [];
+  await strapi.db.transaction(async ({ trx }) => {
+    const contentTypes = Object.values(strapi.contentTypes);
+    const components = Object.values(strapi.components);
+    for (const model of [...contentTypes, ...components]) {
+      const dbModel = strapi.db.metadata.get(model.uid);
+      for (const attribute of Object.values(dbModel.attributes)) {
+        if (attribute.type !== "relation")
+          continue;
+        if (attribute.target !== uid)
+          continue;
+        if (attribute.inversedBy || attribute.mappedBy)
+          continue;
+        const joinTable = attribute.joinTable;
+        if (!joinTable)
+          continue;
+        const { name } = joinTable.inverseJoinColumn;
+        const oldEntriesIds = oldEntries.map((entry) => entry.id);
+        const relations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(name, oldEntriesIds).transacting(trx);
+        if (relations.length === 0)
+          continue;
+        updates.push({ joinTable, relations });
+      }
+    }
+  });
+  return updates;
+};
+const sync = async (oldEntries, newEntries, oldRelations) => {
+  const newEntryByLocale = keyBy("locale", newEntries);
+  const oldEntriesMap = oldEntries.reduce(
+    (acc, entry) => {
+      const newEntry = newEntryByLocale[entry.locale];
+      if (!newEntry)
+        return acc;
+      acc[entry.id] = newEntry.id;
+      return acc;
+    },
+    {}
+  );
+  await strapi.db.transaction(async ({ trx }) => {
+    const con = strapi.db.getConnection();
+    for (const { joinTable, relations } of oldRelations) {
+      const newRelations = relations.map((relation) => {
+        const column = joinTable.inverseJoinColumn.name;
+        const newId = oldEntriesMap[relation[column]];
+        return { ...relation, [column]: newId };
+      });
+      await con.batchInsert(joinTable.name, newRelations).transacting(trx);
+    }
+  });
+};
+export {
+  load,
+  sync
+};
+//# sourceMappingURL=unidirectional-relations.mjs.map

package/dist/services/document-service/utils/unidirectional-relations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy } from 'lodash/fp';\n\nimport { UID, Schema } from '@strapi/types';\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n *\n * @param uid The content type uid\n * @param oldEntries The old entries that are being overridden\n * @returns An array of relations that need to be updated with the join table reference.\n */\nconst load = async (uid: UID.ContentType, oldEntries: { id: string; locale: string }[]) => {\n  const updates = [] as any;\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (attribute.type !== 'relation') continue;\n        if (attribute.target !== uid) continue;\n        if (attribute.inversedBy || attribute.mappedBy) continue;\n        const joinTable = attribute.joinTable;\n        // TODO: joinColumn relations\n        if (!joinTable) continue;\n\n        const { name } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        const oldEntriesIds = oldEntries.map((entry) => entry.id);\n        const relations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(name, oldEntriesIds)\n          .transacting(trx);\n\n        if (relations.length === 0) continue;\n\n        updates.push({ joinTable, relations });\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    const con = strapi.db.getConnection();\n\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const newRelations = relations.map((relation) => {\n        const column = joinTable.inverseJoinColumn.name;\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await con.batchInsert(joinTable.name, newRelations).transacting(trx);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":[],"mappings":";AAcM,MAAA,OAAO,OAAO,KAAsB,eAAiD;AACzF,QAAM,UAAU,CAAA;AAGhB,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAC7C,UAAM,eAAe,OAAO,OAAO,OAAO,YAAY;AACtD,UAAM,aAAa,OAAO,OAAO,OAAO,UAAU;AAElD,eAAW,SAAS,CAAC,GAAG,cAAc,GAAG,UAAU,GAAG;AACpD,YAAM,UAAU,OAAO,GAAG,SAAS,IAAI,MAAM,GAAG;AAEhD,iBAAW,aAAa,OAAO,OAAO,QAAQ,UAAU,GAAU;AAIhE,YAAI,UAAU,SAAS;AAAY;AACnC,YAAI,UAAU,WAAW;AAAK;AAC1B,YAAA,UAAU,cAAc,UAAU;AAAU;AAChD,cAAM,YAAY,UAAU;AAE5B,YAAI,CAAC;AAAW;AAEV,cAAA,EAAE,KAAK,IAAI,UAAU;AAK3B,cAAM,gBAAgB,WAAW,IAAI,CAAC,UAAU,MAAM,EAAE;AACxD,cAAM,YAAY,MAAM,OAAO,GAC5B,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,MAAM,aAAa,EAC3B,YAAY,GAAG;AAElB,YAAI,UAAU,WAAW;AAAG;AAE5B,gBAAQ,KAAK,EAAE,WAAW,UAAW,CAAA;AAAA,MACvC;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA;AACT;AASA,MAAM,OAAO,OACX,YACA,YACA,iBACG;AAMG,QAAA,mBAAmB,MAAM,UAAU,UAAU;AACnD,QAAM,gBAAgB,WAAW;AAAA,IAC/B,CAAC,KAAK,UAAU;AACR,YAAA,WAAW,iBAAiB,MAAM,MAAM;AAC9C,UAAI,CAAC;AAAiB,eAAA;AAClB,UAAA,MAAM,EAAE,IAAI,SAAS;AAClB,aAAA;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EAAA;AAGH,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AACvC,UAAA,MAAM,OAAO,GAAG,cAAc;AAGpC,eAAW,EAAE,WAAW,UAAU,KAAK,cAAc;AAEnD,YAAM,eAAe,UAAU,IAAI,CAAC,aAAa;AACzC,cAAA,SAAS,UAAU,kBAAkB;AAC3C,cAAM,QAAQ,cAAc,SAAS,MAAM,CAAC;AAC5C,eAAO,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM;AAAA,MAAA,CACvC;AAGD,YAAM,IAAI,YAAY,UAAU,MAAM,YAAY,EAAE,YAAY,GAAG;AAAA,IACrE;AAAA,EAAA,CACD;AACH;"}

package/dist/services/entity-service/index.d.ts

@@ -1,15 +1,13 @@
 import type { Database } from '@strapi/database';
-import type { Strapi, EntityService, EntityValidator, EventHub } from '@strapi/types';
+import type { Core, Modules } from '@strapi/types';
 type Decoratable<T> = T & {
-    decorate(decorator: (old: EntityService.EntityService) => EntityService.EntityService & {
+    decorate(decorator: (old: Modules.EntityService.EntityService) => Modules.EntityService.EntityService & {
         [key: string]: unknown;
     }): void;
 };
 declare const _default: (ctx: {
-    strapi: Strapi;
+    strapi: Core.Strapi;
     db: Database;
-    eventHub: EventHub;
-    entityValidator: EntityValidator;
-}) => Decoratable<EntityService.EntityService>;
+}) => Decoratable<Modules.EntityService.EntityService>;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/dist/services/entity-service/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/entity-service/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EACV,MAAM,EACN,aAAa,EACb,eAAe,EACf,QAAQ,EAKT,MAAM,eAAe,CAAC;AAkBvB,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG;IACxB,QAAQ,CACN,SAAS,EAAE,CAAC,GAAG,EAAE,aAAa,CAAC,aAAa,KAAK,aAAa,CAAC,aAAa,GAAG;QAC7E,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GACA,IAAI,CAAC;CACT,CAAC;8BA0ZmB;IACnB,QAAQ,MAAM,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,EAAE,eAAe,CAAC;CAClC,KAAG,YAAY,2BAA2B,CAAC;AAL5C,wBA0DE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/entity-service/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAS,MAAM,eAAe,CAAC;AAE1D,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG;IACxB,QAAQ,CACN,SAAS,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,KAAK,OAAO,CAAC,aAAa,CAAC,aAAa,GAAG;QAC7F,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GACA,IAAI,CAAC;CACT,CAAC;8BAuLmB;IACnB,MAAM,EAAE,KAAK,MAAM,CAAC;IACpB,EAAE,EAAE,QAAQ,CAAC;CACd,KAAG,YAAY,QAAQ,aAAa,CAAC,aAAa,CAAC;AAHpD,wBAoDE"}

package/dist/services/entity-service/index.js

@@ -3,16 +3,11 @@ const _ = require("lodash");
 const delegate = require("delegates");
 const database = require("@strapi/database");
 const strapiUtils = require("@strapi/utils");
-const uploadFiles = require("../utils/upload-files.js");
-const components = require("./components.js");
-const params = require("./params.js");
-const index = require("./attributes/index.js");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 const ___default = /* @__PURE__ */ _interopDefault(_);
 const delegate__default = /* @__PURE__ */ _interopDefault(delegate);
-const { transformParamsToQuery } = strapiUtils.convertQueryParams;
-const transformLoadParamsToQuery = (uid, field, params2, pagination = {}) => {
-  const query = transformParamsToQuery(uid, { populate: { [field]: params2 } });
+const transformLoadParamsToQuery = (uid, field, params, pagination = {}) => {
+  const query = strapi.get("query-params").transform(uid, { populate: { [field]: params } });
   const res = {
     ...query.populate[field],
     ...pagination
@@ -25,258 +20,107 @@ const databaseErrorsToTransform = [
   database.errors.InvalidDateError,
   database.errors.InvalidRelationError
 ];
-const creationPipeline = (data, context) => {
-  return index.applyTransforms(data, context);
-};
-const updatePipeline = (data, context) => {
-  return index.applyTransforms(data, context);
-};
-const ALLOWED_WEBHOOK_EVENTS = {
-  ENTRY_CREATE: "entry.create",
-  ENTRY_UPDATE: "entry.update",
-  ENTRY_DELETE: "entry.delete"
-};
 const createDefaultImplementation = ({
-  strapi,
-  db,
-  eventHub,
-  entityValidator
+  strapi: strapi2,
+  db
 }) => ({
-  /**
-   * Upload files utility
-   */
-  uploadFiles,
   async wrapParams(options = {}) {
     return options;
   },
   async wrapResult(result = {}) {
     return result;
   },
-  async emitEvent(uid, event, entity) {
-    if (uid === "admin::audit-log") {
-      return;
-    }
-    const model = strapi.getModel(uid);
-    const sanitizedEntity = await strapiUtils.sanitize.sanitizers.defaultSanitizeOutput(model, entity);
-    eventHub.emit(event, {
-      model: model.modelName,
-      uid: model.uid,
-      entry: sanitizedEntity
-    });
-  },
   async findMany(uid, opts) {
-    const { kind } = strapi.getModel(uid);
+    const { kind } = strapi2.getModel(uid);
     const wrappedParams = await this.wrapParams(opts, { uid, action: "findMany" });
-    const query = transformParamsToQuery(uid, wrappedParams);
     if (kind === "singleType") {
-      const entity = db.query(uid).findOne(query);
+      const entity = strapi2.documents(uid).findFirst(wrappedParams);
       return this.wrapResult(entity, { uid, action: "findOne" });
     }
-    const entities = await db.query(uid).findMany(query);
+    const entities = await strapi2.documents(uid).findMany(wrappedParams);
     return this.wrapResult(entities, { uid, action: "findMany" });
   },
   async findPage(uid, opts) {
     const wrappedParams = await this.wrapParams(opts, { uid, action: "findPage" });
-    const query = transformParamsToQuery(uid, wrappedParams);
-    const page = await db.query(uid).findPage(query);
-    return {
-      ...page,
-      results: await this.wrapResult(page.results, { uid, action: "findPage" })
-    };
-  },
-  // TODO: streamline the logic based on the populate option
-  async findWithRelationCountsPage(uid, opts) {
-    const wrappedParams = await this.wrapParams(opts, { uid, action: "findWithRelationCounts" });
-    const query = transformParamsToQuery(uid, wrappedParams);
+    const query = strapi2.get("query-params").transform(uid, wrappedParams);
     const entities = await db.query(uid).findPage(query);
-    return {
-      ...entities,
-      results: await this.wrapResult(entities.results, { uid, action: "findWithRelationCounts" })
-    };
-  },
-  async findWithRelationCounts(uid, opts) {
-    const wrappedParams = await this.wrapParams(opts, { uid, action: "findWithRelationCounts" });
-    const query = transformParamsToQuery(uid, wrappedParams);
-    const entities = await db.query(uid).findMany(query);
-    return this.wrapResult(entities, { uid, action: "findWithRelationCounts" });
+    return this.wrapResult(entities, { uid, action: "findMany" });
   },
   async findOne(uid, entityId, opts) {
     const wrappedParams = await this.wrapParams(opts, { uid, action: "findOne" });
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(wrappedParams));
-    const entity = await db.query(uid).findOne({ ...query, where: { id: entityId } });
+    const res = await db.query(uid).findOne({ where: { id: entityId } });
+    if (!res) {
+      return this.wrapResult(null, { uid, action: "findOne" });
+    }
+    const entity = await strapi2.documents(uid).findOne({
+      ...wrappedParams,
+      documentId: res.documentId
+    });
     return this.wrapResult(entity, { uid, action: "findOne" });
   },
   async count(uid, opts) {
     const wrappedParams = await this.wrapParams(opts, { uid, action: "count" });
-    const query = transformParamsToQuery(uid, wrappedParams);
-    return db.query(uid).count(query);
+    return strapi2.documents(uid).count(wrappedParams);
   },
-  async create(uid, params$1) {
-    const wrappedParams = await this.wrapParams(params$1, { uid, action: "create" });
-    const { data, files } = wrappedParams;
+  async create(uid, params) {
+    const wrappedParams = await this.wrapParams(params, { uid, action: "create" });
+    const { data } = wrappedParams;
     if (!data) {
       throw new Error("cannot create");
     }
-    const model = strapi.getModel(uid);
-    const isDraft = strapiUtils.contentTypes.isDraft(data, model);
-    const validData = await entityValidator.validateEntityCreation(model, data, { isDraft });
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(wrappedParams));
-    const componentData = await components.createComponents(uid, validData);
-    const entityData = creationPipeline(
-      Object.assign(components.omitComponentData(model, validData), componentData),
-      {
-        contentType: model
-      }
-    );
-    let entity = await db.query(uid).create({
-      ...query,
-      data: entityData
+    const shouldPublish = !strapiUtils.contentTypes.isDraft(data, strapi2.getModel(uid));
+    const entity = await strapi2.documents(uid).create({
+      ...wrappedParams,
+      status: shouldPublish ? "published" : "draft"
     });
-    if (files && Object.keys(files).length > 0) {
-      await this.uploadFiles(uid, Object.assign(entityData, entity), files);
-      entity = await this.findOne(uid, entity.id, wrappedParams);
-    }
-    entity = await this.wrapResult(entity, { uid, action: "create" });
-    const { ENTRY_CREATE } = ALLOWED_WEBHOOK_EVENTS;
-    await this.emitEvent(uid, ENTRY_CREATE, entity);
-    return entity;
+    return this.wrapResult(entity, { uid, action: "create" });
   },
   async update(uid, entityId, opts) {
     const wrappedParams = await this.wrapParams(opts, {
       uid,
       action: "update"
     });
-    const { data, files } = wrappedParams;
-    const model = strapi.getModel(uid);
     const entityToUpdate = await db.query(uid).findOne({ where: { id: entityId } });
     if (!entityToUpdate) {
-      return null;
+      return this.wrapResult(null, { uid, action: "update" });
     }
-    const isDraft = strapiUtils.contentTypes.isDraft(entityToUpdate, model);
-    const validData = await entityValidator.validateEntityUpdate(
-      model,
-      data,
-      {
-        isDraft
-      },
-      entityToUpdate
-    );
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(wrappedParams));
-    const componentData = await components.updateComponents(uid, entityToUpdate, validData);
-    const entityData = updatePipeline(
-      Object.assign(components.omitComponentData(model, validData), componentData),
-      { contentType: model }
-    );
-    let entity = await db.query(uid).update({
-      ...query,
-      where: { id: entityId },
-      data: entityData
+    const shouldPublish = !strapiUtils.contentTypes.isDraft(entityToUpdate, strapi2.getModel(uid));
+    const entity = strapi2.documents(uid).update({
+      ...wrappedParams,
+      status: shouldPublish ? "published" : "draft",
+      documentId: entityToUpdate.documentId
     });
-    if (files && Object.keys(files).length > 0) {
-      await this.uploadFiles(uid, Object.assign(entityData, entity), files);
-      entity = await this.findOne(uid, entity.id, wrappedParams);
-    }
-    entity = await this.wrapResult(entity, { uid, action: "update" });
-    const { ENTRY_UPDATE } = ALLOWED_WEBHOOK_EVENTS;
-    await this.emitEvent(uid, ENTRY_UPDATE, entity);
-    return entity;
+    return this.wrapResult(entity, { uid, action: "update" });
   },
   async delete(uid, entityId, opts) {
     const wrappedParams = await this.wrapParams(opts, { uid, action: "delete" });
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(wrappedParams));
-    let entityToDelete = await db.query(uid).findOne({
-      ...query,
-      where: { id: entityId }
-    });
+    const entityToDelete = await db.query(uid).findOne({ where: { id: entityId } });
     if (!entityToDelete) {
-      return null;
+      return this.wrapResult(null, { uid, action: "delete" });
     }
-    const componentsToDelete = await components.getComponents(uid, entityToDelete);
-    await db.query(uid).delete({ where: { id: entityToDelete.id } });
-    await components.deleteComponents(uid, componentsToDelete, { loadComponents: false });
-    entityToDelete = await this.wrapResult(entityToDelete, { uid, action: "delete" });
-    const { ENTRY_DELETE } = ALLOWED_WEBHOOK_EVENTS;
-    await this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
-    return entityToDelete;
-  },
-  async clone(uid, cloneId, opts) {
-    const wrappedParams = await this.wrapParams(opts, { uid, action: "clone" });
-    const { data, files } = wrappedParams;
-    if (!data) {
-      throw new Error("cannot clone");
-    }
-    const model = strapi.getModel(uid);
-    const entityToClone = await db.query(uid).findOne({ where: { id: cloneId } });
-    if (!entityToClone) {
-      return null;
-    }
-    const isDraft = strapiUtils.contentTypes.isDraft(entityToClone, model);
-    const validData = await entityValidator.validateEntityUpdate(
-      model,
-      // Omit the id, the cloned entity id will be generated by the database
-      ___default.default.omit(data, ["id"]),
-      { isDraft },
-      entityToClone
-    );
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(wrappedParams));
-    const componentData = await components.cloneComponents(uid, entityToClone, validData);
-    const entityData = creationPipeline(
-      Object.assign(components.omitComponentData(model, validData), componentData),
-      {
-        contentType: model
-      }
-    );
-    let entity = await db.query(uid).clone(cloneId, {
-      ...query,
-      data: entityData
+    await strapi2.documents(uid).delete({
+      ...wrappedParams,
+      documentId: entityToDelete.documentId
     });
-    if (files && Object.keys(files).length > 0) {
-      await this.uploadFiles(uid, Object.assign(entityData, entity), files);
-      entity = await this.findOne(uid, entity.id, wrappedParams);
-    }
-    const { ENTRY_CREATE } = ALLOWED_WEBHOOK_EVENTS;
-    await this.emitEvent(uid, ENTRY_CREATE, entity);
-    return entity;
+    return this.wrapResult(entityToDelete, { uid, action: "delete" });
   },
-  // FIXME: used only for the CM to be removed
-  async deleteMany(uid, opts) {
-    const wrappedParams = await this.wrapParams(opts, { uid, action: "delete" });
-    const query = transformParamsToQuery(uid, wrappedParams);
-    let entitiesToDelete = await db.query(uid).findMany(query);
-    if (!entitiesToDelete.length) {
-      return { count: 0 };
-    }
-    const componentsToDelete = await Promise.all(
-      entitiesToDelete.map((entityToDelete) => components.getComponents(uid, entityToDelete))
-    );
-    const deletedEntities = await db.query(uid).deleteMany(query);
-    await Promise.all(
-      componentsToDelete.map(
-        (compos) => components.deleteComponents(uid, compos, { loadComponents: false })
-      )
-    );
-    entitiesToDelete = await this.wrapResult(entitiesToDelete, { uid, action: "delete" });
-    const { ENTRY_DELETE } = ALLOWED_WEBHOOK_EVENTS;
-    await Promise.all(entitiesToDelete.map((entity) => this.emitEvent(uid, ENTRY_DELETE, entity)));
-    return deletedEntities;
-  },
-  async load(uid, entity, field, params2) {
+  async load(uid, entity, field, params) {
     if (!___default.default.isString(field)) {
       throw new Error(`Invalid load. Expected "${field}" to be a string`);
     }
-    const loadedEntity = await db.query(uid).load(entity, field, transformLoadParamsToQuery(uid, field, params2 ?? {}));
+    const loadedEntity = await db.query(uid).load(entity, field, transformLoadParamsToQuery(uid, field, params ?? {}));
     return this.wrapResult(loadedEntity, { uid, field, action: "load" });
   },
-  async loadPages(uid, entity, field, params2, pagination = {}) {
+  async loadPages(uid, entity, field, params, pagination = {}) {
     if (!___default.default.isString(field)) {
       throw new Error(`Invalid load. Expected "${field}" to be a string`);
     }
-    const { attributes } = strapi.getModel(uid);
+    const { attributes } = strapi2.getModel(uid);
     const attribute = attributes[field];
     if (!strapiUtils.relations.isAnyToMany(attribute)) {
       throw new Error(`Invalid load. Expected "${field}" to be an anyToMany relational attribute`);
     }
-    const query = transformLoadParamsToQuery(uid, field, params2 ?? {}, pagination);
+    const query = transformLoadParamsToQuery(uid, field, params ?? {}, pagination);
     const loadedPage = await db.query(uid).loadPages(entity, field, query);
     return {
       ...loadedPage,
@@ -285,9 +129,6 @@ const createDefaultImplementation = ({
   }
 });
 const createEntityService = (ctx) => {
-  Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
-    ctx.strapi.webhookStore?.addAllowedEvent(key, value);
-  });
   const implementation = createDefaultImplementation(ctx);
   const service = {
     implementation,