@strapi/content-releases 0.0.0-next.2b10ca9b97a5854909ba0a8d1d5b00f73cae58fa → 0.0.0-next.2dcec09530c87d7b3b453630c2d76a967476338d

package/dist/server/index.js

@@ -1,12 +1,13 @@
 "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;
+  if (e && e.__esModule) return e;
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
     for (const k in e) {
@@ -22,8 +23,8 @@ function _interopNamespace(e) {
   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";
@@ -69,82 +70,463 @@ const ACTIONS = [
     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 getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+const ALLOWED_WEBHOOK_EVENTS = {
+  RELEASES_PUBLISH: "releases.publish"
+};
+const getService = (name, { strapi: strapi2 }) => {
   return strapi2.plugin("content-releases").service(name);
 };
-const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
-const register = async ({ strapi: strapi2 }) => {
-  if (features$2.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
-    await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
-    const releaseActionService = getService("release-action", { strapi: strapi2 });
-    const eventManager = getService("event-manager", { strapi: strapi2 });
-    const destroyContentTypeUpdateListener = strapi2.eventHub.on(
-      "content-type.update",
-      async ({ contentType }) => {
-        if (contentType.schema.options.draftAndPublish === false) {
-          await releaseActionService.deleteManyForContentType(contentType.uid);
+const getDraftEntryValidStatus = async ({ contentType, documentId, locale }, { strapi: strapi2 }) => {
+  const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+  const populate = await populateBuilderService(contentType).populateDeep(Infinity).build();
+  const entry = await getEntry({ contentType, documentId, locale, populate }, { strapi: strapi2 });
+  return isEntryValid(contentType, entry, { strapi: strapi2 });
+};
+const isEntryValid = async (contentTypeUid, entry, { strapi: strapi2 }) => {
+  try {
+    await strapi2.entityValidator.validateEntityCreation(
+      strapi2.getModel(contentTypeUid),
+      entry,
+      void 0,
+      // @ts-expect-error - FIXME: entity here is unnecessary
+      entry
+    );
+    const workflowsService = strapi2.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;
+  }
+};
+const getEntry = async ({
+  contentType,
+  documentId,
+  locale,
+  populate,
+  status = "draft"
+}, { strapi: strapi2 }) => {
+  if (documentId) {
+    const entry = await strapi2.documents(contentType).findOne({ documentId, locale, populate, status });
+    if (status === "published" && !entry) {
+      return strapi2.documents(contentType).findOne({ documentId, locale, populate, status: "draft" });
+    }
+    return entry;
+  }
+  return strapi2.documents(contentType).findFirst({ locale, populate, status });
+};
+const getEntryStatus = async (contentType, entry) => {
+  if (entry.publishedAt) {
+    return "published";
+  }
+  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: contentTypes2
+}) {
+  if (!oldContentTypes) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    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();
+    }
+  }
+}
+async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes: contentTypes2 }) {
+  const deletedContentTypes = lodash.difference(lodash.keys(oldContentTypes), lodash.keys(contentTypes2)) ?? [];
+  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: {
+        populate: {
+          entry: true
         }
       }
-    );
-    eventManager.addDestroyListenerCallback(destroyContentTypeUpdateListener);
-    const destroyContentTypeDeleteListener = strapi2.eventHub.on(
-      "content-type.delete",
-      async ({ contentType }) => {
-        await releaseActionService.deleteManyForContentType(contentType.uid);
+    }
+  });
+  utils.async.map(releasesWithoutStatus, async (release2) => {
+    const actions = release2.actions;
+    const notValidatedActions = actions.filter((action) => action.isEntryValid === null);
+    for (const action of notValidatedActions) {
+      if (action.entry) {
+        const isEntryValid2 = 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: isEntryValid2
+          }
+        });
+      }
+    }
+    return getService("release", { strapi }).updateReleaseStatus(release2.id);
+  });
+  const publishedReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+    where: {
+      status: null,
+      releasedAt: {
+        $notNull: true
       }
+    }
+  });
+  utils.async.map(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
     );
