@strapi/content-manager 0.0.0-experimental.a65a85fdea97faae8679d3ffc5f9d79af61abd26 → 0.0.0-experimental.abc

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,25 +212,39 @@ 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);
     return documentMetadataService.getStatus(document, meta.availableStatus);
   };
-  const getDeepPopulate2 = (uid2) => {
+  const getDeepPopulate2 = (uid2, useDatabaseSyntax = false) => {
     const model = strapi2.getModel(uid2);
     const attributes = Object.entries(model.attributes);
+    const fieldSelector = useDatabaseSyntax ? "select" : "fields";
     return attributes.reduce((acc, [attributeName, attribute]) => {
       switch (attribute.type) {
         case "relation": {
+          const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+          if (isMorphRelation) {
+            break;
+          }
           const isVisible2 = strapiUtils.contentTypes.isVisibleAttribute(model, attributeName);
           if (isVisible2) {
-            acc[attributeName] = { fields: ["documentId", "locale", "publishedAt"] };
+            acc[attributeName] = { [fieldSelector]: ["documentId", "locale", "publishedAt"] };
           }
           break;
         }
         case "media": {
-          acc[attributeName] = { fields: ["id"] };
+          acc[attributeName] = { [fieldSelector]: ["id"] };
           break;
         }
         case "component": {
@@ -228,80 +267,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 +339,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 +353,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 +397,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 +428,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 +445,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 +461,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 +495,118 @@ const createHistoryService = ({ strapi: strapi2 }) => {
     }
   };
 };
+const shouldCreateHistoryVersion = (context) => {
+  if (!strapi.requestContext.get()?.request.url.startsWith("/content-manager")) {
+    return false;
+  }
+  if (context.action !== "create" && context.action !== "update" && context.action !== "clone" && context.action !== "publish" && context.action !== "unpublish" && context.action !== "discardDraft") {
+    return false;
+  }
+  if (context.action === "update" && strapi.requestContext.get()?.request.url.endsWith("/actions/publish")) {
+    return false;
+  }
+  if (!context.contentType.uid.startsWith("api::")) {
+    return false;
+  }
+  return true;
+};
+const getSchemas = (uid2) => {
+  const attributesSchema = strapi.getModel(uid2).attributes;
+  const componentsSchemas = Object.keys(attributesSchema).reduce(
+    (currentComponentSchemas, key) => {
+      const fieldSchema = attributesSchema[key];
+      if (fieldSchema.type === "component") {
+        const componentSchema = strapi.getModel(fieldSchema.component).attributes;
+        return {
+          ...currentComponentSchemas,
+          [fieldSchema.component]: componentSchema
+        };
+      }
+      return currentComponentSchemas;
+    },
+    {}
+  );
+  return {
+    schema: fp.omit(FIELDS_TO_IGNORE, attributesSchema),
+    componentsSchemas
+  };
+};
+const createLifecyclesService = ({ strapi: strapi2 }) => {
+  const state = {
+    deleteExpiredJob: null,
+    isInitialized: false
+  };
+  const serviceUtils = createServiceUtils({ strapi: strapi2 });
+  return {
+    async bootstrap() {
+      if (state.isInitialized) {
+        return;
+      }
+      strapi2.documents.use(async (context, next) => {
+        const result = await next();
+        if (!shouldCreateHistoryVersion(context)) {
+          return result;
+        }
+        const documentId = context.action === "create" || context.action === "clone" ? result.documentId : context.params.documentId;
+        const defaultLocale = await serviceUtils.getDefaultLocale();
+        const locales = fp.castArray(context.params?.locale || defaultLocale);
+        if (!locales.length) {
+          return result;
+        }
+        const uid2 = context.contentType.uid;
+        const schemas = getSchemas(uid2);
+        const localeEntries = await strapi2.db.query(uid2).findMany({
+          where: {
+            documentId,
+            locale: { $in: locales },
+            publishedAt: null
+          },
+          populate: serviceUtils.getDeepPopulate(
+            uid2,
+            true
+            /* use database syntax */
+          )
+        });
+        await strapi2.db.transaction(async ({ onCommit }) => {
+          onCommit(async () => {
+            for (const entry of localeEntries) {
+              const status = await serviceUtils.getVersionStatus(uid2, entry);
+              await getService(strapi2, "history").createVersion({
+                contentType: uid2,
+                data: fp.omit(FIELDS_TO_IGNORE, entry),
+                relatedDocumentId: documentId,
+                locale: entry.locale,
+                status,
+                ...schemas
+              });
+            }
+          });
+        });
+        return result;
+      });
+      state.deleteExpiredJob = nodeSchedule.scheduleJob("0 0 * * *", () => {
+        const retentionDaysInMilliseconds = serviceUtils.getRetentionDays() * 24 * 60 * 60 * 1e3;
+        const expirationDate = new Date(Date.now() - retentionDaysInMilliseconds);
+        strapi2.db.query(HISTORY_VERSION_UID).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 +686,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 +1508,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(),
@@ -1532,15 +1607,49 @@ const excludeNotCreatableFields = (uid2, permissionChecker2) => (body, path = []
     }
   }, body);
 };
-const getDocumentLocaleAndStatus = (request) => {
-  const { locale, status, ...rest } = request || {};
-  if (!fp.isNil(locale) && typeof locale !== "string") {
-    throw new strapiUtils.errors.ValidationError(`Invalid locale: ${locale}`);
-  }
-  if (!fp.isNil(status) && !["draft", "published"].includes(status)) {
-    throw new strapiUtils.errors.ValidationError(`Invalid status: ${status}`);
+const singleLocaleSchema = strapiUtils.yup.string().nullable();
+const multipleLocaleSchema = strapiUtils.yup.lazy(
+  (value) => Array.isArray(value) ? strapiUtils.yup.array().of(singleLocaleSchema.required()) : singleLocaleSchema
+);
+const statusSchema = strapiUtils.yup.mixed().oneOf(["draft", "published"], "Invalid status");
+const getDocumentLocaleAndStatus = async (request, model, opts = { allowMultipleLocales: false }) => {
+  const { allowMultipleLocales } = opts;
+  const { locale, status: providedStatus, ...rest } = request || {};
+  const defaultStatus = strapiUtils.contentTypes.hasDraftAndPublish(strapi.getModel(model)) ? void 0 : "published";
+  const status = providedStatus !== void 0 ? providedStatus : defaultStatus;
+  const schema = strapiUtils.yup.object().shape({
+    locale: allowMultipleLocales ? multipleLocaleSchema : singleLocaleSchema,
+    status: statusSchema
+  });
+  try {
+    await strapiUtils.validateYupSchema(schema, { strict: true, abortEarly: false })(request);
+    return { locale, status, ...rest };
+  } catch (error) {
+    throw new strapiUtils.errors.ValidationError(`Validation error: ${error.message}`);
   }
-  return { locale, status, ...rest };
+};
+const formatDocumentWithMetadata = async (permissionChecker2, uid2, document, opts = {}) => {
+  const documentMetadata2 = getService$1("document-metadata");
+  const serviceOutput = await documentMetadata2.formatDocumentWithMetadata(uid2, document, opts);
+  let {
+    meta: { availableLocales, availableStatus }
+  } = serviceOutput;
+  const metadataSanitizer = permissionChecker2.sanitizeOutput;
+  availableLocales = await strapiUtils.async.map(
+    availableLocales,
+    async (localeDocument) => metadataSanitizer(localeDocument)
+  );
+  availableStatus = await strapiUtils.async.map(
+    availableStatus,
+    async (statusDocument) => metadataSanitizer(statusDocument)
+  );
+  return {
+    ...serviceOutput,
+    meta: {
+      availableLocales,
+      availableStatus
+    }
+  };
 };
 const createDocument = async (ctx, opts) => {
   const { userAbility, user } = ctx.state;
@@ -1555,7 +1664,7 @@ const createDocument = async (ctx, opts) => {
   const setCreator = strapiUtils.setCreatorFields({ user });
   const sanitizeFn = strapiUtils.async.pipe(pickPermittedFields, setCreator);
   const sanitizedBody = await sanitizeFn(body);
-  const { locale, status = "draft" } = getDocumentLocaleAndStatus(body);
+  const { locale, status } = await getDocumentLocaleAndStatus(body, model);
   return documentManager2.create(model, {
     data: sanitizedBody,
     locale,
@@ -1574,7 +1683,7 @@ const updateDocument = async (ctx, opts) => {
   }
   const permissionQuery = await permissionChecker2.sanitizedQuery.update(ctx.query);
   const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-  const { locale } = getDocumentLocaleAndStatus(body);
+  const { locale } = await getDocumentLocaleAndStatus(body, model);
   const [documentVersion, documentExists] = await Promise.all([
     documentManager2.findOne(id, model, { populate, locale, status: "draft" }),
     documentManager2.exists(model, id)
@@ -1612,7 +1721,7 @@ const collectionTypes = {
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.read(query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).populateDeep(1).countRelations({ toOne: false, toMany: true }).build();
-    const { locale, status } = getDocumentLocaleAndStatus(query);
+    const { locale, status } = await getDocumentLocaleAndStatus(query, model);
     const { results: documents, pagination } = await documentManager2.findPage(
       { ...permissionQuery, populate, locale, status },
       model
@@ -1641,14 +1750,13 @@ const collectionTypes = {
     const { userAbility } = ctx.state;
     const { model, id } = ctx.params;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.read()) {
       return ctx.forbidden();
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.read(ctx.query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).populateDeep(Infinity).countRelations().build();
-    const { locale, status = "draft" } = getDocumentLocaleAndStatus(ctx.query);
+    const { locale, status } = await getDocumentLocaleAndStatus(ctx.query, model);
     const version = await documentManager2.findOne(id, model, {
       populate,
       locale,
@@ -1659,8 +1767,10 @@ const collectionTypes = {
       if (!exists) {
         return ctx.notFound();
       }
-      const { meta } = await documentMetadata2.formatDocumentWithMetadata(
+      const { meta } = await formatDocumentWithMetadata(
+        permissionChecker2,
         model,
+        // @ts-expect-error TODO: fix
         { id, locale, publishedAt: null },
         { availableLocales: true, availableStatus: false }
       );
@@ -1671,12 +1781,11 @@ const collectionTypes = {
       return ctx.forbidden();
     }
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(version);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument);
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument);
   },
   async create(ctx) {
     const { userAbility } = ctx.state;
     const { model } = ctx.params;
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     const [totalEntries, document] = await Promise.all([
       strapi.db.query(model).count(),
@@ -1684,7 +1793,7 @@ const collectionTypes = {
     ]);
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(document);
     ctx.status = 201;
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument, {
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument, {
       // Empty metadata as it's not relevant for a new document
       availableLocales: false,
       availableStatus: false
@@ -1698,25 +1807,23 @@ const collectionTypes = {
   async update(ctx) {
     const { userAbility } = ctx.state;
     const { model } = ctx.params;
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     const updatedVersion = await updateDocument(ctx);
     const sanitizedVersion = await permissionChecker2.sanitizeOutput(updatedVersion);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedVersion);
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedVersion);
   },
   async clone(ctx) {
     const { userAbility, user } = ctx.state;
     const { model, sourceId: id } = ctx.params;
     const { body } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.create()) {
       return ctx.forbidden();
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.create(ctx.query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-    const { locale } = getDocumentLocaleAndStatus(body);
+    const { locale } = await getDocumentLocaleAndStatus(body, model);
     const document = await documentManager2.findOne(id, model, {
       populate,
       locale,
@@ -1732,7 +1839,7 @@ const collectionTypes = {
     const sanitizedBody = await sanitizeFn(body);
     const clonedDocument = await documentManager2.clone(document.documentId, sanitizedBody, model);
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(clonedDocument);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument, {
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument, {
       // Empty metadata as it's not relevant for a new document
       availableLocales: false,
       availableStatus: false
@@ -1761,7 +1868,7 @@ const collectionTypes = {
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.delete(ctx.query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-    const { locale } = getDocumentLocaleAndStatus(ctx.query);
+    const { locale } = await getDocumentLocaleAndStatus(ctx.query, model);
     const documentLocales = await documentManager2.findLocales(id, model, { populate, locale });
     if (documentLocales.length === 0) {
       return ctx.notFound();
@@ -1783,7 +1890,6 @@ const collectionTypes = {
     const { id, model } = ctx.params;
     const { body } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.publish()) {
       return ctx.forbidden();
@@ -1791,25 +1897,46 @@ const collectionTypes = {
     const publishedDocument = await strapi.db.transaction(async () => {
       const permissionQuery = await permissionChecker2.sanitizedQuery.publish(ctx.query);
       const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).populateDeep(Infinity).countRelations().build();
-      const document = id ? await updateDocument(ctx, { populate }) : await createDocument(ctx, { populate });
+      let document;
+      const { locale } = await getDocumentLocaleAndStatus(body, model);
+      const isCreate = fp.isNil(id);
+      if (isCreate) {
+        if (permissionChecker2.cannot.create()) {
+          throw new strapiUtils.errors.ForbiddenError();
+        }
+        document = await createDocument(ctx, { populate });
+      }
+      const isUpdate = !isCreate;
+      if (isUpdate) {
+        document = await documentManager2.findOne(id, model, { populate, locale });
+        if (!document) {
+          throw new strapiUtils.errors.NotFoundError("Document not found");
+        }
+        if (permissionChecker2.can.update(document)) {
+          await updateDocument(ctx);
+        }
+      }
       if (permissionChecker2.cannot.publish(document)) {
         throw new strapiUtils.errors.ForbiddenError();
       }
-      const { locale } = getDocumentLocaleAndStatus(body);
-      return documentManager2.publish(document.documentId, model, {
+      const publishResult = await documentManager2.publish(document.documentId, model, {
         locale
         // TODO: Allow setting creator fields on publish
         // data: setCreatorFields({ user, isEdition: true })({}),
       });
+      if (!publishResult || publishResult.length === 0) {
+        throw new strapiUtils.errors.NotFoundError("Document not found or already published.");
+      }
+      return publishResult[0];
     });
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(publishedDocument);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument);
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument);
   },
   async bulkPublish(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 });
@@ -1818,8 +1945,13 @@ const collectionTypes = {
     }
     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 } = await getDocumentLocaleAndStatus(body, model, {
+      allowMultipleLocales: true
+    });
+    const entityPromises = documentIds.map(
+      (documentId) => documentManager2.findLocales(documentId, model, { populate, locale, isPublished: false })
+    );
+    const entities = (await Promise.all(entityPromises)).flat();
     for (const entity of entities) {
       if (!entity) {
         return ctx.notFound();
@@ -1828,24 +1960,25 @@ const collectionTypes = {
         return ctx.forbidden();
       }
     }
-    const { count } = await documentManager2.publishMany(entities, model);
+    const count = await documentManager2.publishMany(model, documentIds, 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 } = await getDocumentLocaleAndStatus(body, model);
+    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 +1987,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) {
@@ -1864,7 +1998,6 @@ const collectionTypes = {
       body: { discardDraft, ...body }
     } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.unpublish()) {
       return ctx.forbidden();
@@ -1874,7 +2007,7 @@ const collectionTypes = {
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.unpublish(ctx.query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-    const { locale } = getDocumentLocaleAndStatus(body);
+    const { locale } = await getDocumentLocaleAndStatus(body, model);
     const document = await documentManager2.findOne(id, model, {
       populate,
       locale,
@@ -1896,7 +2029,7 @@ const collectionTypes = {
       ctx.body = await strapiUtils.async.pipe(
         (document2) => documentManager2.unpublish(document2.documentId, model, { locale }),
         permissionChecker2.sanitizeOutput,
-        (document2) => documentMetadata2.formatDocumentWithMetadata(model, document2)
+        (document2) => formatDocumentWithMetadata(permissionChecker2, model, document2)
       )(document);
     });
   },
@@ -1905,14 +2038,13 @@ const collectionTypes = {
     const { id, model } = ctx.params;
     const { body } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.discard()) {
       return ctx.forbidden();
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.discard(ctx.query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-    const { locale } = getDocumentLocaleAndStatus(body);
+    const { locale } = await getDocumentLocaleAndStatus(body, model);
     const document = await documentManager2.findOne(id, model, {
       populate,
       locale,
@@ -1927,14 +2059,14 @@ const collectionTypes = {
     ctx.body = await strapiUtils.async.pipe(
       (document2) => documentManager2.discardDraft(document2.documentId, model, { locale }),
       permissionChecker2.sanitizeOutput,
-      (document2) => documentMetadata2.formatDocumentWithMetadata(model, document2)
+      (document2) => formatDocumentWithMetadata(permissionChecker2, model, document2)
     )(document);
   },
   async bulkDelete(ctx) {
     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 +2074,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 } = await getDocumentLocaleAndStatus(body, model);
+    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) {
@@ -1962,7 +2102,7 @@ const collectionTypes = {
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.read(ctx.query);
     const populate = await getService$1("populate-builder")(model).populateFromQuery(permissionQuery).build();
-    const { locale, status = "draft" } = getDocumentLocaleAndStatus(ctx.query);
+    const { locale, status } = await getDocumentLocaleAndStatus(ctx.query, model);
     const entity = await documentManager2.findOne(id, model, { populate, locale, status });
     if (!entity) {
       return ctx.notFound();
@@ -1977,7 +2117,7 @@ const collectionTypes = {
   },
   async countManyEntriesDraftRelations(ctx) {
     const { userAbility } = ctx.state;
-    const ids = ctx.request.query.ids;
+    const ids = ctx.request.query.documentIds;
     const locale = ctx.request.query.locale;
     const { model } = ctx.params;
     const documentManager2 = getService$1("document-manager");
@@ -1985,16 +2125,16 @@ const collectionTypes = {
     if (permissionChecker2.cannot.read()) {
       return ctx.forbidden();
     }
-    const entities = await documentManager2.findMany(
+    const documents = await documentManager2.findMany(
       {
         filters: {
-          id: ids
+          documentId: ids
         },
         locale
       },
       model
     );
-    if (!entities) {
+    if (!documents) {
       return ctx.notFound();
     }
     const number = await documentManager2.countManyEntriesDraftRelations(ids, model, locale);
@@ -2490,7 +2630,7 @@ const createOrUpdateDocument = async (ctx, opts) => {
     throw new strapiUtils.errors.ForbiddenError();
   }
   const sanitizedQuery = await permissionChecker2.sanitizedQuery.update(query);
-  const { locale } = getDocumentLocaleAndStatus(body);
+  const { locale } = await getDocumentLocaleAndStatus(body, model);
   const [documentVersion, otherDocumentVersion] = await Promise.all([
     findDocument(sanitizedQuery, model, { locale, status: "draft" }),
     // Find the first document to check if it exists
@@ -2527,12 +2667,11 @@ const singleTypes = {
     const { model } = ctx.params;
     const { query = {} } = ctx.request;
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
-    const documentMetadata2 = getService$1("document-metadata");
     if (permissionChecker2.cannot.read()) {
       return ctx.forbidden();
     }
     const permissionQuery = await permissionChecker2.sanitizedQuery.read(query);
-    const { locale, status } = getDocumentLocaleAndStatus(query);
+    const { locale, status } = await getDocumentLocaleAndStatus(query, model);
     const version = await findDocument(permissionQuery, model, { locale, status });
     if (!version) {
       if (permissionChecker2.cannot.create()) {
@@ -2542,8 +2681,10 @@ const singleTypes = {
       if (!document) {
         return ctx.notFound();
       }
-      const { meta } = await documentMetadata2.formatDocumentWithMetadata(
+      const { meta } = await formatDocumentWithMetadata(
+        permissionChecker2,
         model,
+        // @ts-expect-error - fix types
         { id: document.documentId, locale, publishedAt: null },
         { availableLocales: true, availableStatus: false }
       );
@@ -2554,16 +2695,15 @@ const singleTypes = {
       return ctx.forbidden();
     }
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(version);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument);
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument);
   },
   async createOrUpdate(ctx) {
     const { userAbility } = ctx.state;
     const { model } = ctx.params;
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     const document = await createOrUpdateDocument(ctx);
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(document);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument);
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument);
   },
   async delete(ctx) {
     const { userAbility } = ctx.state;
@@ -2576,7 +2716,7 @@ const singleTypes = {
     }
     const sanitizedQuery = await permissionChecker2.sanitizedQuery.delete(query);
     const populate = await buildPopulateFromQuery(sanitizedQuery, model);
-    const { locale } = getDocumentLocaleAndStatus(query);
+    const { locale } = await getDocumentLocaleAndStatus(query, model);
     const documentLocales = await documentManager2.findLocales(void 0, model, {
       populate,
       locale
@@ -2599,7 +2739,6 @@ const singleTypes = {
     const { model } = ctx.params;
     const { query = {} } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.publish()) {
       return ctx.forbidden();
@@ -2614,11 +2753,12 @@ const singleTypes = {
       if (permissionChecker2.cannot.publish(document)) {
         throw new strapiUtils.errors.ForbiddenError();
       }
-      const { locale } = getDocumentLocaleAndStatus(document);
-      return documentManager2.publish(document.documentId, model, { locale });
+      const { locale } = await getDocumentLocaleAndStatus(document, model);
+      const publishResult = await documentManager2.publish(document.documentId, model, { locale });
+      return publishResult.at(0);
     });
     const sanitizedDocument = await permissionChecker2.sanitizeOutput(publishedDocument);
-    ctx.body = await documentMetadata2.formatDocumentWithMetadata(model, sanitizedDocument);
+    ctx.body = await formatDocumentWithMetadata(permissionChecker2, model, sanitizedDocument);
   },
   async unpublish(ctx) {
     const { userAbility } = ctx.state;
@@ -2628,7 +2768,6 @@ const singleTypes = {
       query = {}
     } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.unpublish()) {
       return ctx.forbidden();
@@ -2637,7 +2776,7 @@ const singleTypes = {
       return ctx.forbidden();
     }
     const sanitizedQuery = await permissionChecker2.sanitizedQuery.unpublish(query);
-    const { locale } = getDocumentLocaleAndStatus(body);
+    const { locale } = await getDocumentLocaleAndStatus(body, model);
     const document = await findDocument(sanitizedQuery, model, { locale });
     if (!document) {
       return ctx.notFound();
@@ -2655,7 +2794,7 @@ const singleTypes = {
       ctx.body = await strapiUtils.async.pipe(
         (document2) => documentManager2.unpublish(document2.documentId, model, { locale }),
         permissionChecker2.sanitizeOutput,
-        (document2) => documentMetadata2.formatDocumentWithMetadata(model, document2)
+        (document2) => formatDocumentWithMetadata(permissionChecker2, model, document2)
       )(document);
     });
   },
@@ -2664,13 +2803,12 @@ const singleTypes = {
     const { model } = ctx.params;
     const { body, query = {} } = ctx.request;
     const documentManager2 = getService$1("document-manager");
-    const documentMetadata2 = getService$1("document-metadata");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
     if (permissionChecker2.cannot.discard()) {
       return ctx.forbidden();
     }
     const sanitizedQuery = await permissionChecker2.sanitizedQuery.discard(query);
-    const { locale } = getDocumentLocaleAndStatus(body);
+    const { locale } = await getDocumentLocaleAndStatus(body, model);
     const document = await findDocument(sanitizedQuery, model, { locale, status: "published" });
     if (!document) {
       return ctx.notFound();
@@ -2681,7 +2819,7 @@ const singleTypes = {
     ctx.body = await strapiUtils.async.pipe(
       (document2) => documentManager2.discardDraft(document2.documentId, model, { locale }),
       permissionChecker2.sanitizeOutput,
-      (document2) => documentMetadata2.formatDocumentWithMetadata(model, document2)
+      (document2) => formatDocumentWithMetadata(permissionChecker2, model, document2)
     )(document);
   },
   async countDraftRelations(ctx) {
@@ -2690,7 +2828,7 @@ const singleTypes = {
     const { query } = ctx.request;
     const documentManager2 = getService$1("document-manager");
     const permissionChecker2 = getService$1("permission-checker").create({ userAbility, model });
-    const { locale } = getDocumentLocaleAndStatus(query);
+    const { locale } = await getDocumentLocaleAndStatus(query, model);
     if (permissionChecker2.cannot.read()) {
       return ctx.forbidden();
     }
@@ -2711,7 +2849,7 @@ const uid$1 = {
   async generateUID(ctx) {
     const { contentTypeUID, field, data } = await validateGenerateUIDInput(ctx.request.body);
     const { query = {} } = ctx.request;
-    const { locale } = getDocumentLocaleAndStatus(query);
+    const { locale } = await getDocumentLocaleAndStatus(query, contentTypeUID);
     await validateUIDField(contentTypeUID, field);
     const uidService = getService$1("uid");
     ctx.body = {
@@ -2723,7 +2861,7 @@ const uid$1 = {
       ctx.request.body
     );
     const { query = {} } = ctx.request;
-    const { locale } = getDocumentLocaleAndStatus(query);
+    const { locale } = await getDocumentLocaleAndStatus(query, contentTypeUID);
     await validateUIDField(contentTypeUID, field);
     const uidService = getService$1("uid");
     const isAvailable = await uidService.checkUIDAvailability({
@@ -3514,7 +3652,7 @@ const permission = ({ strapi: strapi2 }) => ({
     await strapi2.service("admin::permission").actionProvider.registerMany(actions);
   }
 });
-const { isVisibleAttribute: isVisibleAttribute$1 } = strapiUtils__default.default.contentTypes;
+const { isVisibleAttribute: isVisibleAttribute$1, isScalarAttribute, getDoesAttributeRequireValidation } = strapiUtils__default.default.contentTypes;
 const { isAnyToMany } = strapiUtils__default.default.relations;
 const { PUBLISHED_AT_ATTRIBUTE: PUBLISHED_AT_ATTRIBUTE$1 } = strapiUtils__default.default.contentTypes.constants;
 const isMorphToRelation = (attribute) => isRelation(attribute) && attribute.relation.includes("morphTo");
@@ -3605,6 +3743,42 @@ const getDeepPopulate = (uid2, {
     {}
   );
 };
+const getValidatableFieldsPopulate = (uid2, {
+  initialPopulate = {},
+  countMany = false,
+  countOne = false,
+  maxLevel = Infinity
+} = {}, level = 1) => {
+  if (level > maxLevel) {
+    return {};
+  }
+  const model = strapi.getModel(uid2);
+  return Object.entries(model.attributes).reduce((populateAcc, [attributeName, attribute]) => {
+    if (!getDoesAttributeRequireValidation(attribute)) {
+      return populateAcc;
+    }
+    if (isScalarAttribute(attribute)) {
+      return fp.merge(populateAcc, {
+        [attributeName]: true
+      });
+    }
+    return fp.merge(
+      populateAcc,
+      getPopulateFor(
+        attributeName,
+        model,
+        {
+          // @ts-expect-error - improve types
+          initialPopulate: initialPopulate?.[attributeName],
+          countMany,
+          countOne,
+          maxLevel
+        },
+        level
+      )
+    );
+  }, {});
+};
 const getDeepPopulateDraftCount = (uid2) => {
   const model = strapi.getModel(uid2);
   let hasRelations = false;
@@ -3612,6 +3786,10 @@ const getDeepPopulateDraftCount = (uid2) => {
     const attribute = model.attributes[attributeName];
     switch (attribute.type) {
       case "relation": {
+        const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+        if (isMorphRelation) {
+          break;
+        }
         if (isVisibleAttribute$1(model, attributeName)) {
           populateAcc[attributeName] = {
             count: true,
@@ -3626,22 +3804,24 @@ const getDeepPopulateDraftCount = (uid2) => {
           attribute.component
         );
         if (childHasRelations) {
-          populateAcc[attributeName] = { populate: populate2 };
+          populateAcc[attributeName] = {
+            populate: populate2
+          };
           hasRelations = true;
         }
         break;
       }
       case "dynamiczone": {
-        const dzPopulate = (attribute.components || []).reduce((acc, componentUID) => {
-          const { populate: populate2, hasRelations: childHasRelations } = getDeepPopulateDraftCount(componentUID);
-          if (childHasRelations) {
+        const dzPopulateFragment = attribute.components?.reduce((acc, componentUID) => {
+          const { populate: componentPopulate, hasRelations: componentHasRelations } = getDeepPopulateDraftCount(componentUID);
+          if (componentHasRelations) {
             hasRelations = true;
-            return fp.merge(acc, populate2);
+            return { ...acc, [componentUID]: { populate: componentPopulate } };
           }
           return acc;
         }, {});
-        if (!fp.isEmpty(dzPopulate)) {
-          populateAcc[attributeName] = { populate: dzPopulate };
+        if (!fp.isEmpty(dzPopulateFragment)) {
+          populateAcc[attributeName] = { on: dzPopulateFragment };
         }
         break;
       }
@@ -3833,41 +4013,70 @@ const AVAILABLE_STATUS_FIELDS = [
   "updatedBy",
   "status"
 ];
-const AVAILABLE_LOCALES_FIELDS = ["id", "locale", "updatedAt", "createdAt", "status"];
+const AVAILABLE_LOCALES_FIELDS = [
+  "id",
+  "locale",
+  "updatedAt",
+  "createdAt",
+  "status",
+  "publishedAt",
+  "documentId"
+];
 const CONTENT_MANAGER_STATUS = {
   PUBLISHED: "published",
   DRAFT: "draft",
   MODIFIED: "modified"
 };
-const areDatesEqual = (date1, date2, threshold) => {
-  if (!date1 || !date2) {
+const getIsVersionLatestModification = (version, otherVersion) => {
+  if (!version || !version.updatedAt) {
     return false;
   }
-  const time1 = new Date(date1).getTime();
-  const time2 = new Date(date2).getTime();
-  const difference = Math.abs(time1 - time2);
-  return difference <= threshold;
+  const versionUpdatedAt = version?.updatedAt ? new Date(version.updatedAt).getTime() : 0;
+  const otherUpdatedAt = otherVersion?.updatedAt ? new Date(otherVersion.updatedAt).getTime() : 0;
+  return versionUpdatedAt > otherUpdatedAt;
 };
 const documentMetadata = ({ strapi: strapi2 }) => ({
   /**
    * Returns available locales of a document for the current status
    */
-  getAvailableLocales(uid2, version, allVersions) {
+  async getAvailableLocales(uid2, version, allVersions, validatableFields = []) {
     const versionsByLocale = fp.groupBy("locale", allVersions);
     delete versionsByLocale[version.locale];
-    return Object.values(versionsByLocale).map((localeVersions) => {
-      if (!strapiUtils.contentTypes.hasDraftAndPublish(strapi2.getModel(uid2))) {
-        return fp.pick(AVAILABLE_LOCALES_FIELDS, localeVersions[0]);
+    const model = strapi2.getModel(uid2);
+    const keysToKeep = [...AVAILABLE_LOCALES_FIELDS, ...validatableFields];
+    const traversalFunction = async (localeVersion) => strapiUtils.traverseEntity(
+      ({ key }, { remove }) => {
+        if (keysToKeep.includes(key)) {
+          return;
+        }
+        remove(key);
+      },
+      { schema: model, getModel: strapi2.getModel.bind(strapi2) },
+      // @ts-expect-error fix types DocumentVersion incompatible with Data
+      localeVersion
+    );
+    const mappingResult = await strapiUtils.async.map(
+      Object.values(versionsByLocale),
+      async (localeVersions) => {
+        const mappedLocaleVersions = await strapiUtils.async.map(
+          localeVersions,
+          traversalFunction
+        );
+        if (!strapiUtils.contentTypes.hasDraftAndPublish(model)) {
+          return mappedLocaleVersions[0];
+        }
+        const draftVersion = mappedLocaleVersions.find((v) => v.publishedAt === null);
+        const otherVersions = mappedLocaleVersions.filter((v) => v.id !== draftVersion?.id);
+        if (!draftVersion) {
+          return;
+        }
+        return {
+          ...draftVersion,
+          status: this.getStatus(draftVersion, otherVersions)
+        };
       }
-      const draftVersion = localeVersions.find((v) => v.publishedAt === null);
-      const otherVersions = localeVersions.filter((v) => v.id !== draftVersion?.id);
-      if (!draftVersion)
-        return;
-      return {
-        ...fp.pick(AVAILABLE_LOCALES_FIELDS, draftVersion),
-        status: this.getStatus(draftVersion, otherVersions)
-      };
-    }).filter(Boolean);
+    );
+    return mappingResult.filter(Boolean);
   },
   /**
    * Returns available status of a document for the current locale
@@ -3905,26 +4114,37 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
     });
   },
   getStatus(version, otherDocumentStatuses) {
-    const isDraft = version.publishedAt === null;
-    if (!otherDocumentStatuses?.length) {
-      return isDraft ? CONTENT_MANAGER_STATUS.DRAFT : CONTENT_MANAGER_STATUS.PUBLISHED;
+    let draftVersion;
+    let publishedVersion;
+    if (version.publishedAt) {
+      publishedVersion = version;
+    } else {
+      draftVersion = version;
     }
-    if (isDraft) {
-      const publishedVersion = otherDocumentStatuses?.find((d) => d.publishedAt !== null);
-      if (!publishedVersion) {
-        return CONTENT_MANAGER_STATUS.DRAFT;
-      }
+    const otherVersion = otherDocumentStatuses?.at(0);
+    if (otherVersion?.publishedAt) {
+      publishedVersion = otherVersion;
+    } else if (otherVersion) {
+      draftVersion = otherVersion;
     }
-    if (areDatesEqual(version.updatedAt, otherDocumentStatuses.at(0)?.updatedAt, 500)) {
+    if (!draftVersion)
       return CONTENT_MANAGER_STATUS.PUBLISHED;
-    }
-    return CONTENT_MANAGER_STATUS.MODIFIED;
+    if (!publishedVersion)
+      return CONTENT_MANAGER_STATUS.DRAFT;
+    const isDraftModified = getIsVersionLatestModification(draftVersion, publishedVersion);
+    return isDraftModified ? CONTENT_MANAGER_STATUS.MODIFIED : CONTENT_MANAGER_STATUS.PUBLISHED;
   },
+  // TODO is it necessary to return metadata on every page of the CM
+  // We could refactor this so the locales are only loaded when they're
+  // needed. e.g. in the bulk locale action modal.
   async getMetadata(uid2, version, { availableLocales = true, availableStatus = true } = {}) {
+    const populate = getValidatableFieldsPopulate(uid2);
     const versions = await strapi2.db.query(uid2).findMany({
       where: { documentId: version.documentId },
-      select: ["createdAt", "updatedAt", "locale", "publishedAt", "documentId"],
       populate: {
+        // Populate only fields that require validation for bulk locale actions
+        ...populate,
+        // NOTE: creator fields are selected in this way to avoid exposing sensitive data
         createdBy: {
           select: ["id", "firstname", "lastname", "email"]
         },
@@ -3933,7 +4153,7 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
         }
       }
     });
-    const availableLocalesResult = availableLocales ? this.getAvailableLocales(uid2, version, versions) : [];
+    const availableLocalesResult = availableLocales ? await this.getAvailableLocales(uid2, version, versions, Object.keys(populate)) : [];
     const availableStatusResult = availableStatus ? this.getAvailableStatus(version, versions) : null;
     return {
       availableLocales: availableLocalesResult,
@@ -3946,8 +4166,15 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
    * - Available status of the document for the current locale
    */
   async formatDocumentWithMetadata(uid2, document, opts = {}) {
-    if (!document)
-      return document;
+    if (!document) {
+      return {
+        data: document,
+        meta: {
+          availableLocales: [],
+          availableStatus: []
+        }
+      };
+    }
     const hasDraftAndPublish = strapiUtils.contentTypes.hasDraftAndPublish(strapi2.getModel(uid2));
     if (!hasDraftAndPublish) {
       opts.availableStatus = false;
@@ -3997,26 +4224,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 +4245,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 +4255,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 = {}) {
@@ -4072,10 +4281,7 @@ const documentManager = ({ strapi: strapi2 }) => {
     async clone(id, body, uid2) {
       const populate = await buildDeepPopulate(uid2);
       const params = {
-        data: {
-          ...omitIdField(body),
-          [PUBLISHED_AT_ATTRIBUTE]: null
-        },
+        data: omitIdField(body),
         populate
       };
       return strapi2.documents(uid2).clone({ ...params, documentId: id }).then((result) => result?.entries.at(0));
@@ -4101,70 +4307,36 @@ 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));
+      return strapi2.documents(uid2).publish({ ...params, documentId: id }).then((result) => result?.entries);
     },
-    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(uid2, documentIds, locale) {
+      return strapi2.db.transaction(async () => {
+        const results = await Promise.all(
+          documentIds.map((documentId) => this.publish(documentId, uid2, { locale }))
+        );
+        const publishedEntitiesCount = results.flat().filter(Boolean).length;
+        return publishedEntitiesCount;
       });
-      await Promise.all(
-        publishedEntities.map((doc) => emitEvent(uid2, ENTRY_PUBLISH, doc))
-      );
-      return 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,16 +4361,20 @@ 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;
       }
+      let localeFilter = {};
+      if (locale) {
+        localeFilter = Array.isArray(locale) ? { locale: { $in: locale } } : { locale };
+      }
       const entities = await strapi2.db.query(uid2).findMany({
         populate,
         where: {
-          id: { $in: ids },
-          ...locale ? { locale } : {}
+          documentId: { $in: documentIds },
+          ...localeFilter
         }
       });
       const totalNumberDraftRelations = entities.reduce(