@strapi/content-manager 5.0.0-beta.6 → 5.0.0-beta.7

package/dist/server/index.js

@@ -138,40 +138,65 @@ const FIELDS_TO_IGNORE = [
   "strapi_stage",
   "strapi_assignee"
 ];
-const getSchemaAttributesDiff = (versionSchemaAttributes, contentTypeSchemaAttributes) => {
-  const sanitizedContentTypeSchemaAttributes = fp.omit(FIELDS_TO_IGNORE, contentTypeSchemaAttributes);
-  const reduceDifferenceToAttributesObject = (diffKeys, source) => {
-    return diffKeys.reduce((previousAttributesObject, diffKey) => {
-      previousAttributesObject[diffKey] = source[diffKey];
-      return previousAttributesObject;
-    }, {});
-  };
-  const versionSchemaKeys = Object.keys(versionSchemaAttributes);
-  const contentTypeSchemaAttributesKeys = Object.keys(sanitizedContentTypeSchemaAttributes);
-  const uniqueToContentType = fp.difference(contentTypeSchemaAttributesKeys, versionSchemaKeys);
-  const added = reduceDifferenceToAttributesObject(
-    uniqueToContentType,
-    sanitizedContentTypeSchemaAttributes
-  );
-  const uniqueToVersion = fp.difference(versionSchemaKeys, contentTypeSchemaAttributesKeys);
-  const removed = reduceDifferenceToAttributesObject(uniqueToVersion, versionSchemaAttributes);
-  return { added, removed };
-};
 const DEFAULT_RETENTION_DAYS = 90;