-    eventManager.addDestroyListenerCallback(destroyContentTypeDeleteListener);
+    const releasesAffected = /* @__PURE__ */ new Set();
+    utils.async.map(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.async.map(actions, async (action) => {
+          if (action.entry && action.release && action.type === "publish") {
+            const isEntryValid2 = 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: isEntryValid2
+              }
+            });
+          }
+        });
+      }
+    }).then(() => {
+      utils.async.map(releasesAffected, async (releaseId) => {
+        return getService("release", { strapi }).updateReleaseStatus(releaseId);
+      });
+    });
+  }
+}
+async function disableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (!oldContentTypes) {
+    return;
+  }
+  const i18nPlugin = strapi.plugin("i18n");
+  if (!i18nPlugin) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    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();
+    }
+  }
+}
+async function enableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (!oldContentTypes) {
+    return;
+  }
+  const i18nPlugin = strapi.plugin("i18n");
+  if (!i18nPlugin) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    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 addEntryDocumentToReleaseActions = {
+  name: "content-releases::5.0.0-add-entry-document-id-to-release-actions",
+  async up(trx, db) {
+    const hasTable = await trx.schema.hasTable("strapi_release_actions");
+    if (!hasTable) {
+      return;
+    }
+    const hasPolymorphicColumn = await trx.schema.hasColumn("strapi_release_actions", "target_id");
+    if (hasPolymorphicColumn) {
+      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);
+        }
+      });
+    }
+  },
+  async down() {
+    throw new Error("not implemented");
+  }
+};
+const register = async ({ strapi: strapi2 }) => {
+  if (strapi2.ee.features.isEnabled("cms-content-releases")) {
+    await strapi2.service("admin::permission").actionProvider.registerMany(ACTIONS);
+    strapi2.db.migrations.providers.internal.register(addEntryDocumentToReleaseActions);
+    strapi2.hook("strapi::content-types.beforeSync").register(disableContentTypeLocalized).register(deleteActionsOnDisableDraftAndPublish);
+    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 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
+      }
+    }
+  });
+  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 release2 of releases) {
+    getService("release", { strapi }).updateReleaseStatus(release2.id);
+  }
+};
+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 release2 of releases) {
+    getService("release", { strapi }).updateReleaseStatus(release2.id);
+  }
+};
+const deleteActionsOnDelete = async (ctx, next) => {
+  if (ctx.action !== "delete") {
+    return next();
+  }
+  if (!utils.contentTypes.hasDraftAndPublish(ctx.contentType)) {
+    return next();
+  }
+  const contentType = ctx.contentType.uid;
+  const { documentId, locale } = ctx.params;
+  const result = await next();
+  if (!result) {
+    return result;
+  }
+  try {
+    deleteActionsAndUpdateReleaseStatus({
+      contentType,
+      entryDocumentId: documentId,
+      ...locale !== "*" && { locale }
+    });
+  } catch (error) {
+    strapi.log.error("Error while deleting release actions after delete", {
+      error
+    });
+  }
+  return result;
+};
+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 {
+    updateActionsStatusAndUpdateReleaseStatus(contentType, result);
+  } catch (error) {
+    strapi.log.error("Error while updating release actions after update", {
+      error
+    });
+  }
+  return result;
+};
+const deleteReleasesActionsAndUpdateReleaseStatus = 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 release2 of releases) {
+    getService("release", { strapi }).updateReleaseStatus(release2.id);
   }
 };
-const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
 const bootstrap = async ({ strapi: strapi2 }) => {
-  if (features$1.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
+  if (strapi2.ee.features.isEnabled("cms-content-releases")) {
+    const contentTypesWithDraftAndPublish = Object.keys(strapi2.contentTypes).filter(
+      (uid) => strapi2.contentTypes[uid]?.options?.draftAndPublish
+    );
     strapi2.db.lifecycles.subscribe({
-      afterDelete(event) {
-        const { model, result } = event;
-        if (model.kind === "collectionType" && model.options.draftAndPublish) {
-          const { id } = result;
-          strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-            where: {
-              target_type: model.uid,
-              target_id: id
-            }
-          });
-        }
-      },
-      /**
-       * 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;
-        }
-      },
+      models: contentTypesWithDraftAndPublish,
       /**
-       * We delete the release actions related to deleted entries
-       * We make this only after deleteMany is succesfully executed to avoid errors
+       * deleteMany is still used outside documents service, for example when deleting a locale
        */
       async afterDeleteMany(event) {
-        const { model, state } = event;
-        const entriesToDelete = state.entriesToDelete;
-        if (entriesToDelete) {
-          await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-            where: {
-              target_type: model.uid,
-              target_id: {
-                $in: entriesToDelete.map((entry) => entry.id)
-              }
-            }
+        try {
+          const model = strapi2.getModel(event.model.uid);
+          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) {
+          strapi2.log.error("Error while deleting release actions after entry deleteMany", {
+            error
           });
         }
       }
     });
+    strapi2.documents.use(deleteActionsOnDelete);
+    strapi2.documents.use(updateActionsOnUpdate);
+    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.get("webhookStore").addAllowedEvent(key, value);
+    });
+  }
+};
+const destroy = async ({ strapi: strapi2 }) => {
+  const scheduledJobs = getService("scheduling", {
+    strapi: strapi2
+  }).getAll();
+  for (const [, job] of scheduledJobs) {
+    job.cancel();
   }
 };
 const schema$1 = {
@@ -173,6 +555,17 @@ const schema$1 = {
     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",
@@ -208,15 +601,13 @@ const schema = {
       enum: ["publish", "unpublish"],
       required: true
     },
-    entry: {
-      type: "relation",
-      relation: "morphToOne",
-      configurable: false
-    },
     contentType: {
       type: "string",
       required: true
     },
+    entryDocumentId: {
+      type: "string"
+    },
     locale: {
       type: "string"
     },
@@ -225,6 +616,9 @@ const schema = {
       relation: "manyToOne",
       target: RELEASE_MODEL_UID,
       inversedBy: "actions"
+    },
+    isEntryValid: {
+      type: "boolean"
     }
   }
 };
