@strapi/content-releases 0.0.0-next.78ea7925e0dad75936ae2e937a041a0666e3d65a → 0.0.0-next.7e9928491527b4d1767954c3372ad33d9c409f14

package/dist/server/index.js

@@ -1,1679 +1,2353 @@
-"use strict";
-const utils = require("@strapi/utils");
-const isEqual = require("lodash/isEqual");
-const lodash = require("lodash");
-const _ = require("lodash/fp");
-const EE = require("@strapi/strapi/dist/utils/ee");
-const nodeSchedule = require("node-schedule");
-const yup = require("yup");
-const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
-function _interopNamespace(e) {
-  if (e && e.__esModule)
-    return e;
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+'use strict';
+
+var utils = require('@strapi/utils');
+var isEqual = require('lodash/isEqual');
+var lodash = require('lodash');
+var _ = require('lodash/fp');
+var nodeSchedule = require('node-schedule');
+var yup = require('yup');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
   if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
         Object.defineProperty(n, k, d.get ? d : {
           enumerable: true,
-          get: () => e[k]
+          get: function () { return e[k]; }
         });
       }
-    }
+    });
   }
   n.default = e;
   return Object.freeze(n);
 }
-const isEqual__default = /* @__PURE__ */ _interopDefault(isEqual);
-const ___default = /* @__PURE__ */ _interopDefault(_);
-const EE__default = /* @__PURE__ */ _interopDefault(EE);
-const yup__namespace = /* @__PURE__ */ _interopNamespace(yup);
-const RELEASE_MODEL_UID = "plugin::content-releases.release";
-const RELEASE_ACTION_MODEL_UID = "plugin::content-releases.release-action";
+
+var yup__namespace = /*#__PURE__*/_interopNamespaceDefault(yup);
+
+const RELEASE_MODEL_UID = 'plugin::content-releases.release';
+const RELEASE_ACTION_MODEL_UID = 'plugin::content-releases.release-action';
 const ACTIONS = [
-  {
-    section: "plugins",
-    displayName: "Read",
-    uid: "read",
-    pluginName: "content-releases"
-  },
-  {
-    section: "plugins",
-    displayName: "Create",
-    uid: "create",
-    pluginName: "content-releases"
-  },
-  {
-    section: "plugins",
-    displayName: "Edit",
-    uid: "update",
-    pluginName: "content-releases"
-  },
-  {
-    section: "plugins",
-    displayName: "Delete",
-    uid: "delete",
-    pluginName: "content-releases"
-  },
-  {
-    section: "plugins",
-    displayName: "Publish",
-    uid: "publish",
-    pluginName: "content-releases"
-  },
-  {
-    section: "plugins",
-    displayName: "Remove an entry from a release",
-    uid: "delete-action",
-    pluginName: "content-releases"
-  },
-  {
-    section: "plugins",
-    displayName: "Add an entry to a release",
-    uid: "create-action",
-    pluginName: "content-releases"
-  }
+    {
+        section: 'plugins',
+        displayName: 'Read',
+        uid: 'read',
+        pluginName: 'content-releases'
+    },
+    {
+        section: 'plugins',
+        displayName: 'Create',
+        uid: 'create',
+        pluginName: 'content-releases'
+    },
+    {
+        section: 'plugins',
+        displayName: 'Edit',
+        uid: 'update',
+        pluginName: 'content-releases'
+    },
+    {
+        section: 'plugins',
+        displayName: 'Delete',
+        uid: 'delete',
+        pluginName: 'content-releases'
+    },
+    {
+        section: 'plugins',
+        displayName: 'Publish',
+        uid: 'publish',
+        pluginName: 'content-releases'
+    },
+    {
+        section: 'plugins',
+        displayName: 'Remove an entry from a release',
+        uid: 'delete-action',
+        pluginName: 'content-releases'
+    },
+    {
+        section: 'plugins',
+        displayName: 'Add an entry to a release',
+        uid: 'create-action',
+        pluginName: 'content-releases'
+    },
+    // Settings
+    {
+        uid: 'settings.read',
+        section: 'settings',
+        displayName: 'Read',
+        category: 'content releases',
+        subCategory: 'options',
+        pluginName: 'content-releases'
+    },
+    {
+        uid: 'settings.update',
+        section: 'settings',
+        displayName: 'Edit',
+        category: 'content releases',
+        subCategory: 'options',
+        pluginName: 'content-releases'
+    }
 ];
 const ALLOWED_WEBHOOK_EVENTS = {
-  RELEASES_PUBLISH: "releases.publish"
+    RELEASES_PUBLISH: 'releases.publish'
 };
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.plugin("content-releases").service(name);
+
+const getService = (name, { strapi: strapi1 })=>{
+    return strapi1.plugin('content-releases').service(name);
 };
-const getPopulatedEntry = async (contentTypeUid, entryId, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
-  const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
-  const entry = await strapi2.entityService.findOne(contentTypeUid, entryId, { populate });
-  return entry;
+const getDraftEntryValidStatus = async ({ contentType, documentId, locale }, { strapi: strapi1 })=>{
+    const populateBuilderService = strapi1.plugin('content-manager').service('populate-builder');
+    // @ts-expect-error - populateBuilderService should be a function but is returning service
+    const populate = await populateBuilderService(contentType).populateDeep(Infinity).build();
+    const entry = await getEntry({
+        contentType,
+        documentId,
+        locale,
+        populate
+    }, {
+        strapi: strapi1
+    });
+    return isEntryValid(contentType, entry, {
+        strapi: strapi1
+    });
 };
-const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  try {
-    await strapi2.entityValidator.validateEntityCreation(
-      strapi2.getModel(contentTypeUid),
-      entry,
-      void 0,
-      // @ts-expect-error - FIXME: entity here is unnecessary
-      entry
-    );
-    return true;
-  } catch {
-    return false;
-  }
+const isEntryValid = async (contentTypeUid, entry, { strapi: strapi1 })=>{
+    try {
+        // @TODO: When documents service has validateEntityCreation method, use it instead
+        await strapi1.entityValidator.validateEntityCreation(strapi1.getModel(contentTypeUid), entry, undefined, // @ts-expect-error - FIXME: entity here is unnecessary
+        entry);
+        const workflowsService = strapi1.plugin('review-workflows').service('workflows');
+        const workflow = await workflowsService.getAssignedWorkflow(contentTypeUid, {
+            populate: 'stageRequiredToPublish'
+        });
+        if (workflow?.stageRequiredToPublish) {
+            return entry.strapi_stage.id === workflow.stageRequiredToPublish.id;
+        }
+        return true;
+    } catch  {
+        return false;
+    }
 };
-async function deleteActionsOnDisableDraftAndPublish({
-  oldContentTypes,
-  contentTypes: contentTypes2
-}) {
-  if (!oldContentTypes) {
-    return;
-  }
-  for (const uid in contentTypes2) {
-    if (!oldContentTypes[uid]) {
-      continue;
+const getEntry = async ({ contentType, documentId, locale, populate, status = 'draft' }, { strapi: strapi1 })=>{
+    if (documentId) {
+        // Try to get an existing draft or published document
+        const entry = await strapi1.documents(contentType).findOne({
+            documentId,
+            locale,
+            populate,
+            status
+        });
+        // The document isn't published yet, but the action is to publish it, fetch the draft
+        if (status === 'published' && !entry) {
+            return strapi1.documents(contentType).findOne({
+                documentId,
+                locale,
+                populate,
+                status: 'draft'
+            });
+        }
+        return entry;
     }
-    const oldContentType = oldContentTypes[uid];
-    const contentType = contentTypes2[uid];
-    if (utils.contentTypes.hasDraftAndPublish(oldContentType) && !utils.contentTypes.hasDraftAndPublish(contentType)) {
-      await strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: uid }).execute();
+    return strapi1.documents(contentType).findFirst({
+        locale,
+        populate,
+        status
+    });
+};
+const getEntryStatus = async (contentType, entry)=>{
+    if (entry.publishedAt) {
+        return 'published';
     }
-  }
-}
-async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes: contentTypes2 }) {
-  const deletedContentTypes = lodash.difference(lodash.keys(oldContentTypes), lodash.keys(contentTypes2)) ?? [];
-  if (deletedContentTypes.length) {
-    await utils.mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
-      return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: deletedContentTypeUID }).execute();
+    const publishedEntry = await strapi.documents(contentType).findOne({
+        documentId: entry.documentId,
+        locale: entry.locale,
+        status: 'published',
+        fields: [
+            'updatedAt'
+        ]
     });
-  }
+    if (!publishedEntry) {
+        return 'draft';
+    }
+    const entryUpdatedAt = new Date(entry.updatedAt).getTime();
+    const publishedEntryUpdatedAt = new Date(publishedEntry.updatedAt).getTime();
+    if (entryUpdatedAt > publishedEntryUpdatedAt) {
+        return 'modified';
+    }
+    return 'published';
+};
+
+async function deleteActionsOnDisableDraftAndPublish({ oldContentTypes, contentTypes }) {
+    if (!oldContentTypes) {
+        return;
+    }
+    for(const uid in contentTypes){
+        if (!oldContentTypes[uid]) {
+            continue;
+        }
+        const oldContentType = oldContentTypes[uid];
+        const contentType = contentTypes[uid];
+        if (utils.contentTypes.hasDraftAndPublish(oldContentType) && !utils.contentTypes.hasDraftAndPublish(contentType)) {
+            await strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({
+                contentType: uid
+            }).execute();
+        }
+    }
+}
+async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes }) {
+    const deletedContentTypes = lodash.difference(lodash.keys(oldContentTypes), lodash.keys(contentTypes)) ?? [];
+    if (deletedContentTypes.length) {
+        await utils.async.map(deletedContentTypes, async (deletedContentTypeUID)=>{
+            return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({
+                contentType: deletedContentTypeUID
+            }).execute();
+        });
+    }
 }
 async function migrateIsValidAndStatusReleases() {
-  const releasesWithoutStatus = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-    where: {
-      status: null,
-      releasedAt: null
-    },
-    populate: {
-      actions: {
+    const releasesWithoutStatus = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+            status: null,
+            releasedAt: null
+        },
         populate: {
-          entry: true
+            actions: {
+                populate: {
+                    entry: true
+                }
+            }
         }
-      }
-    }
-  });
-  utils.mapAsync(releasesWithoutStatus, async (release2) => {
-    const actions = release2.actions;
-    const notValidatedActions = actions.filter((action) => action.isEntryValid === null);
-    for (const action of notValidatedActions) {
-      if (action.entry) {
-        const populatedEntry = await getPopulatedEntry(action.contentType, action.entry.id, {
-          strapi
-        });
-        if (populatedEntry) {
-          const isEntryValid = getEntryValidStatus(action.contentType, populatedEntry, { strapi });
-          await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+    });
+    utils.async.map(releasesWithoutStatus, async (release)=>{
+        const actions = release.actions;
+        const notValidatedActions = actions.filter((action)=>action.isEntryValid === null);
+        for (const action of notValidatedActions){
+            // We need to check the Action is related to a valid entry because we can't assume this is gonna be always the case
+            // example: users could make changes directly to their database, or data could be lost
+            if (action.entry) {
+                const isEntryValid = getDraftEntryValidStatus({
+                    contentType: action.contentType,
+                    documentId: action.entryDocumentId,
+                    locale: action.locale
+                }, {
+                    strapi
+                });
+                await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+                    where: {
+                        id: action.id
+                    },
+                    data: {
+                        isEntryValid
+                    }
+                });
+            }
+        }
+        return getService('release', {
+            strapi
+        }).updateReleaseStatus(release.id);
+    });
+    const publishedReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+            status: null,
+            releasedAt: {
+                $notNull: true
+            }
+        }
+    });
+    utils.async.map(publishedReleases, async (release)=>{
+        return strapi.db.query(RELEASE_MODEL_UID).update({
             where: {
-              id: action.id
+                id: release.id
             },
             data: {
-              isEntryValid
+                status: 'done'
             }
-          });
-        }
-      }
-    }
-    return getService("release", { strapi }).updateReleaseStatus(release2.id);
-  });
-  const publishedReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-    where: {
-      status: null,
-      releasedAt: {
-        $notNull: true
-      }
-    }
-  });
-  utils.mapAsync(publishedReleases, async (release2) => {
-    return strapi.db.query(RELEASE_MODEL_UID).update({
-      where: {
-        id: release2.id
-      },
-      data: {
-        status: "done"
-      }
+        });
     });
-  });
 }