-const createHistoryService = ({ strapi: strapi2 }) => {
-  const state = {
-    deleteExpiredJob: null,
-    isInitialized: false
+const createServiceUtils = ({ strapi: strapi2 }) => {
+  const getSchemaAttributesDiff = (versionSchemaAttributes, contentTypeSchemaAttributes) => {
+    const sanitizedContentTypeSchemaAttributes = fp.omit(
+      FIELDS_TO_IGNORE,
+      contentTypeSchemaAttributes
+    );
+    const reduceDifferenceToAttributesObject = (diffKeys, source) => {
+      return diffKeys.reduce(
+        (previousAttributesObject, diffKey) => {
+          previousAttributesObject[diffKey] = source[diffKey];
+          return previousAttributesObject;
+        },
+        {}
+      );
+    };
+    const versionSchemaKeys = Object.keys(versionSchemaAttributes);
+    const contentTypeSchemaAttributesKeys = Object.keys(sanitizedContentTypeSchemaAttributes);
+    const uniqueToContentType = fp.difference(contentTypeSchemaAttributesKeys, versionSchemaKeys);
+    const added = reduceDifferenceToAttributesObject(
+      uniqueToContentType,
+      sanitizedContentTypeSchemaAttributes
+    );
+    const uniqueToVersion = fp.difference(versionSchemaKeys, contentTypeSchemaAttributesKeys);
+    const removed = reduceDifferenceToAttributesObject(uniqueToVersion, versionSchemaAttributes);
+    return { added, removed };
   };
-  const query = strapi2.db.query(HISTORY_VERSION_UID);
-  const getRetentionDays = (strapi22) => {
-    const featureConfig = strapi22.ee.features.get("cms-content-history");
-    const licenseRetentionDays = typeof featureConfig === "object" && featureConfig?.options.retentionDays;
-    const userRetentionDays = strapi22.config.get("admin.history.retentionDays");
-    if (userRetentionDays && userRetentionDays < licenseRetentionDays) {
-      return userRetentionDays;
+  const getRelationRestoreValue = async (versionRelationData, attribute) => {
+    if (Array.isArray(versionRelationData)) {
+      if (versionRelationData.length === 0)
+        return versionRelationData;
+      const existingAndMissingRelations = await Promise.all(
+        versionRelationData.map((relation) => {
+          return strapi2.documents(attribute.target).findOne({
+            documentId: relation.documentId,
+            locale: relation.locale || void 0
+          });
+        })
+      );
+      return existingAndMissingRelations.filter(
+        (relation) => relation !== null
+      );
     }
-    return Math.min(licenseRetentionDays, DEFAULT_RETENTION_DAYS);
+    return strapi2.documents(attribute.target).findOne({
+      documentId: versionRelationData.documentId,
+      locale: versionRelationData.locale || void 0
+    });
+  };
+  const getMediaRestoreValue = async (versionRelationData, attribute) => {
+    if (attribute.multiple) {
+      const existingAndMissingMedias = await Promise.all(
+        // @ts-expect-error Fix the type definitions so this isn't any
+        versionRelationData.map((media) => {
+          return strapi2.db.query("plugin::upload.file").findOne({ where: { id: media.id } });
+        })
+      );
+      return existingAndMissingMedias.filter((media) => media != null);
+    }
+    return strapi2.db.query("plugin::upload.file").findOne({ where: { id: versionRelationData.id } });
   };
   const localesService = strapi2.plugin("i18n")?.service("locales");
   const getDefaultLocale = async () => localesService ? localesService.getDefaultLocale() : null;
@@ -187,6 +212,15 @@ const createHistoryService = ({ strapi: strapi2 }) => {
       {}
     );
   };
+  const getRetentionDays = () => {
+    const featureConfig = strapi2.ee.features.get("cms-content-history");
+    const licenseRetentionDays = typeof featureConfig === "object" && featureConfig?.options.retentionDays;
+    const userRetentionDays = strapi2.config.get("admin.history.retentionDays");
+    if (userRetentionDays && userRetentionDays < licenseRetentionDays) {
+      return userRetentionDays;
+    }
+    return Math.min(licenseRetentionDays, DEFAULT_RETENTION_DAYS);
+  };
   const getVersionStatus = async (contentTypeUid, document) => {
     const documentMetadataService = strapi2.plugin("content-manager").service("document-metadata");
     const meta = await documentMetadataService.getMetadata(contentTypeUid, document);
@@ -228,80 +262,68 @@ const createHistoryService = ({ strapi: strapi2 }) => {
       return acc;
     }, {});
   };
-  return {
-    async bootstrap() {
-      if (state.isInitialized) {
-        return;
-      }
-      strapi2.documents.use(async (context, next) => {
-        if (!strapi2.requestContext.get()?.request.url.startsWith("/content-manager")) {
-          return next();
+  const buildMediaResponse = async (values) => {
+    return values.slice(0, 25).reduce(
+      async (currentRelationDataPromise, entry) => {
+        const currentRelationData = await currentRelationDataPromise;
+        if (!entry) {
+          return currentRelationData;
         }
-        if (context.action !== "create" && context.action !== "update" && context.action !== "publish" && context.action !== "unpublish" && context.action !== "discardDraft") {
-          return next();
+        const relatedEntry = await strapi2.db.query("plugin::upload.file").findOne({ where: { id: entry.id } });
+        if (relatedEntry) {
+          currentRelationData.results.push(relatedEntry);
+        } else {
+          currentRelationData.meta.missingCount += 1;
         }
-        const contentTypeUid = context.contentType.uid;
-        if (!contentTypeUid.startsWith("api::")) {
-          return next();
+        return currentRelationData;
+      },
+      Promise.resolve({
+        results: [],
+        meta: { missingCount: 0 }
+      })
+    );
+  };
+  const buildRelationReponse = async (values, attributeSchema) => {
+    return values.slice(0, 25).reduce(
+      async (currentRelationDataPromise, entry) => {
+        const currentRelationData = await currentRelationDataPromise;
+        if (!entry) {
+          return currentRelationData;
         }
-        const result = await next();
-        const documentContext = context.action === "create" ? { documentId: result.documentId, locale: context.params?.locale } : { documentId: context.params.documentId, locale: context.params?.locale };
-        const defaultLocale = await getDefaultLocale();
-        const locale = documentContext.locale || defaultLocale;
-        const document = await strapi2.documents(contentTypeUid).findOne({
-          documentId: documentContext.documentId,
-          locale,
-          populate: getDeepPopulate2(contentTypeUid)
-        });
-        const status = await getVersionStatus(contentTypeUid, document);
-        const attributesSchema = strapi2.getModel(contentTypeUid).attributes;
-        const componentsSchemas = Object.keys(
-          attributesSchema
-        ).reduce((currentComponentSchemas, key) => {
-          const fieldSchema = attributesSchema[key];
-          if (fieldSchema.type === "component") {
-            const componentSchema = strapi2.getModel(fieldSchema.component).attributes;
-            return {
-              ...currentComponentSchemas,
-              [fieldSchema.component]: componentSchema
-            };
-          }
-          return currentComponentSchemas;
-        }, {});
-        await strapi2.db.transaction(async ({ onCommit }) => {
-          onCommit(() => {
-            this.createVersion({
-              contentType: contentTypeUid,
-              data: fp.omit(FIELDS_TO_IGNORE, document),
-              schema: fp.omit(FIELDS_TO_IGNORE, attributesSchema),
-              componentsSchemas,
-              relatedDocumentId: documentContext.documentId,
-              locale,
-              status
-            });
+        const relatedEntry = await strapi2.documents(attributeSchema.target).findOne({ documentId: entry.documentId, locale: entry.locale || void 0 });
+        if (relatedEntry) {
+          currentRelationData.results.push({
+            ...relatedEntry,
+            status: await getVersionStatus(attributeSchema.target, relatedEntry)
           });
-        });
-        return result;
-      });
-      const retentionDays = getRetentionDays(strapi2);
-      state.deleteExpiredJob = nodeSchedule.scheduleJob("0 0 * * *", () => {
-        const retentionDaysInMilliseconds = retentionDays * 24 * 60 * 60 * 1e3;
-        const expirationDate = new Date(Date.now() - retentionDaysInMilliseconds);
-        query.deleteMany({
-          where: {
-            created_at: {
-              $lt: expirationDate.toISOString()
-            }
-          }
-        });
-      });
-      state.isInitialized = true;
-    },
-    async destroy() {
-      if (state.deleteExpiredJob) {
-        state.deleteExpiredJob.cancel();
-      }
-    },
+        } else {
+          currentRelationData.meta.missingCount += 1;
+        }
+        return currentRelationData;
+      },
+      Promise.resolve({
+        results: [],
+        meta: { missingCount: 0 }
+      })
+    );
+  };
+  return {
+    getSchemaAttributesDiff,
+    getRelationRestoreValue,
+    getMediaRestoreValue,
+    getDefaultLocale,
+    getLocaleDictionary,
+    getRetentionDays,
+    getVersionStatus,
+    getDeepPopulate: getDeepPopulate2,
+    buildMediaResponse,
+    buildRelationReponse
+  };
+};
+const createHistoryService = ({ strapi: strapi2 }) => {
+  const query = strapi2.db.query(HISTORY_VERSION_UID);
+  const serviceUtils = createServiceUtils({ strapi: strapi2 });
+  return {
     async createVersion(historyVersionData) {
       await query.create({
         data: {
@@ -312,7 +334,7 @@ const createHistoryService = ({ strapi: strapi2 }) => {
       });
     },
     async findVersionsPage(params) {
-      const locale = params.query.locale || await getDefaultLocale();
+      const locale = params.query.locale || await serviceUtils.getDefaultLocale();
       const [{ results, pagination }, localeDictionary] = await Promise.all([
         query.findPage({
           ...params.query,
@@ -326,78 +348,34 @@ const createHistoryService = ({ strapi: strapi2 }) => {
           populate: ["createdBy"],
           orderBy: [{ createdAt: "desc" }]
         }),
-        getLocaleDictionary()
+        serviceUtils.getLocaleDictionary()
       ]);
-      const buildRelationReponse = async (values, attributeSchema) => {
-        return values.slice(0, 25).reduce(
-          async (currentRelationDataPromise, entry) => {
-            const currentRelationData = await currentRelationDataPromise;
-            if (!entry) {
-              return currentRelationData;
-            }
-            const relatedEntry = await strapi2.documents(attributeSchema.target).findOne({ documentId: entry.documentId, locale: entry.locale || void 0 });
-            const permissionChecker2 = getService$1("permission-checker").create({
-              userAbility: params.state.userAbility,
-              model: attributeSchema.target
-            });
-            const sanitizedEntry = await permissionChecker2.sanitizeOutput(relatedEntry);
-            if (sanitizedEntry) {
-              currentRelationData.results.push({
-                ...sanitizedEntry,
-                status: await getVersionStatus(attributeSchema.target, sanitizedEntry)
-              });
-            } else {
-              currentRelationData.meta.missingCount += 1;
-            }
-            return currentRelationData;
-          },
-          Promise.resolve({
-            results: [],
-            meta: { missingCount: 0 }
-          })
-        );
-      };
-      const buildMediaResponse = async (values) => {
-        return values.slice(0, 25).reduce(
-          async (currentRelationDataPromise, entry) => {
-            const currentRelationData = await currentRelationDataPromise;
-            if (!entry) {
-              return currentRelationData;
-            }
-            const permissionChecker2 = getService$1("permission-checker").create({
-              userAbility: params.state.userAbility,
-              model: "plugin::upload.file"
-            });
-            const relatedEntry = await strapi2.db.query("plugin::upload.file").findOne({ where: { id: entry.id } });
-            const sanitizedEntry = await permissionChecker2.sanitizeOutput(relatedEntry);
-            if (sanitizedEntry) {
-              currentRelationData.results.push(sanitizedEntry);
-            } else {
-              currentRelationData.meta.missingCount += 1;
-            }
-            return currentRelationData;
-          },
-          Promise.resolve({
-            results: [],
-            meta: { missingCount: 0 }
-          })
-        );
-      };
       const populateEntryRelations = async (entry) => {
         const entryWithRelations = await Object.entries(entry.schema).reduce(
           async (currentDataWithRelations, [attributeKey, attributeSchema]) => {
             const attributeValue = entry.data[attributeKey];
             const attributeValues = Array.isArray(attributeValue) ? attributeValue : [attributeValue];
             if (attributeSchema.type === "media") {
+              const permissionChecker2 = getService$1("permission-checker").create({
+                userAbility: params.state.userAbility,
+                model: "plugin::upload.file"
+              });
+              const response = await serviceUtils.buildMediaResponse(attributeValues);
+              const sanitizedResults = await Promise.all(
+                response.results.map((media) => permissionChecker2.sanitizeOutput(media))
+              );
               return {
                 ...await currentDataWithRelations,
-                [attributeKey]: await buildMediaResponse(attributeValues)
+                [attributeKey]: {
+                  results: sanitizedResults,
+                  meta: response.meta
+                }
               };
             }
             if (attributeSchema.type === "relation" && attributeSchema.relation !== "morphToOne" && attributeSchema.relation !== "morphToMany") {
               if (attributeSchema.target === "admin::user") {
                 const adminUsers = await Promise.all(
-                  attributeValues.map(async (userToPopulate) => {
+                  attributeValues.map((userToPopulate) => {
                     if (userToPopulate == null) {
                       return null;
                     }
@@ -414,9 +392,23 @@ const createHistoryService = ({ strapi: strapi2 }) => {
                   [attributeKey]: adminUsers
                 };
               }
+              const permissionChecker2 = getService$1("permission-checker").create({
+                userAbility: params.state.userAbility,
+                model: attributeSchema.target
+              });
+              const response = await serviceUtils.buildRelationReponse(
+                attributeValues,
+                attributeSchema
+              );
+              const sanitizedResults = await Promise.all(
+                response.results.map((media) => permissionChecker2.sanitizeOutput(media))
+              );
               return {
                 ...await currentDataWithRelations,
-                [attributeKey]: await buildRelationReponse(attributeValues, attributeSchema)
+                [attributeKey]: {
+                  results: sanitizedResults,
+                  meta: response.meta
+                }
               };
             }
             return currentDataWithRelations;
@@ -431,7 +423,7 @@ const createHistoryService = ({ strapi: strapi2 }) => {
             ...result,
             data: await populateEntryRelations(result),
             meta: {
-              unknownAttributes: getSchemaAttributesDiff(
+              unknownAttributes: serviceUtils.getSchemaAttributesDiff(
                 result.schema,
                 strapi2.getModel(params.query.contentType).attributes
               )
@@ -448,7 +440,10 @@ const createHistoryService = ({ strapi: strapi2 }) => {
     async restoreVersion(versionId) {
       const version = await query.findOne({ where: { id: versionId } });
       const contentTypeSchemaAttributes = strapi2.getModel(version.contentType).attributes;
-      const schemaDiff = getSchemaAttributesDiff(version.schema, contentTypeSchemaAttributes);
+      const schemaDiff = serviceUtils.getSchemaAttributesDiff(
+        version.schema,
+        contentTypeSchemaAttributes
+      );
       const dataWithoutAddedAttributes = Object.keys(schemaDiff.added).reduce(
         (currentData, addedKey) => {
           currentData[addedKey] = null;
@@ -461,61 +456,26 @@ const createHistoryService = ({ strapi: strapi2 }) => {
         FIELDS_TO_IGNORE,
         contentTypeSchemaAttributes
       );
-      const dataWithoutMissingRelations = await Object.entries(sanitizedSchemaAttributes).reduce(
-        async (previousRelationAttributesPromise, [name, attribute]) => {
-          const previousRelationAttributes = await previousRelationAttributesPromise;
-          const relationData = version.data[name];
-          if (relationData === null) {
+      const reducer = strapiUtils.async.reduce(Object.entries(sanitizedSchemaAttributes));
+      const dataWithoutMissingRelations = await reducer(
+        async (previousRelationAttributes, [name, attribute]) => {
+          const versionRelationData = version.data[name];
+          if (!versionRelationData) {
             return previousRelationAttributes;
           }
           if (attribute.type === "relation" && // TODO: handle polymorphic relations
           attribute.relation !== "morphToOne" && attribute.relation !== "morphToMany") {
-            if (Array.isArray(relationData)) {
-              if (relationData.length === 0)
-                return previousRelationAttributes;
-              const existingAndMissingRelations = await Promise.all(
-                relationData.map((relation) => {
-                  return strapi2.documents(attribute.target).findOne({
-                    documentId: relation.documentId,
-                    locale: relation.locale || void 0
-                  });
-                })
-              );
-              const existingRelations = existingAndMissingRelations.filter(
-                (relation) => relation !== null
-              );
-              previousRelationAttributes[name] = existingRelations;
-            } else {
-              const existingRelation = await strapi2.documents(attribute.target).findOne({
-                documentId: relationData.documentId,
-                locale: relationData.locale || void 0
-              });
-              if (!existingRelation) {
-                previousRelationAttributes[name] = null;
-              }
-            }
+            const data2 = await serviceUtils.getRelationRestoreValue(versionRelationData, attribute);
+            previousRelationAttributes[name] = data2;
           }
           if (attribute.type === "media") {
-            if (attribute.multiple) {
-              const existingAndMissingMedias = await Promise.all(
-                // @ts-expect-error Fix the type definitions so this isn't any
-                relationData.map((media) => {
-                  return strapi2.db.query("plugin::upload.file").findOne({ where: { id: media.id } });
-                })
-              );
-              const existingMedias = existingAndMissingMedias.filter((media) => media != null);
-              previousRelationAttributes[name] = existingMedias;
-            } else {
-              const existingMedia = await strapi2.db.query("plugin::upload.file").findOne({ where: { id: version.data[name].id } });
-              if (!existingMedia) {
-                previousRelationAttributes[name] = null;
-              }
-            }
+            const data2 = await serviceUtils.getMediaRestoreValue(versionRelationData, attribute);
+            previousRelationAttributes[name] = data2;
           }
           return previousRelationAttributes;
         },
         // Clone to avoid mutating the original version data
-        Promise.resolve(structuredClone(dataWithoutAddedAttributes))
+        structuredClone(dataWithoutAddedAttributes)
       );
       const data = fp.omit(["id", ...Object.keys(schemaDiff.removed)], dataWithoutMissingRelations);
       const restoredDocument = await strapi2.documents(version.contentType).update({
@@ -530,8 +490,93 @@ const createHistoryService = ({ strapi: strapi2 }) => {
     }
   };
 };
+const createLifecyclesService = ({ strapi: strapi2 }) => {
+  const state = {
+    deleteExpiredJob: null,
+    isInitialized: false
+  };
+  const query = strapi2.db.query(HISTORY_VERSION_UID);
+  const historyService = getService(strapi2, "history");
+  const serviceUtils = createServiceUtils({ strapi: strapi2 });
+  return {
+    async bootstrap() {
+      if (state.isInitialized) {
+        return;
+      }
+      strapi2.documents.use(async (context, next) => {
+        if (!strapi2.requestContext.get()?.request.url.startsWith("/content-manager")) {
+          return next();
+        }
+        if (context.action !== "create" && context.action !== "update" && context.action !== "publish" && context.action !== "unpublish" && context.action !== "discardDraft") {
+          return next();
+        }
+        const contentTypeUid = context.contentType.uid;
+        if (!contentTypeUid.startsWith("api::")) {
+          return next();
+        }
+        const result = await next();
+        const documentContext = context.action === "create" ? { documentId: result.documentId, locale: context.params?.locale } : { documentId: context.params.documentId, locale: context.params?.locale };
+        const defaultLocale = await serviceUtils.getDefaultLocale();
+        const locale = documentContext.locale || defaultLocale;
+        const document = await strapi2.documents(contentTypeUid).findOne({
+          documentId: documentContext.documentId,
+          locale,
+          populate: serviceUtils.getDeepPopulate(contentTypeUid)
+        });
+        const status = await serviceUtils.getVersionStatus(contentTypeUid, document);
+        const attributesSchema = strapi2.getModel(contentTypeUid).attributes;
+        const componentsSchemas = Object.keys(
+          attributesSchema
+        ).reduce((currentComponentSchemas, key) => {
+          const fieldSchema = attributesSchema[key];
+          if (fieldSchema.type === "component") {
+            const componentSchema = strapi2.getModel(fieldSchema.component).attributes;
+            return {
+              ...currentComponentSchemas,
+              [fieldSchema.component]: componentSchema
+            };
+          }
+          return currentComponentSchemas;
+        }, {});
+        await strapi2.db.transaction(async ({ onCommit }) => {
+          onCommit(() => {
+            historyService.createVersion({
+              contentType: contentTypeUid,
+              data: fp.omit(FIELDS_TO_IGNORE, document),
+              schema: fp.omit(FIELDS_TO_IGNORE, attributesSchema),
+              componentsSchemas,
+              relatedDocumentId: documentContext.documentId,
+              locale,
+              status
+            });
+          });
+        });
+        return result;
+      });
+      const retentionDays = serviceUtils.getRetentionDays();
+      state.deleteExpiredJob = nodeSchedule.scheduleJob("0 0 * * *", () => {
+        const retentionDaysInMilliseconds = retentionDays * 24 * 60 * 60 * 1e3;
+        const expirationDate = new Date(Date.now() - retentionDaysInMilliseconds);
+        query.deleteMany({
+          where: {
+            created_at: {
+              $lt: expirationDate.toISOString()
+            }
+          }
+        });
+      });
+      state.isInitialized = true;
+    },
+    async destroy() {
+      if (state.deleteExpiredJob) {
+        state.deleteExpiredJob.cancel();
+      }
+    }
+  };
+};
 const services$1 = {
-  history: createHistoryService
+  history: createHistoryService,
+  lifecycles: createLifecyclesService
 };
 const info = { pluginName: "content-manager", type: "admin" };
 const historyVersionRouter = {
@@ -611,10 +656,10 @@ const getFeature = () => {
         strapi2.get("models").add(historyVersion);
       },
       bootstrap({ strapi: strapi2 }) {
-        getService(strapi2, "history").bootstrap();
+        getService(strapi2, "lifecycles").bootstrap();
       },
       destroy({ strapi: strapi2 }) {
-        getService(strapi2, "history").destroy();
+        getService(strapi2, "lifecycles").destroy();
       },
       controllers: controllers$1,
       services: services$1,
@@ -1433,7 +1478,7 @@ const { PaginationError, ValidationError } = strapiUtils.errors;
 const TYPES = ["singleType", "collectionType"];
 const kindSchema = strapiUtils.yup.string().oneOf(TYPES).nullable();
 const bulkActionInputSchema = strapiUtils.yup.object({
-  ids: strapiUtils.yup.array().of(strapiUtils.yup.strapiID()).min(1).required()
+  documentIds: strapiUtils.yup.array().of(strapiUtils.yup.strapiID()).min(1).required()
 }).required();
 const generateUIDInputSchema = strapiUtils.yup.object({
   contentTypeUID: strapiUtils.yup.string().required(),
@@ -1809,17 +1854,18 @@ const collectionTypes = {
     const { userAbility } = ctx.state;
     const { model } = ctx.params;
     const { body } = ctx.request;
-    const { ids } = body;
+    const { documentIds } = body;
     await validateBulkActionInput(body);
     const documentManager2 = getService$1("document-manager");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.publish()) {
       return ctx.forbidden();
     }
-    const permissionQuery = await permissionChecker2.sanitizedQuery.publish(ctx.query);
-    const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).populateDeep(Infinity).countRelations().build();
-    const entityPromises = ids.map((id) => documentManager2.findOne(id, model, { populate }));
-    const entities = await Promise.all(entityPromises);
+    const { locale } = getDocumentLocaleAndStatus(body);
+    const entityPromises = documentIds.map(
+      (documentId) => documentManager2.findLocales(documentId, model, { locale, isPublished: false })
+    );
+    const entities = (await Promise.all(entityPromises)).flat();
     for (const entity of entities) {
       if (!entity) {
         return ctx.notFound();
@@ -1828,24 +1874,26 @@ const collectionTypes = {
         return ctx.forbidden();
       }
     }
-    const { count } = await documentManager2.publishMany(entities, model);
+    const entitiesIds = entities.map((document) => document.documentId);
+    const { count } = await documentManager2.publishMany(entitiesIds, model, { locale });
     ctx.body = { count };
   },
   async bulkUnpublish(ctx) {
     const { userAbility } = ctx.state;
     const { model } = ctx.params;
     const { body } = ctx.request;
-    const { ids } = body;
+    const { documentIds } = body;
     await validateBulkActionInput(body);
     const documentManager2 = getService$1("document-manager");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.unpublish()) {
       return ctx.forbidden();
     }
-    const permissionQuery = await permissionChecker2.sanitizedQuery.publish(ctx.query);
-    const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-    const entityPromises = ids.map((id) => documentManager2.findOne(id, model, { populate }));
-    const entities = await Promise.all(entityPromises);
+    const { locale } = getDocumentLocaleAndStatus(body);
+    const entityPromises = documentIds.map(
+      (documentId) => documentManager2.findLocales(documentId, model, { locale, isPublished: true })
+    );
+    const entities = (await Promise.all(entityPromises)).flat();
     for (const entity of entities) {
       if (!entity) {
         return ctx.notFound();
@@ -1854,7 +1902,8 @@ const collectionTypes = {
         return ctx.forbidden();
       }
     }
-    const { count } = await documentManager2.unpublishMany(entities, model);
+    const entitiesIds = entities.map((document) => document.documentId);
+    const { count } = await documentManager2.unpublishMany(entitiesIds, model, { locale });
     ctx.body = { count };
   },
   async unpublish(ctx) {
@@ -1934,7 +1983,7 @@ const collectionTypes = {
     const { userAbility } = ctx.state;
     const { model } = ctx.params;
     const { query, body } = ctx.request;
-    const { ids } = body;
+    const { documentIds } = body;
     await validateBulkActionInput(body);
     const documentManager2 = getService$1("document-manager");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
@@ -1942,14 +1991,22 @@ const collectionTypes = {
       return ctx.forbidden();
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.delete(query);
-    const idsWhereClause = { id: { $in: ids } };
-    const params = {
-      ...permissionQuery,
-      filters: {
-        $and: [idsWhereClause].concat(permissionQuery.filters || [])
+    const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
+    const { locale } = getDocumentLocaleAndStatus(body);
+    const documentLocales = await documentManager2.findLocales(documentIds, model, {
+      populate,
+      locale
+    });
+    if (documentLocales.length === 0) {
+      return ctx.notFound();
+    }
+    for (const document of documentLocales) {
+      if (permissionChecker2.cannot.delete(document)) {
+        return ctx.forbidden();
       }
-    };
-    const { count } = await documentManager2.deleteMany(params, model);
+    }
+    const localeDocumentsIds = documentLocales.map((document) => document.documentId);
+    const { count } = await documentManager2.deleteMany(localeDocumentsIds, model, { locale });
     ctx.body = { count };
   },
   async countDraftRelations(ctx) {
@@ -1977,27 +2034,26 @@ const collectionTypes = {
   },
   async countManyEntriesDraftRelations(ctx) {
     const { userAbility } = ctx.state;
-    const ids = ctx.request.query.ids;
-    const locale = ctx.request.query.locale;
+    const { documentIds, locale } = ctx.request.query;
     const { model } = ctx.params;
     const documentManager2 = getService$1("document-manager");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.read()) {
       return ctx.forbidden();
     }
-    const entities = await documentManager2.findMany(
+    const documents = await documentManager2.findMany(
       {
         filters: {
-          id: ids
+          documentId: { $in: documentIds }
         },
         locale
       },
       model
     );
-    if (!entities) {
+    if (!documents) {
       return ctx.notFound();
     }
-    const number = await documentManager2.countManyEntriesDraftRelations(ids, model, locale);
+    const number = await documentManager2.countManyEntriesDraftRelations(documentIds, model, locale);
     return {
       data: number
     };
@@ -3997,26 +4053,9 @@ const sumDraftCounts = (entity, uid2) => {
   }, 0);
 };
 const { ApplicationError } = strapiUtils.errors;
-const { ENTRY_PUBLISH, ENTRY_UNPUBLISH } = ALLOWED_WEBHOOK_EVENTS;
 const { PUBLISHED_AT_ATTRIBUTE } = strapiUtils.contentTypes.constants;
 const omitPublishedAtField = fp.omit(PUBLISHED_AT_ATTRIBUTE);
 const omitIdField = fp.omit("id");
-const emitEvent = async (uid2, event, document) => {
-  const modelDef = strapi.getModel(uid2);
-  const sanitizedDocument = await strapiUtils.sanitize.sanitizers.defaultSanitizeOutput(
-    {
-      schema: modelDef,
-      getModel(uid22) {
-        return strapi.getModel(uid22);
-      }
-    },
-    document
-  );
-  strapi.eventHub.emit(event, {
-    model: modelDef.modelName,
-    entry: sanitizedDocument
-  });
-};
 const documentManager = ({ strapi: strapi2 }) => {
   return {
     async findOne(id, uid2, opts = {}) {
@@ -4035,6 +4074,9 @@ const documentManager = ({ strapi: strapi2 }) => {
       } else if (opts.locale && opts.locale !== "*") {
         where.locale = opts.locale;
       }
+      if (typeof opts.isPublished === "boolean") {
+        where.publishedAt = { $notNull: opts.isPublished };
+      }
       return strapi2.db.query(uid2).findMany({ populate: opts.populate, where });
     },
     async findMany(opts, uid2) {
@@ -4042,20 +4084,16 @@ const documentManager = ({ strapi: strapi2 }) => {
       return strapi2.documents(uid2).findMany(params);
     },
     async findPage(opts, uid2) {
-      const page = Number(opts?.page) || 1;
-      const pageSize = Number(opts?.pageSize) || 10;
+      const params = strapiUtils.pagination.withDefaultPagination(opts || {}, {
+        maxLimit: 1e3
+      });
       const [documents, total = 0] = await Promise.all([
-        strapi2.documents(uid2).findMany(opts),
-        strapi2.documents(uid2).count(opts)
+        strapi2.documents(uid2).findMany(params),
+        strapi2.documents(uid2).count(params)
       ]);
       return {
         results: documents,
-        pagination: {
-          page,
-          pageSize,
-          pageCount: Math.ceil(total / pageSize),
-          total
-        }
+        pagination: strapiUtils.pagination.transformPagedPaginationInfo(params, total)
       };
     },
     async create(uid2, opts = {}) {
@@ -4101,70 +4139,38 @@ const documentManager = ({ strapi: strapi2 }) => {
       return {};
     },
     // FIXME: handle relations
-    async deleteMany(opts, uid2) {
-      const docs = await strapi2.documents(uid2).findMany(opts);
-      for (const doc of docs) {
-        await strapi2.documents(uid2).delete({ documentId: doc.documentId });
-      }
-      return { count: docs.length };
+    async deleteMany(documentIds, uid2, opts) {
+      const deletedEntries = await strapi2.db.transaction(async () => {
+        return Promise.all(documentIds.map(async (id) => this.delete(id, uid2, opts)));
+      });
+      return { count: deletedEntries.length };
     },
     async publish(id, uid2, opts = {}) {
       const populate = await buildDeepPopulate(uid2);
       const params = { ...opts, populate };
       return strapi2.documents(uid2).publish({ ...params, documentId: id }).then((result) => result?.entries.at(0));
     },
-    async publishMany(entities, uid2) {
-      if (!entities.length) {
-        return null;
-      }
-      await Promise.all(
-        entities.map((document) => {
-          return strapi2.entityValidator.validateEntityCreation(
-            strapi2.getModel(uid2),
-            document,
-            void 0,
-            // @ts-expect-error - FIXME: entity here is unnecessary
-            document
-          );
-        })
-      );
-      const entitiesToPublish = entities.filter((doc) => !doc[PUBLISHED_AT_ATTRIBUTE]).map((doc) => doc.id);
-      const filters = { id: { $in: entitiesToPublish } };
-      const data = { [PUBLISHED_AT_ATTRIBUTE]: /* @__PURE__ */ new Date() };
-      const populate = await buildDeepPopulate(uid2);
-      const publishedEntitiesCount = await strapi2.db.query(uid2).updateMany({
-        where: filters,
-        data
-      });
-      const publishedEntities = await strapi2.db.query(uid2).findMany({
-        where: filters,
-        populate
+    async publishMany(documentIds, uid2, opts = {}) {
+      const publishedEntries = await strapi2.db.transaction(async () => {
+        return Promise.all(
+          documentIds.map(
+            (id) => strapi2.documents(uid2).publish({ ...opts, documentId: id }).then((result) => result?.entries)
+          )
+        );
       });
-      await Promise.all(
-        publishedEntities.map((doc) => emitEvent(uid2, ENTRY_PUBLISH, doc))
-      );
-      return publishedEntitiesCount;
+      const publishedEntitiesCount = publishedEntries.flat().filter(Boolean).length;
+      return { count: publishedEntitiesCount };
     },
-    async unpublishMany(documents, uid2) {
-      if (!documents.length) {
-        return null;
-      }
-      const entitiesToUnpublish = documents.filter((doc) => doc[PUBLISHED_AT_ATTRIBUTE]).map((doc) => doc.id);
-      const filters = { id: { $in: entitiesToUnpublish } };
-      const data = { [PUBLISHED_AT_ATTRIBUTE]: null };
-      const populate = await buildDeepPopulate(uid2);
-      const unpublishedEntitiesCount = await strapi2.db.query(uid2).updateMany({
-        where: filters,
-        data
-      });
-      const unpublishedEntities = await strapi2.db.query(uid2).findMany({
-        where: filters,
-        populate
+    async unpublishMany(documentIds, uid2, opts = {}) {
+      const unpublishedEntries = await strapi2.db.transaction(async () => {
+        return Promise.all(
+          documentIds.map(
+            (id) => strapi2.documents(uid2).unpublish({ ...opts, documentId: id }).then((result) => result?.entries)
+          )
+        );
       });
-      await Promise.all(
-        unpublishedEntities.map((doc) => emitEvent(uid2, ENTRY_UNPUBLISH, doc))
-      );
-      return unpublishedEntitiesCount;
+      const unpublishedEntitiesCount = unpublishedEntries.flat().filter(Boolean).length;
+      return { count: unpublishedEntitiesCount };
     },
     async unpublish(id, uid2, opts = {}) {
       const populate = await buildDeepPopulate(uid2);
@@ -4189,19 +4195,19 @@ const documentManager = ({ strapi: strapi2 }) => {
       }
       return sumDraftCounts(document, uid2);
     },
-    async countManyEntriesDraftRelations(ids, uid2, locale) {
+    async countManyEntriesDraftRelations(documentIds, uid2, locale) {
       const { populate, hasRelations } = getDeepPopulateDraftCount(uid2);
       if (!hasRelations) {
         return 0;
       }
-      const entities = await strapi2.db.query(uid2).findMany({
+      const documents = await strapi2.documents(uid2).findMany({
         populate,
-        where: {
-          id: { $in: ids },
-          ...locale ? { locale } : {}
-        }
+        filters: {
+          documentId: documentIds
+        },
+        locale
       });
-      const totalNumberDraftRelations = entities.reduce(
+      const totalNumberDraftRelations = documents.reduce(
         (count, entity) => sumDraftCounts(entity, uid2) + count,
         0
       );