@@ -235,215 +629,307 @@ const contentTypes = {
   release: release$1,
   "release-action": releaseAction$1
 };
-const createReleaseActionService = ({ strapi: strapi2 }) => ({
-  async deleteManyForContentType(contentTypeUid) {
-    return strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+const createReleaseService = ({ strapi: strapi2 }) => {
+  const dispatchWebhook = (event, { isPublished, release: release2, error }) => {
+    strapi2.eventHub.emit(event, {
+      isPublished,
+      error,
+      release: release2
+    });
+  };
+  const getFormattedActions = async (releaseId) => {
+    const actions = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findMany({
       where: {
-        target_type: contentTypeUid
+        release: {
+          id: releaseId
+        }
       }
     });
-  }
-});
-const getGroupName = (queryValue) => {
-  switch (queryValue) {
-    case "contentType":
-      return "entry.contentType.displayName";
-    case "action":
-      return "type";
-    case "locale":
-      return ___default.default.getOr("No locale", "entry.locale.name");
-    default:
-      return "entry.contentType.displayName";
-  }
-};
-const createReleaseService = ({ strapi: strapi2 }) => ({
-  async create(releaseData, { user }) {
-    const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
-    await getService("release-validation", { strapi: strapi2 }).validatePendingReleasesLimit();
-    return strapi2.entityService.create(RELEASE_MODEL_UID, {
-      data: releaseWithCreatorFields
-    });
-  },
-  async findOne(id, query = {}) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
-      ...query
-    });
-    return release2;
-  },
-  findPage(query) {
-    return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
-      ...query,
-      populate: {
-        actions: {
-          // @ts-expect-error Ignore missing properties
-          count: true
+    if (actions.length === 0) {
+      throw new utils.errors.ValidationError("No entries to publish");
+    }
+    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
+      });
+    }
+    return formattedActions;
+  };
+  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.db.query(RELEASE_MODEL_UID).create({
+        data: {
+          ...releaseWithCreatorFields,
+          status: "empty"
         }
+      });
+      if (releaseWithCreatorFields.scheduledAt) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        await schedulingService.set(release2.id, release2.scheduledAt);
       }
-    });
-  },
-  async findManyForContentTypeEntry(contentTypeUid, entryId, {
-    hasEntryAttached
-  } = {
-    hasEntryAttached: false
-  }) {
-    const whereActions = hasEntryAttached ? {
-      // Find all Releases where the content type entry is present
-      actions: {
-        target_type: contentTypeUid,
-        target_id: entryId
+      strapi2.telemetry.send("didCreateContentRelease");
+      return release2;
+    },
+    async findOne(id, query = {}) {
+      const dbQuery = strapi2.get("query-params").transform(RELEASE_MODEL_UID, query);
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
+        ...dbQuery,
+        where: { id }
+      });
+      return release2;
+    },
+    findPage(query) {
+      const dbQuery = strapi2.get("query-params").transform(RELEASE_MODEL_UID, query ?? {});
+      return strapi2.db.query(RELEASE_MODEL_UID).findPage({
+        ...dbQuery,
+        populate: {
+          actions: {
+            count: true
+          }
+        }
+      });
+    },
+    findMany(query) {
+      const dbQuery = strapi2.get("query-params").transform(RELEASE_MODEL_UID, query ?? {});
+      return strapi2.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: strapi2 }
+      );
+      await Promise.all([
+        validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
+        validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
+      ]);
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id } });
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${id}`);
       }
-    } : {
-      // Find all Releases where the content type entry is not present
-      $or: [
-        {
-          $not: {
-            actions: {
-              target_type: contentTypeUid,
-              target_id: entryId
+      if (release2.releasedAt) {
+        throw new utils.errors.ValidationError("Release already published");
+      }
+      const updatedRelease = await strapi2.db.query(RELEASE_MODEL_UID).update({
+        where: { id },
+        data: releaseWithCreatorFields
+      });
+      const schedulingService = getService("scheduling", { strapi: strapi2 });
+      if (releaseData.scheduledAt) {
+        await schedulingService.set(id, releaseData.scheduledAt);
+      } else if (release2.scheduledAt) {
+        schedulingService.cancel(id);
+      }
+      this.updateReleaseStatus(id);
+      strapi2.telemetry.send("didUpdateContentRelease");
+      return updatedRelease;
+    },
+    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;
+        },
+        {}
+      );
+      return componentsMap;
+    },
+    async delete(releaseId) {
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
+        where: { id: releaseId },
+        populate: {
+          actions: {
+            select: ["id"]
+          }
+        }
+      });
+      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)
             }
           }
-        },
-        {
-          actions: null
+        });
+        await strapi2.db.query(RELEASE_MODEL_UID).delete({
+          where: {
+            id: releaseId
+          }
+        });
+      });
+      if (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}`);
         }