-async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: contentTypes2 }) {
-  if (oldContentTypes !== void 0 && contentTypes2 !== void 0) {
-    const contentTypesWithDraftAndPublish = Object.keys(oldContentTypes).filter(
-      (uid) => oldContentTypes[uid]?.options?.draftAndPublish
-    );
-    const releasesAffected = /* @__PURE__ */ new Set();
-    utils.mapAsync(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
-      const oldContentType = oldContentTypes[contentTypeUID];
-      const contentType = contentTypes2[contentTypeUID];
-      if (!isEqual__default.default(oldContentType?.attributes, contentType?.attributes)) {
-        const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
-          where: {
-            contentType: contentTypeUID
-          },
-          populate: {
-            entry: true,
-            release: true
-          }
-        });
-        await utils.mapAsync(actions, async (action) => {
-          if (action.entry && action.release) {
-            const populatedEntry = await getPopulatedEntry(contentTypeUID, action.entry.id, {
-              strapi
-            });
-            if (populatedEntry) {
-              const isEntryValid = await getEntryValidStatus(contentTypeUID, populatedEntry, {
-                strapi
-              });
-              releasesAffected.add(action.release.id);
-              await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-                where: {
-                  id: action.id
-                },
-                data: {
-                  isEntryValid
-                }
-              });
+async function revalidateChangedContentTypes({ oldContentTypes, contentTypes }) {
+    if (oldContentTypes !== undefined && contentTypes !== undefined) {
+        const contentTypesWithDraftAndPublish = Object.keys(oldContentTypes).filter((uid)=>oldContentTypes[uid]?.options?.draftAndPublish);
+        const releasesAffected = new Set();
+        utils.async.map(contentTypesWithDraftAndPublish, async (contentTypeUID)=>{
+            const oldContentType = oldContentTypes[contentTypeUID];
+            const contentType = contentTypes[contentTypeUID];
+            // If attributes have changed, we need to revalidate actions because maybe validations rules are different
+            if (!isEqual(oldContentType?.attributes, contentType?.attributes)) {
+                const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+                    where: {
+                        contentType: contentTypeUID
+                    },
+                    populate: {
+                        entry: true,
+                        release: true
+                    }
+                });
+                await utils.async.map(actions, async (action)=>{
+                    if (action.entry && action.release && action.type === 'publish') {
+                        const isEntryValid = await getDraftEntryValidStatus({
+                            contentType: contentTypeUID,
+                            documentId: action.entryDocumentId,
+                            locale: action.locale
+                        }, {
+                            strapi
+                        });
+                        releasesAffected.add(action.release.id);
+                        await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+                            where: {
+                                id: action.id
+                            },
+                            data: {
+                                isEntryValid
+                            }
+                        });
+                    }
+                });
             }
-          }
+        }).then(()=>{
+            // We need to update the status of the releases affected
+            utils.async.map(releasesAffected, async (releaseId)=>{
+                return getService('release', {
+                    strapi
+                }).updateReleaseStatus(releaseId);
+            });
         });
-      }
-    }).then(() => {
-      utils.mapAsync(releasesAffected, async (releaseId) => {
-        return getService("release", { strapi }).updateReleaseStatus(releaseId);
-      });
-    });
-  }
+    }
 }
-async function disableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
-  if (!oldContentTypes) {
-    return;
-  }
-  for (const uid in contentTypes2) {
-    if (!oldContentTypes[uid]) {
-      continue;
+async function disableContentTypeLocalized({ oldContentTypes, contentTypes }) {
+    if (!oldContentTypes) {
+        return;
     }
-    const oldContentType = oldContentTypes[uid];
-    const contentType = contentTypes2[uid];
-    const i18nPlugin = strapi.plugin("i18n");
-    const { isLocalizedContentType } = i18nPlugin.service("content-types");
-    if (isLocalizedContentType(oldContentType) && !isLocalizedContentType(contentType)) {
-      await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
-        locale: null
-      }).where({ contentType: uid }).execute();
+    const i18nPlugin = strapi.plugin('i18n');
+    if (!i18nPlugin) {
+        return;
+    }
+    for(const uid in contentTypes){
+        if (!oldContentTypes[uid]) {
+            continue;
+        }
+        const oldContentType = oldContentTypes[uid];
+        const contentType = contentTypes[uid];
+        const { isLocalizedContentType } = i18nPlugin.service('content-types');
+        // if i18N is disabled remove non default locales before sync
+        if (isLocalizedContentType(oldContentType) && !isLocalizedContentType(contentType)) {
+            await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
+                locale: null
+            }).where({
+                contentType: uid
+            }).execute();
+        }
     }
-  }
 }
-async function enableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
-  if (!oldContentTypes) {
-    return;
-  }
-  for (const uid in contentTypes2) {
-    if (!oldContentTypes[uid]) {
-      continue;
+async function enableContentTypeLocalized({ oldContentTypes, contentTypes }) {
+    if (!oldContentTypes) {
+        return;
     }
-    const oldContentType = oldContentTypes[uid];
-    const contentType = contentTypes2[uid];
-    const i18nPlugin = strapi.plugin("i18n");
-    const { isLocalizedContentType } = i18nPlugin.service("content-types");
-    const { getDefaultLocale } = i18nPlugin.service("locales");
-    if (!isLocalizedContentType(oldContentType) && isLocalizedContentType(contentType)) {
-      const defaultLocale = await getDefaultLocale();
-      await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
-        locale: defaultLocale
-      }).where({ contentType: uid }).execute();
+    const i18nPlugin = strapi.plugin('i18n');
+    if (!i18nPlugin) {
+        return;
     }
-  }
-}
-const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
-const register = async ({ strapi: strapi2 }) => {
-  if (features$2.isEnabled("cms-content-releases")) {
-    await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
-    strapi2.hook("strapi::content-types.beforeSync").register(deleteActionsOnDisableDraftAndPublish).register(disableContentTypeLocalized);
-    strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType).register(enableContentTypeLocalized).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
-  }
-  if (strapi2.plugin("graphql")) {
-    const graphqlExtensionService = strapi2.plugin("graphql").service("extension");
-    graphqlExtensionService.shadowCRUD(RELEASE_MODEL_UID).disable();
-    graphqlExtensionService.shadowCRUD(RELEASE_ACTION_MODEL_UID).disable();
-  }
-};
-const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
-const bootstrap = async ({ strapi: strapi2 }) => {
-  if (features$1.isEnabled("cms-content-releases")) {
-    const contentTypesWithDraftAndPublish = Object.keys(strapi2.contentTypes).filter(
-      (uid) => strapi2.contentTypes[uid]?.options?.draftAndPublish
-    );
-    strapi2.db.lifecycles.subscribe({
-      models: contentTypesWithDraftAndPublish,
-      async afterDelete(event) {
-        try {
-          const { model, result } = event;
-          if (model.kind === "collectionType" && model.options?.draftAndPublish) {
-            const { id } = result;
-            const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-              where: {
-                actions: {
-                  target_type: model.uid,
-                  target_id: id
-                }
-              }
-            });
-            await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-              where: {
-                target_type: model.uid,
-                target_id: id
-              }
-            });
-            for (const release2 of releases) {
-              getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
-            }
-          }
-        } catch (error) {
-          strapi2.log.error("Error while deleting release actions after entry delete", { error });
+    for(const uid in contentTypes){
+        if (!oldContentTypes[uid]) {
+            continue;
         }
-      },
-      /**
-       * deleteMany hook doesn't return the deleted entries ids
-       * so we need to fetch them before deleting the entries to save the ids on our state
-       */
-      async beforeDeleteMany(event) {
-        const { model, params } = event;
-        if (model.kind === "collectionType" && model.options?.draftAndPublish) {
-          const { where } = params;
-          const entriesToDelete = await strapi2.db.query(model.uid).findMany({ select: ["id"], where });
-          event.state.entriesToDelete = entriesToDelete;
+        const oldContentType = oldContentTypes[uid];
+        const contentType = contentTypes[uid];
+        const { isLocalizedContentType } = i18nPlugin.service('content-types');
+        const { getDefaultLocale } = i18nPlugin.service('locales');
+        // if i18N is enabled remove non default locales before sync
+        if (!isLocalizedContentType(oldContentType) && isLocalizedContentType(contentType)) {
+            const defaultLocale = await getDefaultLocale();
+            await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
+                locale: defaultLocale
+            }).where({
+                contentType: uid
+            }).execute();
         }
-      },
-      /**
-       * We delete the release actions related to deleted entries
-       * We make this only after deleteMany is succesfully executed to avoid errors
-       */
-      async afterDeleteMany(event) {
-        try {
-          const { model, state } = event;
-          const entriesToDelete = state.entriesToDelete;
-          if (entriesToDelete) {
-            const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-              where: {
-                actions: {
-                  target_type: model.uid,
-                  target_id: {
-                    $in: entriesToDelete.map(
-                      (entry) => entry.id
-                    )
-                  }
-                }
-              }
-            });
-            await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-              where: {
-                target_type: model.uid,
-                target_id: {
-                  $in: entriesToDelete.map((entry) => entry.id)
-                }
-              }
-            });
-            for (const release2 of releases) {
-              getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
-            }
-          }
-        } catch (error) {
-          strapi2.log.error("Error while deleting release actions after entry deleteMany", {
-            error
-          });
+    }
+}
+
+/**
+ * On v4, release actions are linked with entries using the built in Polymorphic relations.
+ *
+ * On v5, we are going to save entryDocumentId on the release action and make the link manually.
+ * This because entryId is not a reliable way to link documents, as it can change.
+ */ const addEntryDocumentToReleaseActions = {
+    name: 'content-releases::5.0.0-add-entry-document-id-to-release-actions',
+    async up (trx, db) {
+        // Check if the table exists
+        const hasTable = await trx.schema.hasTable('strapi_release_actions');
+        if (!hasTable) {
+            return;
         }
-      },
-      async afterUpdate(event) {
-        try {
-          const { model, result } = event;
-          if (model.kind === "collectionType" && model.options?.draftAndPublish) {
-            const isEntryValid = await getEntryValidStatus(
-              model.uid,
-              result,
-              {
-                strapi: strapi2
-              }
-            );
-            await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
-              where: {
-                target_type: model.uid,
-                target_id: result.id
-              },
-              data: {
-                isEntryValid
-              }
-            });
-            const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-              where: {
-                actions: {
-                  target_type: model.uid,
-                  target_id: result.id
+        const hasPolymorphicColumn = await trx.schema.hasColumn('strapi_release_actions', 'target_id');
+        // If user has PolymorphicColumn means that is coming from v4
+        if (hasPolymorphicColumn) {
+            // First time coming from v4 user doesn't have entryDocumentId
+            // but we double check to avoid errors
+            const hasEntryDocumentIdColumn = await trx.schema.hasColumn('strapi_release_actions', 'entry_document_id');
+            if (!hasEntryDocumentIdColumn) {
+                await trx.schema.alterTable('strapi_release_actions', (table)=>{
+                    table.string('entry_document_id');
+                });
+            }
+            const releaseActions = await trx.select('*').from('strapi_release_actions');
+            utils.async.map(releaseActions, async (action)=>{
+                const { target_type, target_id } = action;
+                const entry = await db.query(target_type).findOne({
+                    where: {
+                        id: target_id
+                    }
+                });
+                if (entry) {
+                    await trx('strapi_release_actions').update({
+                        entry_document_id: entry.documentId
+                    }).where('id', action.id);
                 }
-              }
             });
-            for (const release2 of releases) {
-              getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
+        }
+    },
+    async down () {
+        throw new Error('not implemented');
+    }
+};
+
+const register = async ({ strapi })=>{
+    if (strapi.ee.features.isEnabled('cms-content-releases')) {
+        await strapi.service('admin::permission').actionProvider.registerMany(ACTIONS);
+        strapi.db.migrations.providers.internal.register(addEntryDocumentToReleaseActions);
+        strapi.hook('strapi::content-types.beforeSync').register(disableContentTypeLocalized).register(deleteActionsOnDisableDraftAndPublish);
+        strapi.hook('strapi::content-types.afterSync').register(deleteActionsOnDeleteContentType).register(enableContentTypeLocalized).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
+    }
+    if (strapi.plugin('graphql')) {
+        const graphqlExtensionService = strapi.plugin('graphql').service('extension');
+        // Exclude the release and release action models from the GraphQL schema
+        graphqlExtensionService.shadowCRUD(RELEASE_MODEL_UID).disable();
+        graphqlExtensionService.shadowCRUD(RELEASE_ACTION_MODEL_UID).disable();
+    }
+};
+
+const updateActionsStatusAndUpdateReleaseStatus = async (contentType, entry)=>{
+    const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+            releasedAt: null,
+            actions: {
+                contentType,
+                entryDocumentId: entry.documentId,
+                locale: entry.locale
             }
-          }
-        } catch (error) {
-          strapi2.log.error("Error while updating release actions after entry update", { error });
         }
-      }
     });
-    if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-      getService("scheduling", { strapi: strapi2 }).syncFromDatabase().catch((err) => {
-        strapi2.log.error(
-          "Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling."
-        );
-        throw err;
-      });
-      Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
-        strapi2.webhookStore.addAllowedEvent(key, value);
-      });
+    const entryStatus = await isEntryValid(contentType, entry, {
+        strapi
+    });
+    await strapi.db.query(RELEASE_ACTION_MODEL_UID).updateMany({
+        where: {
+            contentType,
+            entryDocumentId: entry.documentId,
+            locale: entry.locale
+        },
+        data: {
+            isEntryValid: entryStatus
+        }
+    });
+    for (const release of releases){
+        getService('release', {
+            strapi
+        }).updateReleaseStatus(release.id);
     }
-  }
 };