-      ]
-    };
-    const populateAttachedAction = hasEntryAttached ? {
-      // Filter the action to get only the content type entry
-      actions: {
-        where: {
-          target_type: contentTypeUid,
-          target_id: entryId
+        if (lockedRelease.releasedAt) {
+          throw new utils.errors.ValidationError("Release already published");
         }
-      }
-    } : {};
-    const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-      where: {
-        ...whereActions,
-        releasedAt: {
-          $null: true
+        if (lockedRelease.status === "failed") {
+          throw new utils.errors.ValidationError("Release failed to publish");
         }
-      },
-      populate: {
-        ...populateAttachedAction
-      }
-    });
-    return releases.map((release2) => {
-      if (release2.actions?.length) {
-        const [actionForEntry] = release2.actions;
-        delete release2.actions;
-        return {
-          ...release2,
-          action: actionForEntry
-        };
+        try {
+          strapi2.log.info(`[Content Releases] Starting to publish release ${lockedRelease.name}`);
+          const formattedActions = await getFormattedActions(releaseId);
+          await strapi2.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) => strapi2.documents(contentType).publish(params)),
+                  ...unpublish.map((params) => strapi2.documents(contentType).unpublish(params))
+                ]);
+              })
+            )
+          );
+          const release22 = await strapi2.db.query(RELEASE_MODEL_UID).update({
+            where: {
+              id: releaseId
+            },
+            data: {
+              status: "done",
+              releasedAt: /* @__PURE__ */ new Date()
+            }
+          });
+          dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+            isPublished: true,
+            release: release22
+          });
+          strapi2.telemetry.send("didPublishContentRelease");
+          return { release: release22, error: null };
+        } catch (error2) {
+          dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+            isPublished: false,
+            error: error2
+          });
+          await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).update({
+            status: "failed"
+          }).transacting(trx).execute();
+          return {
+            release: null,
+            error: error2
+          };
+        }
+      });
+      if (error instanceof Error) {
+        throw error;
       }
       return release2;
-    });
-  },
-  async update(id, releaseData, { user }) {
-    const releaseWithCreatorFields = await utils.setCreatorFields({ user, isEdition: true })(releaseData);
-    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
-    });
-    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;
-    return strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
-      data: {
-        type,
-        contentType: entry.contentType,
-        locale: entry.locale,
-        entry: {
-          id: entry.id,
-          __type: entry.contentType,
-          __pivot: { field: "entry" }
+    },
+    async updateReleaseStatus(releaseId) {
+      const releaseActionService = getService("release-action", { strapi: strapi2 });
+      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 strapi2.db.query(RELEASE_MODEL_UID).update({
+            where: {
+              id: releaseId
+            },
+            data: {
+              status: "blocked"
+            }
+          });
+        }
+        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
         },
-        release: releaseId
-      },
-      populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
-    });
-  },
-  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}`);
+        data: {
+          status: "empty"
+        }
+      });
     }
-    return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
-      ...query,
-      populate: {
-        entry: true
-      },
-      filters: {
-        release: releaseId
-      }
-    });
-  },
-  async countActions(query) {
-    return strapi2.entityService.count(RELEASE_ACTION_MODEL_UID, query);
-  },
-  async groupActions(actions, groupBy) {
-    const contentTypeUids = actions.reduce((acc, action) => {
-      if (!acc.includes(action.contentType)) {
-        acc.push(action.contentType);
-      }
-      return acc;
-    }, []);
-    const allReleaseContentTypesDictionary = await this.getContentTypesDataForActions(
-      contentTypeUids
-    );
-    const allLocales = await strapi2.plugin("i18n").service("locales").find();
-    const allLocalesDictionary = allLocales.reduce((acc, locale) => {
+  };
+};
+const getGroupName = (queryValue) => {
+  switch (queryValue) {
+    case "contentType":
+      return "contentType.displayName";
+    case "type":
+      return "type";
+    case "locale":
+      return ___default.default.getOr("No locale", "locale.name");
+    default:
+      return "contentType.displayName";
+  }
+};
+const createReleaseActionService = ({ strapi: strapi2 }) => {
+  const getLocalesDataForActions = async () => {
+    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;
     }, {});
-    const formattedData = actions.map((action) => {
-      const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
-      return {
-        ...action,
-        entry: {
-          id: action.entry.id,
-          contentType: {
-            displayName,
-            mainFieldValue: action.entry[mainField]
-          },
-          locale: action.locale ? allLocalesDictionary[action.locale] : null,
-          status: action.entry.publishedAt ? "published" : "draft"
-        }
-      };
-    });
-    const groupName = getGroupName(groupBy);
-    return ___default.default.groupBy(groupName)(formattedData);
-  },
-  async getContentTypesDataForActions(contentTypesUids) {
+  };
+  const getContentTypesDataForActions = async (contentTypesUids) => {
     const contentManagerContentTypeService = strapi2.plugin("content-manager").service("content-types");
     const contentTypesData = {};
     for (const contentTypeUid of contentTypesUids) {
@@ -456,167 +942,307 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       };
     }
     return contentTypesData;
-  },
-  async delete(releaseId) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-      populate: {
-        actions: {
-          fields: ["id"]
+  };
+  return {
+    async create(releaseId, action, { disableUpdateReleaseStatus = false } = {}) {
+      const { validateEntryData, validateUniqueEntry } = getService("release-validation", {
+        strapi: strapi2
+      });
+      await Promise.all([
+        validateEntryData(action.contentType, action.entryDocumentId),
+        validateUniqueEntry(releaseId, action)
+      ]);
+      const model = strapi2.contentType(action.contentType);
+      if (model.kind === "singleType") {
+        const document = await strapi2.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;
       }
-    });
-    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({
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: 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 actionStatus = action.type === "publish" ? await getDraftEntryValidStatus(
+        {
+          contentType: action.contentType,
+          documentId: action.entryDocumentId,
+          locale: action.locale
+        },
+        {
+          strapi: strapi2
+        }
+      ) : true;
+      const releaseAction2 = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).create({
+        data: {
+          ...action,
+          release: release2.id,
+          isEntryValid: actionStatus
+        },
+        populate: { release: { select: ["id"] } }
+      });
+      if (!disableUpdateReleaseStatus) {
+        getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
+      }
+      return releaseAction2;
+    },
+    async findPage(releaseId, query) {
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
+        where: { id: releaseId },
+        select: ["id"]
+      });
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      const dbQuery = strapi2.get("query-params").transform(RELEASE_ACTION_MODEL_UID, query ?? {});
+      const { results: actions, pagination } = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findPage({
+        ...dbQuery,
         where: {
-          id: {
-            $in: release2.actions.map((action) => action.id)
-          }
+          release: releaseId
         }
       });
-      await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
-    });
-    return release2;
-  },
-  async publish(releaseId) {
-    const releaseWithPopulatedActionEntries = await strapi2.entityService.findOne(
-      RELEASE_MODEL_UID,
-      releaseId,
-      {
-        populate: {
-          actions: {
-            populate: {
-              entry: true
+      const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+      const actionsWithEntry = await utils.async.map(actions, async (action) => {
+        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: strapi2 }
+        );
+        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 ___default.default.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 = strapi2.plugin("review-workflows").service("workflows");
+      const contentTypeModelsMap = await utils.async.reduce(contentTypeUids)(
+        async (accPromise, contentTypeUid) => {
+          const acc = await accPromise;
+          const contentTypeModel = strapi2.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 = strapi2.get("query-params").transform(RELEASE_ACTION_MODEL_UID, query ?? {});
+      return strapi2.db.query(RELEASE_ACTION_MODEL_UID).count(dbQuery);
+    },
+    async update(actionId, releaseId, update) {
+      const action = await strapi2.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`
+        );
       }