-const destroy = async ({ strapi: strapi2 }) => {
-  if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-    const scheduledJobs = getService("scheduling", {
-      strapi: strapi2
-    }).getAll();
-    for (const [, job] of scheduledJobs) {
-      job.cancel();
+const deleteActionsAndUpdateReleaseStatus = async (params)=>{
+    const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+            actions: params
+        }
+    });
+    await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+        where: params
+    });
+    for (const release of releases){
+        getService('release', {
+            strapi
+        }).updateReleaseStatus(release.id);
     }
-  }
 };
-const schema$1 = {
-  collectionName: "strapi_releases",
-  info: {
-    singularName: "release",
-    pluralName: "releases",
-    displayName: "Release"
-  },
-  options: {
-    draftAndPublish: false
-  },
-  pluginOptions: {
-    "content-manager": {
-      visible: false
-    },
-    "content-type-builder": {
-      visible: false
+const deleteActionsOnDelete = async (ctx, next)=>{
+    if (ctx.action !== 'delete') {
+        return next();
     }
-  },
-  attributes: {
-    name: {
-      type: "string",
-      required: true
-    },
-    releasedAt: {
-      type: "datetime"
-    },
-    scheduledAt: {
-      type: "datetime"
-    },
-    timezone: {
-      type: "string"
-    },
-    status: {
-      type: "enumeration",
-      enum: ["ready", "blocked", "failed", "done", "empty"],
-      required: true
-    },
-    actions: {
-      type: "relation",
-      relation: "oneToMany",
-      target: RELEASE_ACTION_MODEL_UID,
-      mappedBy: "release"
+    if (!utils.contentTypes.hasDraftAndPublish(ctx.contentType)) {
+        return next();
     }
-  }
-};
-const release$1 = {
-  schema: schema$1
-};
-const schema = {
-  collectionName: "strapi_release_actions",
-  info: {
-    singularName: "release-action",
-    pluralName: "release-actions",
-    displayName: "Release Action"
-  },
-  options: {
-    draftAndPublish: false
-  },
-  pluginOptions: {
-    "content-manager": {
-      visible: false
-    },
-    "content-type-builder": {
-      visible: false
+    const contentType = ctx.contentType.uid;
+    const { documentId, locale } = ctx.params;
+    const result = await next();
+    if (!result) {
+        return result;
     }
-  },
-  attributes: {
-    type: {
-      type: "enumeration",
-      enum: ["publish", "unpublish"],
-      required: true
-    },
-    entry: {
-      type: "relation",
-      relation: "morphToOne",
-      configurable: false
-    },
-    contentType: {
-      type: "string",
-      required: true
-    },
-    locale: {
-      type: "string"
-    },
-    release: {
-      type: "relation",
-      relation: "manyToOne",
-      target: RELEASE_MODEL_UID,
-      inversedBy: "actions"
-    },
-    isEntryValid: {
-      type: "boolean"
+    try {
+        deleteActionsAndUpdateReleaseStatus({
+            contentType,
+            entryDocumentId: documentId,
+            ...locale !== '*' && {
+                locale
+            }
+        });
+    } catch (error) {
+        strapi.log.error('Error while deleting release actions after delete', {
+            error
+        });
     }
-  }
-};
-const releaseAction$1 = {
-  schema
+    return result;
 };
-const contentTypes = {
-  release: release$1,
-  "release-action": releaseAction$1
-};
-const getGroupName = (queryValue) => {
-  switch (queryValue) {
-    case "contentType":
-      return "contentType.displayName";
-    case "action":
-      return "type";
-    case "locale":
-      return ___default.default.getOr("No locale", "locale.name");
-    default:
-      return "contentType.displayName";
-  }
-};
-const createReleaseService = ({ strapi: strapi2 }) => {
-  const dispatchWebhook = (event, { isPublished, release: release2, error }) => {
-    strapi2.eventHub.emit(event, {
-      isPublished,
-      error,
-      release: release2
-    });
-  };
-  const publishSingleTypeAction = async (uid, actionType, entryId) => {
-    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
-    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
-    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
-    const entry = await strapi2.entityService.findOne(uid, entryId, { populate });
+const updateActionsOnUpdate = async (ctx, next)=>{
+    if (ctx.action !== 'update') {
+        return next();
+    }
+    if (!utils.contentTypes.hasDraftAndPublish(ctx.contentType)) {
+        return next();
+    }
+    const contentType = ctx.contentType.uid;
+    const result = await next();
+    if (!result) {
+        return result;
+    }
     try {
-      if (actionType === "publish") {
-        await entityManagerService.publish(entry, uid);
-      } else {
-        await entityManagerService.unpublish(entry, uid);
-      }
+        updateActionsStatusAndUpdateReleaseStatus(contentType, result);
     } catch (error) {
-      if (error instanceof utils.errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft"))
-        ;
-      else {
-        throw error;
-      }
+        strapi.log.error('Error while updating release actions after update', {
+            error
+        });
     }
-  };
-  const publishCollectionTypeAction = async (uid, entriesToPublishIds, entriestoUnpublishIds) => {
-    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
-    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
-    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
-    const entriesToPublish = await strapi2.entityService.findMany(uid, {
-      filters: {
-        id: {
-          $in: entriesToPublishIds
-        }
-      },
-      populate
-    });
-    const entriesToUnpublish = await strapi2.entityService.findMany(uid, {
-      filters: {
-        id: {
-          $in: entriestoUnpublishIds
+    return result;
+};
+
+const deleteReleasesActionsAndUpdateReleaseStatus = async (params)=>{
+    const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+            actions: params
         }
-      },
-      populate
     });
-    if (entriesToPublish.length > 0) {
-      await entityManagerService.publishMany(entriesToPublish, uid);
-    }
-    if (entriesToUnpublish.length > 0) {
-      await entityManagerService.unpublishMany(entriesToUnpublish, uid);
-    }
-  };
-  const getFormattedActions = async (releaseId) => {
-    const actions = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findMany({
-      where: {
-        release: {
-          id: releaseId
-        }
-      },
-      populate: {
-        entry: {
-          fields: ["id"]
-        }
-      }
+    await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+        where: params
     });
-    if (actions.length === 0) {
-      throw new utils.errors.ValidationError("No entries to publish");
+    // We update the status of each release after delete the actions
+    for (const release of releases){
+        getService('release', {
+            strapi
+        }).updateReleaseStatus(release.id);
     }
-    const collectionTypeActions = {};
-    const singleTypeActions = [];
-    for (const action of actions) {
-      const contentTypeUid = action.contentType;
-      if (strapi2.contentTypes[contentTypeUid].kind === "collectionType") {
-        if (!collectionTypeActions[contentTypeUid]) {
-          collectionTypeActions[contentTypeUid] = {
-            entriesToPublishIds: [],
-            entriesToUnpublishIds: []
-          };
-        }
-        if (action.type === "publish") {
-          collectionTypeActions[contentTypeUid].entriesToPublishIds.push(action.entry.id);
-        } else {
-          collectionTypeActions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
-        }
-      } else {
-        singleTypeActions.push({
-          uid: contentTypeUid,
-          action: action.type,
-          id: action.entry.id
+};
+const bootstrap = async ({ strapi: strapi1 })=>{
+    if (strapi1.ee.features.isEnabled('cms-content-releases')) {
+        const contentTypesWithDraftAndPublish = Object.keys(strapi1.contentTypes).filter((uid)=>strapi1.contentTypes[uid]?.options?.draftAndPublish);
+        strapi1.db.lifecycles.subscribe({
+            models: contentTypesWithDraftAndPublish,
+            /**
+       * deleteMany is still used outside documents service, for example when deleting a locale
+       */ async afterDeleteMany (event) {
+                try {
+                    const model = strapi1.getModel(event.model.uid);
+                    // @ts-expect-error TODO: lifecycles types looks like are not 100% finished
+                    if (model.kind === 'collectionType' && model.options?.draftAndPublish) {
+                        const { where } = event.params;
+                        deleteReleasesActionsAndUpdateReleaseStatus({
+                            contentType: model.uid,
+                            locale: where?.locale ?? null,
+                            ...where?.documentId && {
+                                entryDocumentId: where.documentId
+                            }
+                        });
+                    }
+                } catch (error) {
+                    // If an error happens we don't want to block the delete entry flow, but we log the error
+                    strapi1.log.error('Error while deleting release actions after entry deleteMany', {
+                        error
+                    });
+                }
+            }
+        });
+        // We register middleware to handle ReleaseActions when changes on documents are made
+        strapi1.documents.use(deleteActionsOnDelete);
+        strapi1.documents.use(updateActionsOnUpdate);
+        getService('scheduling', {
+            strapi: strapi1
+        }).syncFromDatabase().catch((err)=>{
+            strapi1.log.error('Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling.');
+            throw err;
+        });
+        Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value])=>{
+            strapi1.get('webhookStore').addAllowedEvent(key, value);
         });
-      }
     }
-    return { collectionTypeActions, singleTypeActions };
-  };
-  return {
-    async create(releaseData, { user }) {
-      const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
-      const {
-        validatePendingReleasesLimit,
-        validateUniqueNameForPendingRelease,
-        validateScheduledAtIsLaterThanNow
-      } = getService("release-validation", { strapi: strapi2 });
-      await Promise.all([
-        validatePendingReleasesLimit(),
-        validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
-        validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
-      ]);
-      const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
-        data: {
-          ...releaseWithCreatorFields,
-          status: "empty"
-        }
-      });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && releaseWithCreatorFields.scheduledAt) {
-        const schedulingService = getService("scheduling", { strapi: strapi2 });
-        await schedulingService.set(release2.id, release2.scheduledAt);
-      }
-      strapi2.telemetry.send("didCreateContentRelease");
-      return release2;
-    },
-    async findOne(id, query = {}) {
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
-        ...query
-      });
-      return release2;
+};
+
+const destroy = async ({ strapi })=>{
+    const scheduledJobs = getService('scheduling', {
+        strapi
+    }).getAll();
+    for (const [, job] of scheduledJobs){
+        job.cancel();
+    }
+};
+
+var schema$1 = {
+    collectionName: 'strapi_releases',
+    info: {
+        singularName: 'release',
+        pluralName: 'releases',
+        displayName: 'Release'
     },
-    findPage(query) {
-      return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
-        ...query,
-        populate: {
-          actions: {
-            // @ts-expect-error Ignore missing properties
-            count: true
-          }
-        }
-      });
+    options: {
+        draftAndPublish: false
     },
-    async findManyWithContentTypeEntryAttached(contentTypeUid, entryId) {
-      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-          actions: {
-            target_type: contentTypeUid,
-            target_id: entryId
-          },
-          releasedAt: {
-            $null: true
-          }
+    pluginOptions: {
+        'content-manager': {
+            visible: false
         },
-        populate: {
-          // Filter the action to get only the content type entry
-          actions: {
-            where: {
-              target_type: contentTypeUid,
-              target_id: entryId
-            }
-          }
-        }
-      });
-      return releases.map((release2) => {
-        if (release2.actions?.length) {
-          const [actionForEntry] = release2.actions;
-          delete release2.actions;
-          return {
-            ...release2,
-            action: actionForEntry
-          };
-        }
-        return release2;
-      });
-    },
-    async findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId) {
-      const releasesRelated = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-          releasedAt: {
-            $null: true
-          },
-          actions: {
-            target_type: contentTypeUid,
-            target_id: entryId
-          }
-        }
-      });
-      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-          $or: [
-            {
-              id: {
-                $notIn: releasesRelated.map((release2) => release2.id)
-              }
-            },
-            {
-              actions: null
-            }
-          ],
-          releasedAt: {
-            $null: true
-          }
-        }
-      });
-      return releases.map((release2) => {
-        if (release2.actions?.length) {
-          const [actionForEntry] = release2.actions;
-          delete release2.actions;
-          return {
-            ...release2,
-            action: actionForEntry
-          };
-        }
-        return release2;
-      });
-    },
-    async update(id, releaseData, { user }) {
-      const releaseWithCreatorFields = await utils.setCreatorFields({ user, isEdition: true })(
-        releaseData
-      );
-      const { validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService(
-        "release-validation",
-        { strapi: strapi2 }
-      );
-      await Promise.all([
-        validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
-        validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
-      ]);
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
-      if (!release2) {
-        throw new utils.errors.NotFoundError(`No release found for id ${id}`);
-      }
-      if (release2.releasedAt) {
-        throw new utils.errors.ValidationError("Release already published");
-      }
-      const updatedRelease = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
-        /*
-         * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">>
-         * is not compatible with the type we are passing here: UpdateRelease.Request['body']
-         */
-        // @ts-expect-error see above
-        data: releaseWithCreatorFields
-      });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-        const schedulingService = getService("scheduling", { strapi: strapi2 });
-        if (releaseData.scheduledAt) {
-          await schedulingService.set(id, releaseData.scheduledAt);
-        } else if (release2.scheduledAt) {
-          schedulingService.cancel(id);
+        'content-type-builder': {
+            visible: false
         }
-      }
-      this.updateReleaseStatus(id);
-      strapi2.telemetry.send("didUpdateContentRelease");
-      return updatedRelease;
     },