-    );
-    if (!releaseWithPopulatedActionEntries) {
-      throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-    }
-    if (releaseWithPopulatedActionEntries.releasedAt) {
-      throw new utils.errors.ValidationError("Release already published");
-    }
-    if (releaseWithPopulatedActionEntries.actions.length === 0) {
-      throw new utils.errors.ValidationError("No entries to publish");
-    }
-    const actions = {};
-    for (const action of releaseWithPopulatedActionEntries.actions) {
-      const contentTypeUid = action.contentType;
-      if (!actions[contentTypeUid]) {
-        actions[contentTypeUid] = {
-          publish: [],
-          unpublish: []
-        };
-      }
-      if (action.type === "publish") {
-        actions[contentTypeUid].publish.push(action.entry);
-      } else {
-        actions[contentTypeUid].unpublish.push(action.entry);
-      }
-    }
-    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
-    await strapi2.db.transaction(async () => {
-      for (const contentTypeUid of Object.keys(actions)) {
-        const { publish, unpublish } = actions[contentTypeUid];
-        if (publish.length > 0) {
-          await entityManagerService.publishMany(publish, contentTypeUid);
+      const actionStatus = update.type === "publish" ? await getDraftEntryValidStatus(
+        {
+          contentType: action.contentType,
+          documentId: action.entryDocumentId,
+          locale: action.locale
+        },
+        {
+          strapi: strapi2
         }
-        if (unpublish.length > 0) {
-          await entityManagerService.unpublishMany(unpublish, contentTypeUid);
+      ) : true;
+      const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
+        where: {
+          id: actionId,
+          release: {
+            id: releaseId,
+            releasedAt: {
+              $null: true
+            }
+          }
+        },
+        data: {
+          ...update,
+          isEntryValid: actionStatus
         }
-      }
-    });
-    const release2 = await strapi2.entityService.update(RELEASE_MODEL_UID, releaseId, {
-      data: {
-        /*
-         * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">> looks like it's wrong
-         */
-        // @ts-expect-error see above
-        releasedAt: /* @__PURE__ */ new Date()
-      }
-    });
-    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
+      });
+      getService("release", { strapi: strapi2 }).updateReleaseStatus(releaseId);
+      return updatedAction;
+    },
+    async delete(actionId, releaseId) {
+      const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
+        where: {
+          id: actionId,
+          release: {
+            id: releaseId,
+            releasedAt: {
+              $null: true
+            }
           }
         }
-      },
-      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
+      });
+      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: strapi2 }).updateReleaseStatus(releaseId);
+      return deletedAction;
+    },
+    async validateActionsByContentTypes(contentTypeUids) {
+      const actions = await strapi2.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: strapi2 }
+        );
+        await strapi2.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: strapi2 }).updateReleaseStatus(releaseId);
+        });
       }
-    });
-    if (!deletedAction) {
-      throw new utils.errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
-      );
     }
-    return deletedAction;
+  };
+};
+class AlreadyOnReleaseError extends utils.errors.ApplicationError {
+  constructor(message) {
+    super(message);
+    this.name = "AlreadyOnReleaseError";
   }
-});
+}
 const createReleaseValidationService = ({ strapi: strapi2 }) => ({
   async validateUniqueEntry(releaseId, releaseActionArgs) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-      populate: { actions: { populate: { entry: { fields: ["id"] } } } }
+    const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
+      where: {
+        id: releaseId
+      },
+      populate: {
+        actions: true
+      }
     });
     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
+      (action) => action.entryDocumentId === releaseActionArgs.entryDocumentId && action.contentType === releaseActionArgs.contentType && (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true)
     );
     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}`
+      throw new AlreadyOnReleaseError(
+        `Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ""} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`
       );
     }
   },
-  validateEntryContentType(contentTypeUid) {
+  validateEntryData(contentTypeUid, entryDocumentId) {
     const contentType = strapi2.contentType(contentTypeUid);
     if (!contentType) {
       throw new utils.errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
     }
-    if (!contentType.options?.draftAndPublish) {
+    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() {
-    const maximumPendingReleases = (
-      // @ts-expect-error - options is not typed into features
-      EE__default.default.features.get("cms-content-releases")?.options?.maximumReleases || 3
-    );
+    const featureCfg = strapi2.ee.features.get("cms-content-releases");
+    const maximumPendingReleases = typeof featureCfg === "object" && featureCfg?.options?.maximumReleases || 3;
     const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
       filters: {
         releasedAt: {
@@ -627,23 +1253,98 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
     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.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) <= /* @__PURE__ */ new Date()) {
+      throw new utils.errors.ValidationError("Scheduled at must be later than now");
+    }
   }
 });
-const createEventManagerService = () => {
-  const state = {
-    destroyListenerCallbacks: []
-  };
+const createSchedulingService = ({ strapi: strapi2 }) => {
+  const scheduledJobs = /* @__PURE__ */ new Map();
   return {
-    addDestroyListenerCallback(destroyListenerCallback) {
-      state.destroyListenerCallbacks.push(destroyListenerCallback);
+    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", { strapi: strapi2 }).publish(releaseId);
+        } catch (error) {
+        }
+        this.cancel(releaseId);
+      });
+      if (scheduledJobs.has(releaseId)) {
+        this.cancel(releaseId);
+      }
+      scheduledJobs.set(releaseId, job);
+      return scheduledJobs;
     },
-    destroyAllListeners() {
-      if (!state.destroyListenerCallbacks.length) {
-        return;
+    cancel(releaseId) {
+      if (scheduledJobs.has(releaseId)) {
+        scheduledJobs.get(releaseId).cancel();
+        scheduledJobs.delete(releaseId);
       }
-      state.destroyListenerCallbacks.forEach((destroyListenerCallback) => {
-        destroyListenerCallback();
+      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
+        }
       });
+      for (const release2 of releases) {
+        this.set(release2.id, release2.scheduledAt);
+      }
+      return scheduledJobs;
+    }
+  };
+};
+const DEFAULT_SETTINGS = {
+  defaultTimezone: null
+};
+const createSettingsService = ({ strapi: strapi2 }) => {
+  const getStore = async () => strapi2.store({ type: "core", name: "content-releases" });
+  return {
+    async update({ settings: settings2 }) {
+      const store = await getStore();
+      store.set({ key: "settings", value: settings2 });
+      return settings2;
+    },
+    async find() {
+      const store = await getStore();
+      const settings2 = await store.get({ key: "settings" });
+      return {
+        ...DEFAULT_SETTINGS,
+        ...settings2 || {}
+      };
     }
   };
 };
@@ -651,64 +1352,148 @@ const services = {
   release: createReleaseService,
   "release-action": createReleaseActionService,
   "release-validation": createReleaseValidationService,
-  "event-manager": createEventManagerService
+  scheduling: createSchedulingService,
+  settings: createSettingsService
 };
-const RELEASE_SCHEMA = yup__namespace.object().shape({
-  name: yup__namespace.string().trim().required()
+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 !== void 0,
+    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({
+  /**
+   * 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 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 = await releaseService.findManyForContentTypeEntry(contentTypeUid, entryId, {
-        hasEntryAttached
+    const query = await permissionsManager.sanitizeQuery(ctx.query);
+    await validatefindByDocumentAttachedParams(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}`);
+      }
+      query.entryDocumentId = document.documentId;
+    }
+    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 };
+      ctx.body = { data: releases };
     } 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,
+      const relatedReleases = await releaseService.findMany({
+        where: {
+          releasedAt: null,
           actions: {
-            meta: {
-              count: actions.count
-            }
+            contentType,
+            entryDocumentId: entryDocumentId ?? null,
+            locale: locale ?? null
           }
-        };
+        }
       });
-      ctx.body = { data, meta: { pagination } };
+      const releases = await releaseService.findMany({
+        where: {
+          $or: [
+            {
+              id: {
+                $notIn: relatedReleases.map((release2) => release2.id)
+              }
+            },
+            {
+              actions: null
+            }
+          ],
+          releasedAt: null
+        }
+      });
+      ctx.body = { data: releases };
     }
   },
-  async findOne(ctx) {
-    const id = ctx.params.id;
-    const releaseService = getService("release", { strapi });
-    const release2 = await releaseService.findOne(id, { populate: ["createdBy"] });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+  async findPage(ctx) {
+    const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_MODEL_UID
     });
-    const sanitizedRelease = await permissionsManager.sanitizeOutput(release2);
-    const count = await releaseService.countActions({
-      filters: {
-        release: id
+    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((release2) => {
+      const { actions, ...releaseData } = release2;
+      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 release2 = await releaseService.findOne(id, { populate: ["createdBy"] });
     if (!release2) {
       throw new utils.errors.NotFoundError(`Release not found for id: ${id}`);
     }
+    const count = await releaseActionService.countActions({
+      filters: {
+        release: id
+      }
+    });
+    const sanitizedRelease = {
+      ...release2,
+      createdBy: release2.createdBy ? strapi.service("admin::user").sanitizeUser(release2.createdBy) : null
+    };
     const data = {
       ...sanitizedRelease,
       actions: {
@@ -719,19 +1504,63 @@ const releaseController = {
     };
     ctx.body = { data };
   },
+  async mapEntriesToReleases(ctx) {
+    const { contentTypeUid, documentIds, locale } = ctx.query;
+    if (!contentTypeUid || !documentIds) {
+      throw new utils.errors.ValidationError("Missing required query parameters");
+    }
+    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, release2) => {
+        release2.actions.forEach((action) => {
+          if (action.contentType !== contentTypeUid) {
+            return;
+          }
+          if (locale && action.locale !== locale) {
+            return;
+          }
+          if (!acc[action.entryDocumentId]) {
+            acc[action.entryDocumentId] = [{ id: release2.id, name: release2.name }];
+          } else {
+            acc[action.entryDocumentId].push({ id: release2.id, name: release2.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 release2 = await releaseService.create(releaseArgs, { user });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+    const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_MODEL_UID
     });
-    ctx.body = {
+    ctx.created({
       data: await permissionsManager.sanitizeOutput(release2)
-    };
+    });
   },
   async update(ctx) {
     const user = ctx.state.user;
@@ -740,7 +1569,7 @@ const releaseController = {
     await validateRelease(releaseArgs);
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.update(id, releaseArgs, { user });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+    const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_MODEL_UID
     });
@@ -757,55 +1586,142 @@ const releaseController = {
     };
   },
   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 releaseActionService = getService("release-action", { strapi });
+    const release2 = 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: release2
+      data: release2,
+      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(),
+  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()
 });
+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 = {
+    const releaseActionService = getService("release-action", { strapi });
+    const releaseAction2 = await releaseActionService.create(releaseId, releaseActionArgs);
+    ctx.created({
       data: releaseAction2
-    };
+    });
+  },
+  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 releaseActions2 = await Promise.all(
+        releaseActionsArgs.map(async (releaseActionArgs) => {
+          try {
+            const action = await releaseActionService.create(releaseId, releaseActionArgs, {
+              disableUpdateReleaseStatus: true
+            });
+            return action;
+          } catch (error) {
+            if (error instanceof AlreadyOnReleaseError) {
+              return null;
+            }
+            throw error;
+          }
+        })
+      );
+      return releaseActions2;
+    });
+    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.admin.services.permission.createPermissionsManager({
+    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 releaseService = getService("release", { strapi });
-    const { results, pagination } = await releaseService.findActions(releaseId, {
-      sort: query.groupBy === "action" ? "type" : query.groupBy,
+    const releaseActionService = getService("release-action", { strapi });
+    const { results, pagination } = await releaseActionService.findPage(releaseId, {
       ...query
     });
-    const groupedData = await releaseService.groupActions(results, query.groupBy);
+    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;
+    }, {});
+    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 contentTypes2 = await releaseActionService.getContentTypeModelsFromActions(results);
+    const releaseService = getService("release", { strapi });
+    const components = await releaseService.getAllComponents();
     ctx.body = {
       data: groupedData,
       meta: {
-        pagination
+        pagination,
+        contentTypes: contentTypes2,
+        components
       }
     };
   },
@@ -814,8 +1730,8 @@ const releaseActionController = {
     const releaseId = ctx.params.releaseId;
     const releaseActionUpdateArgs = ctx.request.body;
     await validateReleaseActionUpdateSchema(releaseActionUpdateArgs);
-    const releaseService = getService("release", { strapi });
-    const updatedAction = await releaseService.updateAction(
+    const releaseActionService = getService("release-action", { strapi });
+    const updatedAction = await releaseActionService.update(
       actionId,
       releaseId,
       releaseActionUpdateArgs
@@ -827,17 +1743,71 @@ const releaseActionController = {
   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);
+    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 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) {
+    const settingsService = getService("settings", { strapi });
+    const settings2 = await settingsService.find();
+    ctx.body = { data: settings2 };
+  },
+  async update(ctx) {
+    const settingsBody = ctx.request.body;
+    const settings2 = await validateSettings(settingsBody);
+    const settingsService = getService("settings", { strapi });
+    const updatedSettings = await settingsService.update({ settings: settings2 });
+    ctx.body = { data: updatedSettings };
+  }
+};
+const controllers = {
+  release: releaseController,
+  "release-action": releaseActionController,
+  settings: settingsController
+};
 const release = {
   type: "admin",
   routes: [
+    {
+      method: "GET",
+      path: "/mapEntriesToReleases",
+      handler: "release.mapEntriesToReleases",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: ["plugin::content-releases.read"]
+            }
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/getByDocumentAttached",
+      handler: "release.findByDocumentAttached",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: ["plugin::content-releases.read"]
+            }
+          }
+        ]
+      }
+    },
     {
       method: "POST",
       path: "/",
@@ -857,7 +1827,7 @@ const release = {
     {
       method: "GET",
       path: "/",
-      handler: "release.findMany",
+      handler: "release.findPage",
       config: {
         policies: [
           "admin::isAuthenticatedAdmin",
@@ -955,6 +1925,22 @@ const releaseAction = {
         ]
       }
     },
+    {
+      method: "POST",
+      path: "/:releaseId/actions/bulk",
+      handler: "release-action.createMany",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: ["plugin::content-releases.create-action"]
+            }
+          }
+        ]
+      }
+    },
     {
       method: "GET",
       path: "/:releaseId/actions",
@@ -1005,28 +1991,64 @@ const releaseAction = {
     }
   ]
 };
+const 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 = {
+  settings,
   release,
   "release-action": releaseAction
 };
-const { features } = require("@strapi/strapi/dist/utils/ee");
 const getPlugin = () => {
-  if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
+  if (strapi.ee.features.isEnabled("cms-content-releases")) {
     return {
       register,
       bootstrap,
+      destroy,
       contentTypes,
       services,
       controllers,
-      routes,
-      destroy() {
-        if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
-          getService("event-manager").destroyAllListeners();
-        }
-      }
+      routes
     };
   }
   return {
+    // Always return register, it handles its own feature check
+    register,
+    // Always return contentTypes to avoid losing data when the feature is disabled
     contentTypes
   };
 };