-    async createAction(releaseId, action) {
-      const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
-        strapi: strapi2
-      });
-      await Promise.all([
-        validateEntryContentType(action.entry.contentType),
-        validateUniqueEntry(releaseId, action)
-      ]);
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
-      if (!release2) {
-        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-      }
-      if (release2.releasedAt) {
-        throw new utils.errors.ValidationError("Release already published");
-      }
-      const { entry, type } = action;
-      const populatedEntry = await getPopulatedEntry(entry.contentType, entry.id, { strapi: strapi2 });
-      const isEntryValid = await getEntryValidStatus(entry.contentType, populatedEntry, { strapi: strapi2 });
-      const releaseAction2 = await strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
-        data: {
-          type,
-          contentType: entry.contentType,
-          locale: entry.locale,
-          isEntryValid,
-          entry: {
-            id: entry.id,
-            __type: entry.contentType,
-            __pivot: { field: "entry" }
-          },
-          release: releaseId
+    attributes: {
+        name: {
+            type: 'string',
+            required: true
         },
-        populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
-      });
-      this.updateReleaseStatus(releaseId);
-      return releaseAction2;
-    },
-    async findActions(releaseId, query) {
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-        fields: ["id"]
-      });
-      if (!release2) {
-        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-      }
-      return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
-        ...query,
-        populate: {
-          entry: {
-            populate: "*"
-          }
+        releasedAt: {
+            type: 'datetime'
+        },
+        scheduledAt: {
+            type: 'datetime'
+        },
+        timezone: {
+            type: 'string'
         },
-        filters: {
-          release: releaseId
+        status: {
+            type: 'enumeration',
+            enum: [
+                'ready',
+                'blocked',
+                'failed',
+                'done',
+                'empty'
+            ],
+            required: true
+        },
+        actions: {
+            type: 'relation',
+            relation: 'oneToMany',
+            target: RELEASE_ACTION_MODEL_UID,
+            mappedBy: 'release'
         }
-      });
+    }
+};
+
+const release$1 = {
+    schema: schema$1
+};
+
+var schema = {
+    collectionName: 'strapi_release_actions',
+    info: {
+        singularName: 'release-action',
+        pluralName: 'release-actions',
+        displayName: 'Release Action'
     },
-    async countActions(query) {
-      return strapi2.entityService.count(RELEASE_ACTION_MODEL_UID, query);
+    options: {
+        draftAndPublish: false
     },
-    async groupActions(actions, groupBy) {
-      const contentTypeUids = actions.reduce((acc, action) => {
-        if (!acc.includes(action.contentType)) {
-          acc.push(action.contentType);
+    pluginOptions: {
+        'content-manager': {
+            visible: false
+        },
+        'content-type-builder': {
+            visible: false
         }
-        return acc;
-      }, []);
-      const allReleaseContentTypesDictionary = await this.getContentTypesDataForActions(
-        contentTypeUids
-      );
-      const allLocalesDictionary = await this.getLocalesDataForActions();
-      const formattedData = actions.map((action) => {
-        const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
-        return {
-          ...action,
-          locale: action.locale ? allLocalesDictionary[action.locale] : null,
-          contentType: {
-            displayName,
-            mainFieldValue: action.entry[mainField],
-            uid: action.contentType
-          }
-        };
-      });
-      const groupName = getGroupName(groupBy);
-      return ___default.default.groupBy(groupName)(formattedData);
-    },
-    async getLocalesDataForActions() {
-      if (!strapi2.plugin("i18n")) {
-        return {};
-      }
-      const allLocales = await strapi2.plugin("i18n").service("locales").find() || [];
-      return allLocales.reduce((acc, locale) => {
-        acc[locale.code] = { name: locale.name, code: locale.code };
-        return acc;
-      }, {});
-    },
-    async getContentTypesDataForActions(contentTypesUids) {
-      const contentManagerContentTypeService = strapi2.plugin("content-manager").service("content-types");
-      const contentTypesData = {};
-      for (const contentTypeUid of contentTypesUids) {
-        const contentTypeConfig = await contentManagerContentTypeService.findConfiguration({
-          uid: contentTypeUid
-        });
-        contentTypesData[contentTypeUid] = {
-          mainField: contentTypeConfig.settings.mainField,
-          displayName: strapi2.getModel(contentTypeUid).info.displayName
-        };
-      }
-      return contentTypesData;
     },
-    getContentTypeModelsFromActions(actions) {
-      const contentTypeUids = actions.reduce((acc, action) => {
-        if (!acc.includes(action.contentType)) {
-          acc.push(action.contentType);
-        }
-        return acc;
-      }, []);
-      const contentTypeModelsMap = contentTypeUids.reduce(
-        (acc, contentTypeUid) => {
-          acc[contentTypeUid] = strapi2.getModel(contentTypeUid);
-          return acc;
+    attributes: {
+        type: {
+            type: 'enumeration',
+            enum: [
+                'publish',
+                'unpublish'
+            ],
+            required: true
         },
-        {}
-      );
-      return contentTypeModelsMap;
-    },
-    async getAllComponents() {
-      const contentManagerComponentsService = strapi2.plugin("content-manager").service("components");
-      const components = await contentManagerComponentsService.findAllComponents();
-      const componentsMap = components.reduce(
-        (acc, component) => {
-          acc[component.uid] = component;
-          return acc;
+        contentType: {
+            type: 'string',
+            required: true
         },
-        {}
-      );
-      return componentsMap;
-    },
-    async delete(releaseId) {
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-        populate: {
-          actions: {
-            fields: ["id"]
-          }
+        entryDocumentId: {
+            type: 'string'
+        },
+        locale: {
+            type: 'string'
+        },
+        release: {
+            type: 'relation',
+            relation: 'manyToOne',
+            target: RELEASE_MODEL_UID,
+            inversedBy: 'actions'
+        },
+        isEntryValid: {
+            type: 'boolean'
         }
-      });
-      if (!release2) {
-        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-      }
-      if (release2.releasedAt) {
-        throw new utils.errors.ValidationError("Release already published");
-      }
-      await strapi2.db.transaction(async () => {
-        await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-          where: {
-            id: {
-              $in: release2.actions.map((action) => action.id)
-            }
-          }
-        });
-        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
-      });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && release2.scheduledAt) {
-        const schedulingService = getService("scheduling", { strapi: strapi2 });
-        await schedulingService.cancel(release2.id);
-      }
-      strapi2.telemetry.send("didDeleteContentRelease");
-      return release2;
-    },
-    async publish(releaseId) {
-      const {
-        release: release2,
-        error
-      } = await strapi2.db.transaction(async ({ trx }) => {
-        const lockedRelease = await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).select(["id", "name", "releasedAt", "status"]).first().transacting(trx).forUpdate().execute();
-        if (!lockedRelease) {
-          throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-        }
-        if (lockedRelease.releasedAt) {
-          throw new utils.errors.ValidationError("Release already published");
+    }
+};
+
+const releaseAction$1 = {
+    schema
+};
+
+const contentTypes = {
+    release: release$1,
+    'release-action': releaseAction$1
+};
+
+const createReleaseService = ({ strapi })=>{
+    const dispatchWebhook = (event, { isPublished, release, error })=>{
+        strapi.eventHub.emit(event, {
+            isPublished,
+            error,
+            release
+        });
+    };
+    /**
+   * Given a release id, it returns the actions formatted ready to be used to publish them.
+   * We split them by contentType and type (publish/unpublish) and extract only the documentIds and locales.
+   */ const getFormattedActions = async (releaseId)=>{
+        const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+            where: {
+                release: {
+                    id: releaseId
+                }
+            }
+        });
+        if (actions.length === 0) {
+            throw new utils.errors.ValidationError('No entries to publish');
         }
-        if (lockedRelease.status === "failed") {
-          throw new utils.errors.ValidationError("Release failed to publish");
+        /**
+     * We separate publish and unpublish actions, grouping them by contentType and extracting only their documentIds and locales.
+     */ const formattedActions = {};
+        for (const action of actions){
+            const contentTypeUid = action.contentType;
+            if (!formattedActions[contentTypeUid]) {
+                formattedActions[contentTypeUid] = {
+                    publish: [],
+                    unpublish: []
+                };
+            }
+            formattedActions[contentTypeUid][action.type].push({
+                documentId: action.entryDocumentId,
+                locale: action.locale
+            });
         }
-        try {
-          strapi2.log.info(`[Content Releases] Starting to publish release ${lockedRelease.name}`);
-          const { collectionTypeActions, singleTypeActions } = await getFormattedActions(
-            releaseId
-          );
-          await strapi2.db.transaction(async () => {
-            for (const { uid, action, id } of singleTypeActions) {
-              await publishSingleTypeAction(uid, action, id);
-            }
-            for (const contentTypeUid of Object.keys(collectionTypeActions)) {
-              const uid = contentTypeUid;
-              await publishCollectionTypeAction(
-                uid,
-                collectionTypeActions[uid].entriesToPublishIds,
-                collectionTypeActions[uid].entriesToUnpublishIds
-              );
-            }
-          });
-          const release22 = await strapi2.db.query(RELEASE_MODEL_UID).update({
-            where: {
-              id: releaseId
-            },
-            data: {
-              status: "done",
-              releasedAt: /* @__PURE__ */ new Date()
-            }
-          });
-          if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-            dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
-              isPublished: true,
-              release: release22
+        return formattedActions;
+    };
+    return {
+        async create (releaseData, { user }) {
+            const releaseWithCreatorFields = await utils.setCreatorFields({
+                user
+            })(releaseData);
+            const { validatePendingReleasesLimit, validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService('release-validation', {
+                strapi
             });
-          }
-          strapi2.telemetry.send("didPublishContentRelease");
-          return { release: release22, error: null };
-        } catch (error2) {
-          if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-            dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
-              isPublished: false,
-              error: error2
+            await Promise.all([
+                validatePendingReleasesLimit(),
+                validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
+                validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
+            ]);
+            const release = await strapi.db.query(RELEASE_MODEL_UID).create({
+                data: {
+                    ...releaseWithCreatorFields,
+                    status: 'empty'
+                }
             });
-          }
-          await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).update({
-            status: "failed"
-          }).transacting(trx).execute();
-          return {
-            release: null,
-            error: error2
-          };
-        }
-      });
-      if (error) {
-        throw error;
-      }
-      return release2;
-    },
-    async updateAction(actionId, releaseId, update) {
-      const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
-        where: {
-          id: actionId,
-          release: {
-            id: releaseId,
-            releasedAt: {
-              $null: true
+            if (releaseWithCreatorFields.scheduledAt) {
+                const schedulingService = getService('scheduling', {
+                    strapi
+                });
+                await schedulingService.set(release.id, release.scheduledAt);
             }
-          }
+            strapi.telemetry.send('didCreateContentRelease');
+            return release;
         },
-        data: update
-      });
-      if (!updatedAction) {
-        throw new utils.errors.NotFoundError(
-          `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
-        );
-      }
-      return updatedAction;
-    },
-    async deleteAction(actionId, releaseId) {
-      const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
-        where: {
-          id: actionId,
-          release: {
-            id: releaseId,
-            releasedAt: {
-              $null: true
+        async findOne (id, query = {}) {
+            const dbQuery = strapi.get('query-params').transform(RELEASE_MODEL_UID, query);
+            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                ...dbQuery,
+                where: {
+                    id
+                }
+            });
+            return release;
+        },
+        findPage (query) {
+            const dbQuery = strapi.get('query-params').transform(RELEASE_MODEL_UID, query ?? {});
+            return strapi.db.query(RELEASE_MODEL_UID).findPage({
+                ...dbQuery,
+                populate: {
+                    actions: {
+                        count: true
+                    }
+                }
+            });
+        },
+        findMany (query) {
+            const dbQuery = strapi.get('query-params').transform(RELEASE_MODEL_UID, query ?? {});
+            return strapi.db.query(RELEASE_MODEL_UID).findMany({
+                ...dbQuery
+            });
+        },
+        async update (id, releaseData, { user }) {
+            const releaseWithCreatorFields = await utils.setCreatorFields({
+                user,
+                isEdition: true
+            })(releaseData);
+            const { validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService('release-validation', {
+                strapi
+            });
+            await Promise.all([
+                validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
+                validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
+            ]);
+            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id
+                }
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${id}`);
             }
-          }
-        }
-      });
-      if (!deletedAction) {
-        throw new utils.errors.NotFoundError(
-          `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
-        );
-      }
-      this.updateReleaseStatus(releaseId);
-      return deletedAction;
-    },
-    async updateReleaseStatus(releaseId) {
-      const [totalActions, invalidActions] = await Promise.all([
-        this.countActions({
-          filters: {
-            release: releaseId
-          }
-        }),
-        this.countActions({
-          filters: {
-            release: releaseId,
-            isEntryValid: false
-          }
-        })
-      ]);
-      if (totalActions > 0) {
-        if (invalidActions > 0) {
-          return strapi2.db.query(RELEASE_MODEL_UID).update({
-            where: {
-              id: releaseId
-            },
-            data: {
-              status: "blocked"
+            if (release.releasedAt) {
+                throw new utils.errors.ValidationError('Release already published');
             }
-          });
-        }
-        return strapi2.db.query(RELEASE_MODEL_UID).update({
-          where: {
-            id: releaseId
-          },
-          data: {
-            status: "ready"
-          }
-        });
-      }
-      return strapi2.db.query(RELEASE_MODEL_UID).update({
-        where: {
-          id: releaseId
+            const updatedRelease = await strapi.db.query(RELEASE_MODEL_UID).update({
+                where: {
+                    id
+                },
+                data: releaseWithCreatorFields
+            });
+            const schedulingService = getService('scheduling', {
+                strapi
+            });
+            if (releaseData.scheduledAt) {
+                // set function always cancel the previous job if it exists, so we can call it directly
+                await schedulingService.set(id, releaseData.scheduledAt);
+            } else if (release.scheduledAt) {
+                // When user don't send a scheduledAt and we have one on the release, means that user want to unschedule it
+                schedulingService.cancel(id);
+            }
+            this.updateReleaseStatus(id);
+            strapi.telemetry.send('didUpdateContentRelease');
+            return updatedRelease;
         },
-        data: {
-          status: "empty"
+        async getAllComponents () {
+            const contentManagerComponentsService = strapi.plugin('content-manager').service('components');
+            const components = await contentManagerComponentsService.findAllComponents();
+            const componentsMap = components.reduce((acc, component)=>{
+                acc[component.uid] = component;
+                return acc;
+            }, {});
+            return componentsMap;
+        },
+        async delete (releaseId) {
+            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId
+                },
+                populate: {
+                    actions: {
+                        select: [
+                            'id'
+                        ]
+                    }
+                }
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            if (release.releasedAt) {
+                throw new utils.errors.ValidationError('Release already published');
+            }
+            // Only delete the release and its actions is you in fact can delete all the actions and the release
+            // Otherwise, if the transaction fails it throws an error
+            await strapi.db.transaction(async ()=>{
+                await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+                    where: {
+                        id: {
+                            $in: release.actions.map((action)=>action.id)
+                        }
+                    }
+                });
+                await strapi.db.query(RELEASE_MODEL_UID).delete({
+                    where: {
+                        id: releaseId
+                    }
+                });
+            });
+            if (release.scheduledAt) {
+                const schedulingService = getService('scheduling', {
+                    strapi
+                });
+                await schedulingService.cancel(release.id);
+            }
+            strapi.telemetry.send('didDeleteContentRelease');
+            return release;
+        },
+        async publish (releaseId) {
+            const { release, error } = await strapi.db.transaction(async ({ trx })=>{
+                /**
+           * We lock the release in this transaction, so any other process trying to publish it will wait until this transaction is finished
+           * In this transaction we don't care about rollback, becasue we want to persist the lock until the end and if it fails we want to change the release status to failed
+           */ const lockedRelease = await strapi.db?.queryBuilder(RELEASE_MODEL_UID).where({
+                    id: releaseId
+                }).select([
+                    'id',
+                    'name',
+                    'releasedAt',
+                    'status'
+                ]).first().transacting(trx).forUpdate().execute();
+                if (!lockedRelease) {
+                    throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+                }
+                if (lockedRelease.releasedAt) {
+                    throw new utils.errors.ValidationError('Release already published');
+                }
+                if (lockedRelease.status === 'failed') {
+                    throw new utils.errors.ValidationError('Release failed to publish');
+                }
+                try {
+                    strapi.log.info(`[Content Releases] Starting to publish release ${lockedRelease.name}`);
+                    const formattedActions = await getFormattedActions(releaseId);
+                    await strapi.db.transaction(async ()=>Promise.all(Object.keys(formattedActions).map(async (contentTypeUid)=>{
+                            const contentType = contentTypeUid;
+                            const { publish, unpublish } = formattedActions[contentType];
+                            return Promise.all([
+                                ...publish.map((params)=>strapi.documents(contentType).publish(params)),
+                                ...unpublish.map((params)=>strapi.documents(contentType).unpublish(params))
+                            ]);
+                        })));
+                    const release = await strapi.db.query(RELEASE_MODEL_UID).update({
+                        where: {
+                            id: releaseId
+                        },
+                        data: {
+                            status: 'done',
+                            releasedAt: new Date()
+                        }
+                    });
+                    dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+                        isPublished: true,
+                        release
+                    });
+                    strapi.telemetry.send('didPublishContentRelease');
+                    return {
+                        release,
+                        error: null
+                    };
+                } catch (error) {
+                    dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+                        isPublished: false,
+                        error
+                    });
+                    // We need to run the update in the same transaction because the release is locked
+                    await strapi.db?.queryBuilder(RELEASE_MODEL_UID).where({
+                        id: releaseId
+                    }).update({
+                        status: 'failed'
+                    }).transacting(trx).execute();
+                    // At this point, we don't want to throw the error because if that happen we rollback the change in the release status
+                    // We want to throw the error after the transaction is finished, so we return the error
+                    return {
+                        release: null,
+                        error
+                    };
+                }
+            });
+            // Now the first transaction is commited, we can safely throw the error if it exists
+            if (error instanceof Error) {
+                throw error;
+            }
+            return release;
+        },
+        async updateReleaseStatus (releaseId) {
+            const releaseActionService = getService('release-action', {
+                strapi
+            });
+            const [totalActions, invalidActions] = await Promise.all([
+                releaseActionService.countActions({
+                    filters: {
+                        release: releaseId
+                    }
+                }),
+                releaseActionService.countActions({
+                    filters: {
+                        release: releaseId,
+                        isEntryValid: false
+                    }
+                })
+            ]);
+            if (totalActions > 0) {
+                if (invalidActions > 0) {
+                    return strapi.db.query(RELEASE_MODEL_UID).update({
+                        where: {
+                            id: releaseId
+                        },
+                        data: {
+                            status: 'blocked'
+                        }
+                    });
+                }
+                return strapi.db.query(RELEASE_MODEL_UID).update({
+                    where: {
+                        id: releaseId
+                    },
+                    data: {
+                        status: 'ready'
+                    }
+                });
+            }
+            return strapi.db.query(RELEASE_MODEL_UID).update({
+                where: {
+                    id: releaseId
+                },
+                data: {
+                    status: 'empty'
+                }
+            });
         }
-      });
-    }
-  };
+    };
 };
-const createReleaseValidationService = ({ strapi: strapi2 }) => ({
-  async validateUniqueEntry(releaseId, releaseActionArgs) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-      populate: { actions: { populate: { entry: { fields: ["id"] } } } }
-    });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-    }
-    const isEntryInRelease = release2.actions.some(
-      (action) => Number(action.entry.id) === Number(releaseActionArgs.entry.id) && action.contentType === releaseActionArgs.entry.contentType
-    );
-    if (isEntryInRelease) {
-      throw new utils.errors.ValidationError(
-        `Entry with id ${releaseActionArgs.entry.id} and contentType ${releaseActionArgs.entry.contentType} already exists in release with id ${releaseId}`
-      );
+
+const getGroupName = (queryValue)=>{
+    switch(queryValue){
+        case 'contentType':
+            return 'contentType.displayName';
+        case 'type':
+            return 'type';
+        case 'locale':
+            return _.getOr('No locale', 'locale.name');
+        default:
+            return 'contentType.displayName';
     }
-  },
-  validateEntryContentType(contentTypeUid) {
-    const contentType = strapi2.contentType(contentTypeUid);
-    if (!contentType) {
-      throw new utils.errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
-    }
-    if (!contentType.options?.draftAndPublish) {
-      throw new utils.errors.ValidationError(
-        `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`
-      );
-    }
-  },
-  async validatePendingReleasesLimit() {
-    const maximumPendingReleases = (
-      // @ts-expect-error - options is not typed into features
-      EE__default.default.features.get("cms-content-releases")?.options?.maximumReleases || 3
-    );
-    const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
-      filters: {
-        releasedAt: {
-          $null: true
+};
+const createReleaseActionService = ({ strapi })=>{
+    const getLocalesDataForActions = async ()=>{
+        if (!strapi.plugin('i18n')) {
+            return {};
         }
-      }
-    });
-    if (pendingReleasesCount >= maximumPendingReleases) {
-      throw new utils.errors.ValidationError("You have reached the maximum number of pending releases");
-    }
-  },
-  async validateUniqueNameForPendingRelease(name, id) {
-    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
-      filters: {
-        releasedAt: {
-          $null: true
+        const allLocales = await strapi.plugin('i18n').service('locales').find() || [];
+        return allLocales.reduce((acc, locale)=>{
+            acc[locale.code] = {
+                name: locale.name,
+                code: locale.code
+            };
+            return acc;
+        }, {});
+    };
+    const getContentTypesDataForActions = async (contentTypesUids)=>{
+        const contentManagerContentTypeService = strapi.plugin('content-manager').service('content-types');
+        const contentTypesData = {};
+        for (const contentTypeUid of contentTypesUids){
+            const contentTypeConfig = await contentManagerContentTypeService.findConfiguration({
+                uid: contentTypeUid
+            });
+            contentTypesData[contentTypeUid] = {
+                mainField: contentTypeConfig.settings.mainField,
+                displayName: strapi.getModel(contentTypeUid).info.displayName
+            };
+        }
+        return contentTypesData;
+    };
+    return {
+        async create (releaseId, action, { disableUpdateReleaseStatus = false } = {}) {
+            const { validateEntryData, validateUniqueEntry } = getService('release-validation', {
+                strapi
+            });
+            await Promise.all([
+                validateEntryData(action.contentType, action.entryDocumentId),
+                validateUniqueEntry(releaseId, action)
+            ]);
+            // If we are adding a singleType, we need to append the documentId of that singleType
+            const model = strapi.contentType(action.contentType);
+            if (model.kind === 'singleType') {
+                const document = await strapi.db.query(model.uid).findOne({
+                    select: [
+                        'documentId'
+                    ]
+                });
+                if (!document) {
+                    throw new utils.errors.NotFoundError(`No entry found for contentType ${action.contentType}`);
+                }
+                action.entryDocumentId = document.documentId;
+            }
+            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId
+                }
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            if (release.releasedAt) {
+                throw new utils.errors.ValidationError('Release already published');
+            }
+            // If the action is a publish, check if the entry is valid
+            // If the action is an unpublish, skip the validation
+            const actionStatus = action.type === 'publish' ? await getDraftEntryValidStatus({
+                contentType: action.contentType,
+                documentId: action.entryDocumentId,
+                locale: action.locale
+            }, {
+                strapi
+            }) : true;
+            const releaseAction = await strapi.db.query(RELEASE_ACTION_MODEL_UID).create({
+                data: {
+                    ...action,
+                    release: release.id,
+                    isEntryValid: actionStatus
+                },
+                populate: {
+                    release: {
+                        select: [
+                            'id'
+                        ]
+                    }
+                }
+            });
+            if (!disableUpdateReleaseStatus) {
+                getService('release', {
+                    strapi
+                }).updateReleaseStatus(release.id);
+            }
+            return releaseAction;
         },
-        name,
-        ...id && { id: { $ne: id } }
-      }
-    });
-    const isNameUnique = pendingReleases.length === 0;
-    if (!isNameUnique) {
-      throw new utils.errors.ValidationError(`Release with name ${name} already exists`);
-    }
-  },
-  async validateScheduledAtIsLaterThanNow(scheduledAt) {
-    if (scheduledAt && new Date(scheduledAt) <= /* @__PURE__ */ new Date()) {
-      throw new utils.errors.ValidationError("Scheduled at must be later than now");
+        async findPage (releaseId, query) {
+            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId
+                },
+                select: [
+                    'id'
+                ]
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            const dbQuery = strapi.get('query-params').transform(RELEASE_ACTION_MODEL_UID, query ?? {});
+            const { results: actions, pagination } = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findPage({
+                ...dbQuery,
+                where: {
+                    release: releaseId
+                }
+            });
+            // For each contentType on the release, we create a custom populate object for nested relations
+            const populateBuilderService = strapi.plugin('content-manager').service('populate-builder');
+            const actionsWithEntry = await utils.async.map(actions, async (action)=>{
+                // @ts-expect-error - Core.Service type is not a function
+                const populate = await populateBuilderService(action.contentType).populateDeep(Infinity).build();
+                const entry = await getEntry({
+                    contentType: action.contentType,
+                    documentId: action.entryDocumentId,
+                    locale: action.locale,
+                    populate,
+                    status: action.type === 'publish' ? 'draft' : 'published'
+                }, {
+                    strapi
+                });
+                return {
+                    ...action,
+                    entry,
+                    status: entry ? await getEntryStatus(action.contentType, entry) : null
+                };
+            });
+            return {
+                results: actionsWithEntry,
+                pagination
+            };
+        },
+        async groupActions (actions, groupBy) {
+            const contentTypeUids = actions.reduce((acc, action)=>{
+                if (!acc.includes(action.contentType)) {
+                    acc.push(action.contentType);
+                }
+                return acc;
+            }, []);
+            const allReleaseContentTypesDictionary = await getContentTypesDataForActions(contentTypeUids);
+            const allLocalesDictionary = await getLocalesDataForActions();
+            const formattedData = actions.map((action)=>{
+                const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
+                return {
+                    ...action,
+                    locale: action.locale ? allLocalesDictionary[action.locale] : null,
+                    contentType: {
+                        displayName,
+                        mainFieldValue: action.entry[mainField],
+                        uid: action.contentType
+                    }
+                };
+            });
+            const groupName = getGroupName(groupBy);
+            return _.groupBy(groupName)(formattedData);
+        },
+        async getContentTypeModelsFromActions (actions) {
+            const contentTypeUids = actions.reduce((acc, action)=>{
+                if (!acc.includes(action.contentType)) {
+                    acc.push(action.contentType);
+                }
+                return acc;
+            }, []);
+            const workflowsService = strapi.plugin('review-workflows').service('workflows');
+            const contentTypeModelsMap = await utils.async.reduce(contentTypeUids)(async (accPromise, contentTypeUid)=>{
+                const acc = await accPromise;
+                const contentTypeModel = strapi.getModel(contentTypeUid);
+                const workflow = await workflowsService.getAssignedWorkflow(contentTypeUid, {
+                    populate: 'stageRequiredToPublish'
+                });
+                acc[contentTypeUid] = {
+                    ...contentTypeModel,
+                    hasReviewWorkflow: !!workflow,
+                    stageRequiredToPublish: workflow?.stageRequiredToPublish
+                };
+                return acc;
+            }, {});
+            return contentTypeModelsMap;
+        },
+        async countActions (query) {
+            const dbQuery = strapi.get('query-params').transform(RELEASE_ACTION_MODEL_UID, query ?? {});
+            return strapi.db.query(RELEASE_ACTION_MODEL_UID).count(dbQuery);
+        },
+        async update (actionId, releaseId, update) {
+            const action = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findOne({
+                where: {
+                    id: actionId,
+                    release: {
+                        id: releaseId,
+                        releasedAt: {
+                            $null: true
+                        }
+                    }
+                }
+            });
+            if (!action) {
+                throw new utils.errors.NotFoundError(`Action with id ${actionId} not found in release with id ${releaseId} or it is already published`);
+            }
+            const actionStatus = update.type === 'publish' ? await getDraftEntryValidStatus({
+                contentType: action.contentType,
+                documentId: action.entryDocumentId,
+                locale: action.locale
+            }, {
+                strapi
+            }) : true;
+            const updatedAction = await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+                where: {
+                    id: actionId,
+                    release: {
+                        id: releaseId,
+                        releasedAt: {
+                            $null: true
+                        }
+                    }
+                },
+                data: {
+                    ...update,
+                    isEntryValid: actionStatus
+                }
+            });
+            getService('release', {
+                strapi
+            }).updateReleaseStatus(releaseId);
+            return updatedAction;
+        },
+        async delete (actionId, releaseId) {
+            const deletedAction = await strapi.db.query(RELEASE_ACTION_MODEL_UID).delete({
+                where: {
+                    id: actionId,
+                    release: {
+                        id: releaseId,
+                        releasedAt: {
+                            $null: true
+                        }
+                    }
+                }
+            });
+            if (!deletedAction) {
+                throw new utils.errors.NotFoundError(`Action with id ${actionId} not found in release with id ${releaseId} or it is already published`);
+            }
+            getService('release', {
+                strapi
+            }).updateReleaseStatus(releaseId);
+            return deletedAction;
+        },
+        async validateActionsByContentTypes (contentTypeUids) {
+            const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+                where: {
+                    contentType: {
+                        $in: contentTypeUids
+                    },
+                    // We only want to validate actions that are going to be published
+                    type: 'publish',
+                    release: {
+                        releasedAt: {
+                            $null: true
+                        }
+                    }
+                },
+                populate: {
+                    release: true
+                }
+            });
+            const releasesUpdated = [];
+            await utils.async.map(actions, async (action)=>{
+                const isValid = await getDraftEntryValidStatus({
+                    contentType: action.contentType,
+                    documentId: action.entryDocumentId,
+                    locale: action.locale
+                }, {
+                    strapi
+                });
+                await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+                    where: {
+                        id: action.id
+                    },
+                    data: {
+                        isEntryValid: isValid
+                    }
+                });
+                if (!releasesUpdated.includes(action.release.id)) {
+                    releasesUpdated.push(action.release.id);
+                }
+                return {
+                    id: action.id,
+                    isEntryValid: isValid
+                };
+            });
+            if (releasesUpdated.length > 0) {
+                await utils.async.map(releasesUpdated, async (releaseId)=>{
+                    await getService('release', {
+                        strapi
+                    }).updateReleaseStatus(releaseId);
+                });
+            }
+        }
+    };
+};
+
+class AlreadyOnReleaseError extends utils.errors.ApplicationError {
+    constructor(message){
+        super(message);
+        this.name = 'AlreadyOnReleaseError';
     }
-  }
-});
-const createSchedulingService = ({ strapi: strapi2 }) => {
-  const scheduledJobs = /* @__PURE__ */ new Map();
-  return {
-    async set(releaseId, scheduleDate) {
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: releaseId, releasedAt: null } });
-      if (!release2) {
-        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-      }
-      const job = nodeSchedule.scheduleJob(scheduleDate, async () => {
-        try {
-          await getService("release").publish(releaseId);
-        } catch (error) {
+}
+const createReleaseValidationService = ({ strapi })=>({
+        async validateUniqueEntry (releaseId, releaseActionArgs) {
+            /**
+     * Asserting the type, otherwise TS complains: 'release.actions' is of type 'unknown', even though the types come through for non-populated fields...
+     * Possibly related to the comment on GetValues: https://github.com/strapi/strapi/blob/main/packages/core/types/src/modules/entity-service/result.ts
+     */ const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId
+                },
+                populate: {
+                    actions: true
+                }
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            const isEntryInRelease = release.actions.some((action)=>action.entryDocumentId === releaseActionArgs.entryDocumentId && action.contentType === releaseActionArgs.contentType && (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true));
+            if (isEntryInRelease) {
+                throw new AlreadyOnReleaseError(`Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ''} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`);
+            }
+        },
+        validateEntryData (contentTypeUid, entryDocumentId) {
+            const contentType = strapi.contentType(contentTypeUid);
+            if (!contentType) {
+                throw new utils.errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
+            }
+            if (!utils.contentTypes.hasDraftAndPublish(contentType)) {
+                throw new utils.errors.ValidationError(`Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`);
+            }
+            if (contentType.kind === 'collectionType' && !entryDocumentId) {
+                throw new utils.errors.ValidationError('Document id is required for collection type');
+            }
+        },
+        async validatePendingReleasesLimit () {
+            // Use the maximum releases option if it exists, otherwise default to 3
+            const featureCfg = strapi.ee.features.get('cms-content-releases');
+            const maximumPendingReleases = typeof featureCfg === 'object' && featureCfg?.options?.maximumReleases || 3;
+            const [, pendingReleasesCount] = await strapi.db.query(RELEASE_MODEL_UID).findWithCount({
+                filters: {
+                    releasedAt: {
+                        $null: true
+                    }
+                }
+            });
+            // Unlimited is a number that will never be reached like 9999
+            if (pendingReleasesCount >= maximumPendingReleases) {
+                throw new utils.errors.ValidationError('You have reached the maximum number of pending releases');
+            }
+        },
+        async validateUniqueNameForPendingRelease (name, id) {
+            const pendingReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+                where: {
+                    releasedAt: {
+                        $null: true
+                    },
+                    name,
+                    ...id && {
+                        id: {
+                            $ne: id
+                        }
+                    }
+                }
+            });
+            const isNameUnique = pendingReleases.length === 0;
+            if (!isNameUnique) {
+                throw new utils.errors.ValidationError(`Release with name ${name} already exists`);
+            }
+        },
+        async validateScheduledAtIsLaterThanNow (scheduledAt) {
+            if (scheduledAt && new Date(scheduledAt) <= new Date()) {
+                throw new utils.errors.ValidationError('Scheduled at must be later than now');
+            }
         }
-        this.cancel(releaseId);
-      });
-      if (scheduledJobs.has(releaseId)) {
-        this.cancel(releaseId);
-      }
-      scheduledJobs.set(releaseId, job);
-      return scheduledJobs;
-    },
-    cancel(releaseId) {
-      if (scheduledJobs.has(releaseId)) {
-        scheduledJobs.get(releaseId).cancel();
-        scheduledJobs.delete(releaseId);
-      }
-      return scheduledJobs;
-    },
-    getAll() {
-      return scheduledJobs;
-    },
-    /**
+    });
+
+const createSchedulingService = ({ strapi })=>{
+    const scheduledJobs = new Map();
+    return {
+        async set (releaseId, scheduleDate) {
+            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId,
+                    releasedAt: null
+                }
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            const job = nodeSchedule.scheduleJob(scheduleDate, async ()=>{
+                try {
+                    await getService('release', {
+                        strapi
+                    }).publish(releaseId);
+                // @TODO: Trigger webhook with success message
+                } catch (error) {
+                // @TODO: Trigger webhook with error message
+                }
+                this.cancel(releaseId);
+            });
+            if (scheduledJobs.has(releaseId)) {
+                this.cancel(releaseId);
+            }
+            scheduledJobs.set(releaseId, job);
+            return scheduledJobs;
+        },
+        cancel (releaseId) {
+            if (scheduledJobs.has(releaseId)) {
+                scheduledJobs.get(releaseId).cancel();
+                scheduledJobs.delete(releaseId);
+            }
+            return scheduledJobs;
+        },
+        getAll () {
+            return scheduledJobs;
+        },
+        /**
      * On bootstrap, we can use this function to make sure to sync the scheduled jobs from the database that are not yet released
      * This is useful in case the server was restarted and the scheduled jobs were lost
      * This also could be used to sync different Strapi instances in case of a cluster
-     */
-    async syncFromDatabase() {
-      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-          scheduledAt: {
-            $gte: /* @__PURE__ */ new Date()
-          },
-          releasedAt: null
+     */ async syncFromDatabase () {
+            const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+                where: {
+                    scheduledAt: {
+                        $gte: new Date()
+                    },
+                    releasedAt: null
+                }
+            });
+            for (const release of releases){
+                this.set(release.id, release.scheduledAt);
+            }
+            return scheduledJobs;
         }
-      });
-      for (const release2 of releases) {
-        this.set(release2.id, release2.scheduledAt);
-      }
-      return scheduledJobs;
-    }
-  };
+    };
+};
+
+const DEFAULT_SETTINGS = {
+    defaultTimezone: null
 };
+const createSettingsService = ({ strapi })=>{
+    const getStore = async ()=>strapi.store({
+            type: 'core',
+            name: 'content-releases'
+        });
+    return {
+        async update ({ settings }) {
+            const store = await getStore();
+            store.set({
+                key: 'settings',
+                value: settings
+            });
+            return settings;
+        },
+        async find () {
+            const store = await getStore();
+            const settings = await store.get({
+                key: 'settings'
+            });
+            return {
+                ...DEFAULT_SETTINGS,
+                ...settings || {}
+            };
+        }
+    };
+};
+
 const services = {
-  release: createReleaseService,
-  "release-validation": createReleaseValidationService,
-  ...strapi.features.future.isEnabled("contentReleasesScheduling") ? { scheduling: createSchedulingService } : {}
+    release: createReleaseService,
+    'release-action': createReleaseActionService,
+    'release-validation': createReleaseValidationService,
+    scheduling: createSchedulingService,
+    settings: createSettingsService
 };
-const RELEASE_SCHEMA = yup__namespace.object().shape({
-  name: yup__namespace.string().trim().required(),
-  scheduledAt: yup__namespace.string().nullable(),
-  isScheduled: yup__namespace.boolean().optional(),
-  time: yup__namespace.string().when("isScheduled", {
-    is: true,
-    then: yup__namespace.string().trim().required(),
-    otherwise: yup__namespace.string().nullable()
-  }),
-  timezone: yup__namespace.string().when("isScheduled", {
-    is: true,
-    then: yup__namespace.string().required().nullable(),
-    otherwise: yup__namespace.string().nullable()
-  }),
-  date: yup__namespace.string().when("isScheduled", {
-    is: true,
-    then: yup__namespace.string().required().nullable(),
-    otherwise: yup__namespace.string().nullable()
-  })
+
+const RELEASE_SCHEMA = utils.yup.object().shape({
+    name: utils.yup.string().trim().required(),
+    scheduledAt: utils.yup.string().nullable(),
+    timezone: utils.yup.string().when('scheduledAt', {
+        is: (value)=>value !== null && value !== undefined,
+        then: utils.yup.string().required(),
+        otherwise: utils.yup.string().nullable()
+    })
+}).required().noUnknown();
+const FIND_BY_DOCUMENT_ATTACHED_PARAMS_SCHEMA = utils.yup.object().shape({
+    contentType: utils.yup.string().required(),
+    entryDocumentId: utils.yup.string().nullable(),
+    hasEntryAttached: utils.yup.string().nullable(),
+    locale: utils.yup.string().nullable()
 }).required().noUnknown();
 const validateRelease = utils.validateYupSchema(RELEASE_SCHEMA);
+const validatefindByDocumentAttachedParams = utils.validateYupSchema(FIND_BY_DOCUMENT_ATTACHED_PARAMS_SCHEMA);
+
 const releaseController = {
-  async findMany(ctx) {
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: RELEASE_MODEL_UID
-    });
-    await permissionsManager.validateQuery(ctx.query);
-    const releaseService = getService("release", { strapi });
-    const isFindManyForContentTypeEntry = Boolean(ctx.query?.contentTypeUid && ctx.query?.entryId);
-    if (isFindManyForContentTypeEntry) {
-      const query = await permissionsManager.sanitizeQuery(ctx.query);
-      const contentTypeUid = query.contentTypeUid;
-      const entryId = query.entryId;
-      const hasEntryAttached = typeof query.hasEntryAttached === "string" ? JSON.parse(query.hasEntryAttached) : false;
-      const data = hasEntryAttached ? await releaseService.findManyWithContentTypeEntryAttached(contentTypeUid, entryId) : await releaseService.findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId);
-      ctx.body = { data };
-    } else {
-      const query = await permissionsManager.sanitizeQuery(ctx.query);
-      const { results, pagination } = await releaseService.findPage(query);
-      const data = results.map((release2) => {
-        const { actions, ...releaseData } = release2;
-        return {
-          ...releaseData,
-          actions: {
-            meta: {
-              count: actions.count
+    /**
+   * Find releases based on documents attached or not to the release.
+   * If `hasEntryAttached` is true, it will return all releases that have the entry attached.
+   * If `hasEntryAttached` is false, it will return all releases that don't have the entry attached.
+   */ async findByDocumentAttached (ctx) {
+        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
+            ability: ctx.state.userAbility,
+            model: RELEASE_MODEL_UID
+        });
+        await permissionsManager.validateQuery(ctx.query);
+        const releaseService = getService('release', {
+            strapi
+        });
+        const query = await permissionsManager.sanitizeQuery(ctx.query);
+        await validatefindByDocumentAttachedParams(query);
+        // If entry is a singleType, we need to manually add the entryDocumentId to the query
+        const model = strapi.getModel(query.contentType);
+        if (model.kind && model.kind === 'singleType') {
+            const document = await strapi.db.query(model.uid).findOne({
+                select: [
+                    'documentId'
+                ]
+            });
+            if (!document) {
+                throw new utils.errors.NotFoundError(`No entry found for contentType ${query.contentType}`);
             }
-          }
-        };
-      });
-      const pendingReleasesCount = await strapi.query(RELEASE_MODEL_UID).count({
-        where: {
-          releasedAt: null
+            query.entryDocumentId = document.documentId;
         }
-      });
-      ctx.body = { data, meta: { pagination, pendingReleasesCount } };
-    }
-  },
-  async findOne(ctx) {
-    const id = ctx.params.id;
-    const releaseService = getService("release", { strapi });
-    const release2 = await releaseService.findOne(id, { populate: ["createdBy"] });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`Release not found for id: ${id}`);
-    }
-    const count = await releaseService.countActions({
-      filters: {
-        release: id
-      }
-    });
-    const sanitizedRelease = {
-      ...release2,
-      createdBy: release2.createdBy ? strapi.admin.services.user.sanitizeUser(release2.createdBy) : null
-    };
-    const data = {
-      ...sanitizedRelease,
-      actions: {
-        meta: {
-          count
+        const { contentType, hasEntryAttached, entryDocumentId, locale } = query;
+        const isEntryAttached = typeof hasEntryAttached === 'string' ? Boolean(JSON.parse(hasEntryAttached)) : false;
+        if (isEntryAttached) {
+            const releases = await releaseService.findMany({
+                where: {
+                    releasedAt: null,
+                    actions: {
+                        contentType,
+                        entryDocumentId: entryDocumentId ?? null,
+                        locale: locale ?? null
+                    }
+                },
+                populate: {
+                    actions: {
+                        fields: [
+                            'type'
+                        ],
+                        filters: {
+                            contentType,
+                            entryDocumentId: entryDocumentId ?? null,
+                            locale: locale ?? null
+                        }
+                    }
+                }
+            });
+            ctx.body = {
+                data: releases
+            };
+        } else {
+            const relatedReleases = await releaseService.findMany({
+                where: {
+                    releasedAt: null,
+                    actions: {
+                        contentType,
+                        entryDocumentId: entryDocumentId ?? null,
+                        locale: locale ?? null
+                    }
+                }
+            });
+            const releases = await releaseService.findMany({
+                where: {
+                    $or: [
+                        {
+                            id: {
+                                $notIn: relatedReleases.map((release)=>release.id)
+                            }
+                        },
+                        {
+                            actions: null
+                        }
+                    ],
+                    releasedAt: null
+                }
+            });
+            ctx.body = {
+                data: releases
+            };
         }
-      }
-    };
-    ctx.body = { data };
-  },
-  async create(ctx) {
-    const user = ctx.state.user;
-    const releaseArgs = ctx.request.body;
-    await validateRelease(releaseArgs);
-    const releaseService = getService("release", { strapi });
-    const release2 = await releaseService.create(releaseArgs, { user });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: RELEASE_MODEL_UID
-    });
-    ctx.body = {
-      data: await permissionsManager.sanitizeOutput(release2)
-    };
-  },
-  async update(ctx) {
-    const user = ctx.state.user;
-    const releaseArgs = ctx.request.body;
-    const id = ctx.params.id;
-    await validateRelease(releaseArgs);
-    const releaseService = getService("release", { strapi });
-    const release2 = await releaseService.update(id, releaseArgs, { user });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: RELEASE_MODEL_UID
-    });
-    ctx.body = {
-      data: await permissionsManager.sanitizeOutput(release2)
-    };
-  },
-  async delete(ctx) {
-    const id = ctx.params.id;
-    const releaseService = getService("release", { strapi });
-    const release2 = await releaseService.delete(id);
-    ctx.body = {
-      data: release2
-    };
-  },
-  async publish(ctx) {
-    const user = ctx.state.user;
-    const id = ctx.params.id;
-    const releaseService = getService("release", { strapi });
-    const release2 = await releaseService.publish(id, { user });
-    const [countPublishActions, countUnpublishActions] = await Promise.all([
-      releaseService.countActions({
-        filters: {
-          release: id,
-          type: "publish"
+    },
+    async findPage (ctx) {
+        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
+            ability: ctx.state.userAbility,
+            model: RELEASE_MODEL_UID
+        });
+        await permissionsManager.validateQuery(ctx.query);
+        const releaseService = getService('release', {
+            strapi
+        });
+        const query = await permissionsManager.sanitizeQuery(ctx.query);
+        const { results, pagination } = await releaseService.findPage(query);
+        const data = results.map((release)=>{
+            const { actions, ...releaseData } = release;
+            return {
+                ...releaseData,
+                actions: {
+                    meta: {
+                        count: actions.count
+                    }
+                }
+            };
+        });
+        const pendingReleasesCount = await strapi.db.query(RELEASE_MODEL_UID).count({
+            where: {
+                releasedAt: null
+            }
+        });
+        ctx.body = {
+            data,
+            meta: {
+                pagination,
+                pendingReleasesCount
+            }
+        };
+    },
+    async findOne (ctx) {
+        const id = ctx.params.id;
+        const releaseService = getService('release', {
+            strapi
+        });
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const release = await releaseService.findOne(id, {
+            populate: [
+                'createdBy'
+            ]
+        });
+        if (!release) {
+            throw new utils.errors.NotFoundError(`Release not found for id: ${id}`);
         }
-      }),
-      releaseService.countActions({
-        filters: {
-          release: id,
-          type: "unpublish"
+        const count = await releaseActionService.countActions({
+            filters: {
+                release: id
+            }
+        });
+        const sanitizedRelease = {
+            ...release,
+            createdBy: release.createdBy ? strapi.service('admin::user').sanitizeUser(release.createdBy) : null
+        };
+        // Format the data object
+        const data = {
+            ...sanitizedRelease,
+            actions: {
+                meta: {
+                    count
+                }
+            }
+        };
+        ctx.body = {
+            data
+        };
+    },
+    async mapEntriesToReleases (ctx) {
+        const { contentTypeUid, documentIds, locale } = ctx.query;
+        if (!contentTypeUid || !documentIds) {
+            throw new utils.errors.ValidationError('Missing required query parameters');
         }
-      })
-    ]);
-    ctx.body = {
-      data: release2,
-      meta: {
-        totalEntries: countPublishActions + countUnpublishActions,
-        totalPublishedEntries: countPublishActions,
-        totalUnpublishedEntries: countUnpublishActions
-      }
-    };
-  }
+        const releaseService = getService('release', {
+            strapi
+        });
+        const releasesWithActions = await releaseService.findMany({
+            where: {
+                releasedAt: null,
+                actions: {
+                    contentType: contentTypeUid,
+                    entryDocumentId: {
+                        $in: documentIds
+                    },
+                    locale
+                }
+            },
+            populate: {
+                actions: true
+            }
+        });
+        const mappedEntriesInReleases = releasesWithActions.reduce((acc, release)=>{
+            release.actions.forEach((action)=>{
+                if (action.contentType !== contentTypeUid) {
+                    return;
+                }
+                if (locale && action.locale !== locale) {
+                    return;
+                }
+                if (!acc[action.entryDocumentId]) {
+                    acc[action.entryDocumentId] = [
+                        {
+                            id: release.id,
+                            name: release.name
+                        }
+                    ];
+                } else {
+                    acc[action.entryDocumentId].push({
+                        id: release.id,
+                        name: release.name
+                    });
+                }
+            });
+            return acc;
+        }, {});
+        ctx.body = {
+            data: mappedEntriesInReleases
+        };
+    },
+    async create (ctx) {
+        const user = ctx.state.user;
+        const releaseArgs = ctx.request.body;
+        await validateRelease(releaseArgs);
+        const releaseService = getService('release', {
+            strapi
+        });
+        const release = await releaseService.create(releaseArgs, {
+            user
+        });
+        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
+            ability: ctx.state.userAbility,
+            model: RELEASE_MODEL_UID
+        });
+        ctx.created({
+            data: await permissionsManager.sanitizeOutput(release)
+        });
+    },
+    async update (ctx) {
+        const user = ctx.state.user;
+        const releaseArgs = ctx.request.body;
+        const id = ctx.params.id;
+        await validateRelease(releaseArgs);
+        const releaseService = getService('release', {
+            strapi
+        });
+        const release = await releaseService.update(id, releaseArgs, {
+            user
+        });
+        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
+            ability: ctx.state.userAbility,
+            model: RELEASE_MODEL_UID
+        });
+        ctx.body = {
+            data: await permissionsManager.sanitizeOutput(release)
+        };
+    },
+    async delete (ctx) {
+        const id = ctx.params.id;
+        const releaseService = getService('release', {
+            strapi
+        });
+        const release = await releaseService.delete(id);
+        ctx.body = {
+            data: release
+        };
+    },
+    async publish (ctx) {
+        const id = ctx.params.id;
+        const releaseService = getService('release', {
+            strapi
+        });
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const release = await releaseService.publish(id);
+        const [countPublishActions, countUnpublishActions] = await Promise.all([
+            releaseActionService.countActions({
+                filters: {
+                    release: id,
+                    type: 'publish'
+                }
+            }),
+            releaseActionService.countActions({
+                filters: {
+                    release: id,
+                    type: 'unpublish'
+                }
+            })
+        ]);
+        ctx.body = {
+            data: release,
+            meta: {
+                totalEntries: countPublishActions + countUnpublishActions,
+                totalPublishedEntries: countPublishActions,
+                totalUnpublishedEntries: countUnpublishActions
+            }
+        };
+    }
 };
+
 const RELEASE_ACTION_SCHEMA = utils.yup.object().shape({
-  entry: utils.yup.object().shape({
-    id: utils.yup.strapiID().required(),
-    contentType: utils.yup.string().required()
-  }).required(),
-  type: utils.yup.string().oneOf(["publish", "unpublish"]).required()
+    contentType: utils.yup.string().required(),
+    entryDocumentId: utils.yup.strapiID(),
+    locale: utils.yup.string(),
+    type: utils.yup.string().oneOf([
+        'publish',
+        'unpublish'
+    ]).required()
 });
 const RELEASE_ACTION_UPDATE_SCHEMA = utils.yup.object().shape({
-  type: utils.yup.string().oneOf(["publish", "unpublish"]).required()
+    type: utils.yup.string().oneOf([
+        'publish',
+        'unpublish'
+    ]).required()
+});
+const FIND_MANY_ACTIONS_PARAMS = utils.yup.object().shape({
+    groupBy: utils.yup.string().oneOf([
+        'action',
+        'contentType',
+        'locale'
+    ])
 });
 const validateReleaseAction = utils.validateYupSchema(RELEASE_ACTION_SCHEMA);
 const validateReleaseActionUpdateSchema = utils.validateYupSchema(RELEASE_ACTION_UPDATE_SCHEMA);
+const validateFindManyActionsParams = utils.validateYupSchema(FIND_MANY_ACTIONS_PARAMS);
+
 const releaseActionController = {
-  async create(ctx) {
-    const releaseId = ctx.params.releaseId;
-    const releaseActionArgs = ctx.request.body;
-    await validateReleaseAction(releaseActionArgs);
-    const releaseService = getService("release", { strapi });
-    const releaseAction2 = await releaseService.createAction(releaseId, releaseActionArgs);
-    ctx.body = {
-      data: releaseAction2
-    };
-  },
-  async findMany(ctx) {
-    const releaseId = ctx.params.releaseId;
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: RELEASE_ACTION_MODEL_UID
-    });
-    const query = await permissionsManager.sanitizeQuery(ctx.query);
-    const releaseService = getService("release", { strapi });
-    const { results, pagination } = await releaseService.findActions(releaseId, {
-      sort: query.groupBy === "action" ? "type" : query.groupBy,
-      ...query
-    });
-    const contentTypeOutputSanitizers = results.reduce((acc, action) => {
-      if (acc[action.contentType]) {
-        return acc;
-      }
-      const contentTypePermissionsManager = strapi.admin.services.permission.createPermissionsManager({
-        ability: ctx.state.userAbility,
-        model: action.contentType
-      });
-      acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
-      return acc;
-    }, {});
-    const sanitizedResults = await utils.mapAsync(results, async (action) => ({
-      ...action,
-      entry: await contentTypeOutputSanitizers[action.contentType](action.entry)
-    }));
-    const groupedData = await releaseService.groupActions(sanitizedResults, query.groupBy);
-    const contentTypes2 = releaseService.getContentTypeModelsFromActions(results);
-    const components = await releaseService.getAllComponents();
-    ctx.body = {
-      data: groupedData,
-      meta: {
-        pagination,
-        contentTypes: contentTypes2,
-        components
-      }
-    };
-  },
-  async update(ctx) {
-    const actionId = ctx.params.actionId;
-    const releaseId = ctx.params.releaseId;
-    const releaseActionUpdateArgs = ctx.request.body;
-    await validateReleaseActionUpdateSchema(releaseActionUpdateArgs);
-    const releaseService = getService("release", { strapi });
-    const updatedAction = await releaseService.updateAction(
-      actionId,
-      releaseId,
-      releaseActionUpdateArgs
-    );
-    ctx.body = {
-      data: updatedAction
-    };
-  },
-  async delete(ctx) {
-    const actionId = ctx.params.actionId;
-    const releaseId = ctx.params.releaseId;
-    const releaseService = getService("release", { strapi });
-    const deletedReleaseAction = await releaseService.deleteAction(actionId, releaseId);
-    ctx.body = {
-      data: deletedReleaseAction
-    };
-  }
+    async create (ctx) {
+        const releaseId = ctx.params.releaseId;
+        const releaseActionArgs = ctx.request.body;
+        await validateReleaseAction(releaseActionArgs);
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const releaseAction = await releaseActionService.create(releaseId, releaseActionArgs);
+        ctx.created({
+            data: releaseAction
+        });
+    },
+    async createMany (ctx) {
+        const releaseId = ctx.params.releaseId;
+        const releaseActionsArgs = ctx.request.body;
+        await Promise.all(releaseActionsArgs.map((releaseActionArgs)=>validateReleaseAction(releaseActionArgs)));
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const releaseService = getService('release', {
+            strapi
+        });
+        const releaseActions = await strapi.db.transaction(async ()=>{
+            const releaseActions = await Promise.all(releaseActionsArgs.map(async (releaseActionArgs)=>{
+                try {
+                    const action = await releaseActionService.create(releaseId, releaseActionArgs, {
+                        disableUpdateReleaseStatus: true
+                    });
+                    return action;
+                } catch (error) {
+                    // If the entry is already in the release, we don't want to throw an error, so we catch and ignore it
+                    if (error instanceof AlreadyOnReleaseError) {
+                        return null;
+                    }
+                    throw error;
+                }
+            }));
+            return releaseActions;
+        });
+        const newReleaseActions = releaseActions.filter((action)=>action !== null);
+        if (newReleaseActions.length > 0) {
+            releaseService.updateReleaseStatus(releaseId);
+        }
+        ctx.created({
+            data: newReleaseActions,
+            meta: {
+                entriesAlreadyInRelease: releaseActions.length - newReleaseActions.length,
+                totalEntries: releaseActions.length
+            }
+        });
+    },
+    async findMany (ctx) {
+        const releaseId = ctx.params.releaseId;
+        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
+            ability: ctx.state.userAbility,
+            model: RELEASE_ACTION_MODEL_UID
+        });
+        await validateFindManyActionsParams(ctx.query);
+        if (ctx.query.groupBy) {
+            if (![
+                'action',
+                'contentType',
+                'locale'
+            ].includes(ctx.query.groupBy)) {
+                ctx.badRequest('Invalid groupBy parameter');
+            }
+        }
+        ctx.query.sort = ctx.query.groupBy === 'action' ? 'type' : ctx.query.groupBy;
+        delete ctx.query.groupBy;
+        const query = await permissionsManager.sanitizeQuery(ctx.query);
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const { results, pagination } = await releaseActionService.findPage(releaseId, {
+            ...query
+        });
+        /**
+     * Release actions can be related to entries of different content types.
+     * We need to sanitize the entry output according to that content type.
+     * So, we group the sanitized output function by content type.
+     */ const contentTypeOutputSanitizers = results.reduce((acc, action)=>{
+            if (acc[action.contentType]) {
+                return acc;
+            }
+            const contentTypePermissionsManager = strapi.service('admin::permission').createPermissionsManager({
+                ability: ctx.state.userAbility,
+                model: action.contentType
+            });
+            acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
+            return acc;
+        }, {});
+        /**
+     * sanitizeOutput doesn't work if you use it directly on the Release Action model, it doesn't sanitize the entries
+     * So, we need to sanitize manually each entry inside a Release Action
+     */ const sanitizedResults = await utils.async.map(results, async (action)=>({
+                ...action,
+                entry: action.entry ? await contentTypeOutputSanitizers[action.contentType](action.entry) : {}
+            }));
+        const groupedData = await releaseActionService.groupActions(sanitizedResults, query.sort);
+        const contentTypes = await releaseActionService.getContentTypeModelsFromActions(results);
+        const releaseService = getService('release', {
+            strapi
+        });
+        const components = await releaseService.getAllComponents();
+        ctx.body = {
+            data: groupedData,
+            meta: {
+                pagination,
+                contentTypes,
+                components
+            }
+        };
+    },
+    async update (ctx) {
+        const actionId = ctx.params.actionId;
+        const releaseId = ctx.params.releaseId;
+        const releaseActionUpdateArgs = ctx.request.body;
+        await validateReleaseActionUpdateSchema(releaseActionUpdateArgs);
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const updatedAction = await releaseActionService.update(actionId, releaseId, releaseActionUpdateArgs);
+        ctx.body = {
+            data: updatedAction
+        };
+    },
+    async delete (ctx) {
+        const actionId = ctx.params.actionId;
+        const releaseId = ctx.params.releaseId;
+        const releaseActionService = getService('release-action', {
+            strapi
+        });
+        const deletedReleaseAction = await releaseActionService.delete(actionId, releaseId);
+        ctx.body = {
+            data: deletedReleaseAction
+        };
+    }
 };
-const controllers = { release: releaseController, "release-action": releaseActionController };
-const release = {
-  type: "admin",
-  routes: [
-    {
-      method: "POST",
-      path: "/",
-      handler: "release.create",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+
+const SETTINGS_SCHEMA = yup__namespace.object().shape({
+    defaultTimezone: yup__namespace.string().nullable().default(null)
+}).required().noUnknown();
+const validateSettings = utils.validateYupSchema(SETTINGS_SCHEMA);
+
+const settingsController = {
+    async find (ctx) {
+        // Get settings
+        const settingsService = getService('settings', {
+            strapi
+        });
+        const settings = await settingsService.find();
+        // Response
+        ctx.body = {
+            data: settings
+        };
+    },
+    async update (ctx) {
+        // Data validation
+        const settingsBody = ctx.request.body;
+        const settings = await validateSettings(settingsBody);
+        // Update
+        const settingsService = getService('settings', {
+            strapi
+        });
+        const updatedSettings = await settingsService.update({
+            settings
+        });
+        // Response
+        ctx.body = {
+            data: updatedSettings
+        };
+    }
+};
+
+const controllers = {
+    release: releaseController,
+    'release-action': releaseActionController,
+    settings: settingsController
+};
+
+var release = {
+    type: 'admin',
+    routes: [
+        {
+            method: 'GET',
+            path: '/mapEntriesToReleases',
+            handler: 'release.mapEntriesToReleases',
             config: {
-              actions: ["plugin::content-releases.create"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.read'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "GET",
-      path: "/",
-      handler: "release.findMany",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'GET',
+            path: '/getByDocumentAttached',
+            handler: 'release.findByDocumentAttached',
             config: {
-              actions: ["plugin::content-releases.read"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.read'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "GET",
-      path: "/:id",
-      handler: "release.findOne",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'POST',
+            path: '/',
+            handler: 'release.create',
             config: {
-              actions: ["plugin::content-releases.read"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.create'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "PUT",
-      path: "/:id",
-      handler: "release.update",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'GET',
+            path: '/',
+            handler: 'release.findPage',
             config: {
-              actions: ["plugin::content-releases.update"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.read'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "DELETE",
-      path: "/:id",
-      handler: "release.delete",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'GET',
+            path: '/:id',
+            handler: 'release.findOne',
             config: {
-              actions: ["plugin::content-releases.delete"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.read'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "POST",
-      path: "/:id/publish",
-      handler: "release.publish",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'PUT',
+            path: '/:id',
+            handler: 'release.update',
             config: {
-              actions: ["plugin::content-releases.publish"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.update'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    }
-  ]
+        },
+        {
+            method: 'DELETE',
+            path: '/:id',
+            handler: 'release.delete',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.delete'
+                            ]
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            method: 'POST',
+            path: '/:id/publish',
+            handler: 'release.publish',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.publish'
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    ]
 };
-const releaseAction = {
-  type: "admin",
-  routes: [
-    {
-      method: "POST",
-      path: "/:releaseId/actions",
-      handler: "release-action.create",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+
+var releaseAction = {
+    type: 'admin',
+    routes: [
+        {
+            method: 'POST',
+            path: '/:releaseId/actions',
+            handler: 'release-action.create',
             config: {
-              actions: ["plugin::content-releases.create-action"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.create-action'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "GET",
-      path: "/:releaseId/actions",
-      handler: "release-action.findMany",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'POST',
+            path: '/:releaseId/actions/bulk',
+            handler: 'release-action.createMany',
             config: {
-              actions: ["plugin::content-releases.read"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.create-action'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "PUT",
-      path: "/:releaseId/actions/:actionId",
-      handler: "release-action.update",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'GET',
+            path: '/:releaseId/actions',
+            handler: 'release-action.findMany',
             config: {
-              actions: ["plugin::content-releases.update"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.read'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    },
-    {
-      method: "DELETE",
-      path: "/:releaseId/actions/:actionId",
-      handler: "release-action.delete",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
+        },
+        {
+            method: 'PUT',
+            path: '/:releaseId/actions/:actionId',
+            handler: 'release-action.update',
             config: {
-              actions: ["plugin::content-releases.delete-action"]
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.update'
+                            ]
+                        }
+                    }
+                ]
             }
-          }
-        ]
-      }
-    }
-  ]
+        },
+        {
+            method: 'DELETE',
+            path: '/:releaseId/actions/:actionId',
+            handler: 'release-action.delete',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.delete-action'
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    ]
 };
+
+var settings = {
+    type: 'admin',
+    routes: [
+        {
+            method: 'GET',
+            path: '/settings',
+            handler: 'settings.find',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.settings.read'
+                            ]
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            method: 'PUT',
+            path: '/settings',
+            handler: 'settings.update',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin',
+                    {
+                        name: 'admin::hasPermissions',
+                        config: {
+                            actions: [
+                                'plugin::content-releases.settings.update'
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    ]
+};
+
 const routes = {
-  release,
-  "release-action": releaseAction
+    settings,
+    release,
+    'release-action': releaseAction
 };
-const { features } = require("@strapi/strapi/dist/utils/ee");
-const getPlugin = () => {
-  if (features.isEnabled("cms-content-releases")) {
+
+const getPlugin = ()=>{
+    if (strapi.ee.features.isEnabled('cms-content-releases')) {
+        return {
+            register,
+            bootstrap,
+            destroy,
+            contentTypes,
+            services,
+            controllers,
+            routes
+        };
+    }
     return {
-      register,
-      bootstrap,
-      destroy,
-      contentTypes,
-      services,
-      controllers,
-      routes
+        // Always return register, it handles its own feature check
+        register,
+        // Always return contentTypes to avoid losing data when the feature is disabled
+        contentTypes
     };
-  }
-  return {
-    // Always return register, it handles its own feature check
-    register,
-    // Always return contentTypes to avoid losing data when the feature is disabled
-    contentTypes
-  };
 };
-const index = getPlugin();
+var index = getPlugin();
+
 module.exports = index;
 //# sourceMappingURL=index.js.map