@strapi/content-releases 0.0.0-next.b6d552f6e63dec5627cb8611ab2adcb8244359be → 0.0.0-next.bb6ff32f5168f3e380d3d9acba90a9d53bfcfb89

package/dist/server/index.mjs

@@ -1,8 +1,7 @@
-import { contentTypes as contentTypes$1, mapAsync, setCreatorFields, errors, validateYupSchema, yup as yup$1 } from "@strapi/utils";
+import { contentTypes as contentTypes$1, async, setCreatorFields, errors, yup as yup$1, validateYupSchema } from "@strapi/utils";
 import isEqual from "lodash/isEqual";
 import { difference, keys } from "lodash";
 import _ from "lodash/fp";
-import EE from "@strapi/strapi/dist/utils/ee";
 import { scheduleJob } from "node-schedule";
 import * as yup from "yup";
 const RELEASE_MODEL_UID = "plugin::content-releases.release";
@@ -49,21 +48,38 @@ 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 ALLOWED_WEBHOOK_EVENTS = {
   RELEASES_PUBLISH: "releases.publish"
 };
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+const getService = (name, { strapi: strapi2 }) => {
   return strapi2.plugin("content-releases").service(name);
 };
-const getPopulatedEntry = async (contentTypeUid, entryId, { strapi: strapi2 } = { strapi: global.strapi }) => {
+const getDraftEntryValidStatus = async ({ contentType, documentId, locale }, { strapi: strapi2 }) => {
   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 populate = await populateBuilderService(contentType).populateDeep(Infinity).build();
+  const entry = await getEntry({ contentType, documentId, locale, populate }, { strapi: strapi2 });
+  return isEntryValid(contentType, entry, { strapi: strapi2 });
 };
-const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } = { strapi: global.strapi }) => {
+const isEntryValid = async (contentTypeUid, entry, { strapi: strapi2 }) => {
   try {
     await strapi2.entityValidator.validateEntityCreation(
       strapi2.getModel(contentTypeUid),
@@ -72,11 +88,54 @@ const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } =
       // @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
@@ -98,7 +157,7 @@ async function deleteActionsOnDisableDraftAndPublish({
 async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes: contentTypes2 }) {
   const deletedContentTypes = difference(keys(oldContentTypes), keys(contentTypes2)) ?? [];
   if (deletedContentTypes.length) {
-    await mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
+    await async.map(deletedContentTypes, async (deletedContentTypeUID) => {
       return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: deletedContentTypeUID }).execute();
     });
   }
@@ -117,25 +176,27 @@ async function migrateIsValidAndStatusReleases() {
       }
     }
   });
-  mapAsync(releasesWithoutStatus, async (release2) => {
+  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 populatedEntry = await getPopulatedEntry(action.contentType, action.entry.id, {
-          strapi
+        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
+          }
         });
-        if (populatedEntry) {
-          const isEntryValid = getEntryValidStatus(action.contentType, populatedEntry, { strapi });
-          await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-            where: {
-              id: action.id
-            },
-            data: {
-              isEntryValid
-            }
-          });
-        }
       }
     }
     return getService("release", { strapi }).updateReleaseStatus(release2.id);
@@ -148,7 +209,7 @@ async function migrateIsValidAndStatusReleases() {
       }
     }
   });
-  mapAsync(publishedReleases, async (release2) => {
+  async.map(publishedReleases, async (release2) => {
     return strapi.db.query(RELEASE_MODEL_UID).update({
       where: {
         id: release2.id
@@ -165,7 +226,7 @@ async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: co
       (uid) => oldContentTypes[uid]?.options?.draftAndPublish
     );
     const releasesAffected = /* @__PURE__ */ new Set();
-    mapAsync(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
+    async.map(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
       const oldContentType = oldContentTypes[contentTypeUID];
       const contentType = contentTypes2[contentTypeUID];
       if (!isEqual(oldContentType?.attributes, contentType?.attributes)) {
@@ -178,187 +239,272 @@ async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: co
             release: true
           }
         });
-        await mapAsync(actions, async (action) => {
-          if (action.entry) {
-            const populatedEntry = await getPopulatedEntry(contentTypeUID, action.entry.id, {
-              strapi
+        await 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
+              }
             });
-            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
-                }
-              });
-            }
           }
         });
       }
     }).then(() => {
-      mapAsync(releasesAffected, async (releaseId) => {
+      async.map(releasesAffected, async (releaseId) => {
         return getService("release", { strapi }).updateReleaseStatus(releaseId);
       });
     });
   }
 }
-const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
+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");
+      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 (features$2.isEnabled("cms-content-releases")) {
-    await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
-    strapi2.hook("strapi::content-types.beforeSync").register(deleteActionsOnDisableDraftAndPublish);
-    strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
+  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 (!contentTypes$1.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 (!contentTypes$1.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")) {
+  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({
       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 });
-        }
-      },
-      /**
-       * 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;
-        }
-      },
       /**
-       * 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) {
         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)
-                }
-              }
+          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 }
             });
-            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
           });
         }
-      },
-      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
-                }
-              }
-            });
-            for (const release2 of releases) {
-              getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
-            }
-          }
-        } 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);
-      });
-    }
+    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 }) => {
-  if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-    const scheduledJobs = getService("scheduling", {
-      strapi: strapi2
-    }).getAll();
-    for (const [, job] of scheduledJobs) {
-      job.cancel();
-    }
+  const scheduledJobs = getService("scheduling", {
+    strapi: strapi2
+  }).getAll();
+  for (const [, job] of scheduledJobs) {
+    job.cancel();
   }
 };
 const schema$1 = {
@@ -433,15 +579,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"
     },
@@ -463,18 +607,6 @@ 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 _.getOr("No locale", "locale.name");
-    default:
-      return "contentType.displayName";
-  }
-};
 const createReleaseService = ({ strapi: strapi2 }) => {
   const dispatchWebhook = (event, { isPublished, release: release2, error }) => {
     strapi2.eventHub.emit(event, {
@@ -483,6 +615,33 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       release: release2
     });
   };
+  const getFormattedActions = async (releaseId) => {
+    const actions = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+      where: {
+        release: {
+          id: releaseId
+        }
+      }
+    });
+    if (actions.length === 0) {
+      throw new 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 setCreatorFields({ user })(releaseData);
@@ -496,13 +655,13 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
         validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
       ]);
-      const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).create({
         data: {
           ...releaseWithCreatorFields,
           status: "empty"
         }
       });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && releaseWithCreatorFields.scheduledAt) {
+      if (releaseWithCreatorFields.scheduledAt) {
         const schedulingService = getService("scheduling", { strapi: strapi2 });
         await schedulingService.set(release2.id, release2.scheduledAt);
       }
@@ -510,94 +669,28 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return release2;
     },
     async findOne(id, query = {}) {
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, 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) {
-      return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
-        ...query,
+      const dbQuery = strapi2.get("query-params").transform(RELEASE_MODEL_UID, query ?? {});
+      return strapi2.db.query(RELEASE_MODEL_UID).findPage({
+        ...dbQuery,
         populate: {
           actions: {
-            // @ts-expect-error Ignore missing properties
             count: true
           }
         }
       });
     },
-    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
-          }
-        },
-        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;
+    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 }) {
@@ -612,157 +705,27 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
         validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
       ]);
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id } });
       if (!release2) {
         throw new errors.NotFoundError(`No release found for id ${id}`);
       }
       if (release2.releasedAt) {
         throw new 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
+      const updatedRelease = await strapi2.db.query(RELEASE_MODEL_UID).update({
+        where: { id },
         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);
-        }
+      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 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 errors.NotFoundError(`No release found for id ${releaseId}`);
-      }
-      if (release2.releasedAt) {
-        throw new 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
-        },
-        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 errors.NotFoundError(`No release found for id ${releaseId}`);
-      }
-      return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
-        ...query,
-        populate: {
-          entry: {
-            populate: "*"
-          }
-        },
-        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 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 _.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;
-        },
-        {}
-      );
-      return contentTypeModelsMap;
-    },
     async getAllComponents() {
       const contentManagerComponentsService = strapi2.plugin("content-manager").service("components");
       const components = await contentManagerComponentsService.findAllComponents();
@@ -776,10 +739,11 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return componentsMap;
     },
     async delete(releaseId) {
-      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
+        where: { id: releaseId },
         populate: {
           actions: {
-            fields: ["id"]
+            select: ["id"]
           }
         }
       });
@@ -797,9 +761,13 @@ const createReleaseService = ({ strapi: strapi2 }) => {
             }
           }
         });
-        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
+        await strapi2.db.query(RELEASE_MODEL_UID).delete({
+          where: {
+            id: releaseId
+          }
+        });
       });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && release2.scheduledAt) {
+      if (release2.scheduledAt) {
         const schedulingService = getService("scheduling", { strapi: strapi2 });
         await schedulingService.cancel(release2.id);
       }
@@ -807,148 +775,294 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return release2;
     },
     async publish(releaseId) {
-      try {
-        const releaseWithPopulatedActionEntries = await strapi2.entityService.findOne(
-          RELEASE_MODEL_UID,
-          releaseId,
-          {
-            populate: {
-              actions: {
-                populate: {
-                  entry: {
-                    fields: ["id"]
-                  }
-                }
-              }
-            }
-          }
-        );
-        if (!releaseWithPopulatedActionEntries) {
+      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 errors.NotFoundError(`No release found for id ${releaseId}`);
         }
-        if (releaseWithPopulatedActionEntries.releasedAt) {
+        if (lockedRelease.releasedAt) {
           throw new errors.ValidationError("Release already published");
         }
-        if (releaseWithPopulatedActionEntries.actions.length === 0) {
-          throw new errors.ValidationError("No entries to publish");
+        if (lockedRelease.status === "failed") {
+          throw new errors.ValidationError("Release failed to publish");
         }
-        const collectionTypeActions = {};
-        const singleTypeActions = [];
-        for (const action of releaseWithPopulatedActionEntries.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 entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
-        const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
-        await strapi2.db.transaction(async () => {
-          for (const { uid, action, id } of singleTypeActions) {
-            const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
-            const entry = await strapi2.entityService.findOne(uid, id, { populate });
-            try {
-              if (action === "publish") {
-                await entityManagerService.publish(entry, uid);
-              } else {
-                await entityManagerService.unpublish(entry, uid);
-              }
-            } catch (error) {
-              if (error instanceof errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft")) {
-              } else {
-                throw error;
-              }
-            }
-          }
-          for (const contentTypeUid of Object.keys(collectionTypeActions)) {
-            const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
-            const { entriestoPublishIds, entriesToUnpublishIds } = collectionTypeActions[contentTypeUid];
-            const entriesToPublish = await strapi2.entityService.findMany(
-              contentTypeUid,
-              {
-                filters: {
-                  id: {
-                    $in: entriestoPublishIds
-                  }
-                },
-                populate
-              }
-            );
-            const entriesToUnpublish = await strapi2.entityService.findMany(
-              contentTypeUid,
-              {
-                filters: {
-                  id: {
-                    $in: entriesToUnpublishIds
-                  }
-                },
-                populate
-              }
-            );
-            if (entriesToPublish.length > 0) {
-              await entityManagerService.publishMany(entriesToPublish, contentTypeUid);
-            }
-            if (entriesToUnpublish.length > 0) {
-              await entityManagerService.unpublishMany(entriesToUnpublish, contentTypeUid);
-            }
-          }
-        });
-        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()
-          },
-          populate: {
-            actions: {
-              // @ts-expect-error is not expecting count but it is working
-              count: true
+        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()
             }
-          }
-        });
-        if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+          });
           dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
             isPublished: true,
-            release: release2
+            release: release22
           });
-        }
-        strapi2.telemetry.send("didPublishContentRelease");
-        return release2;
-      } catch (error) {
-        if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+          strapi2.telemetry.send("didPublishContentRelease");
+          return { release: release22, error: null };
+        } catch (error2) {
           dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
             isPublished: false,
-            error
+            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 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"
+            }
           });
         }
-        strapi2.db.query(RELEASE_MODEL_UID).update({
-          where: { id: releaseId },
+        return strapi2.db.query(RELEASE_MODEL_UID).update({
+          where: {
+            id: releaseId
+          },
           data: {
-            status: "failed"
+            status: "ready"
           }
         });
-        throw error;
       }
+      return strapi2.db.query(RELEASE_MODEL_UID).update({
+        where: {
+          id: releaseId
+        },
+        data: {
+          status: "empty"
+        }
+      });
+    }
+  };
+};
+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";
+  }
+};
+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 getContentTypesDataForActions = async (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;
+  };
+  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 errors.NotFoundError(`No entry found for contentType ${action.contentType}`);
+        }
+        action.entryDocumentId = document.documentId;
+      }
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: releaseId } });
+      if (!release2) {
+        throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      if (release2.releasedAt) {
+        throw new 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 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: {
+          release: releaseId
+        }
+      });
+      const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+      const actionsWithEntry = await 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 _.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 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 updateAction(actionId, releaseId, update) {
-      const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
+    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: {
@@ -957,17 +1071,42 @@ const createReleaseService = ({ strapi: strapi2 }) => {
               $null: true
             }
           }
-        },
-        data: update
+        }
       });
-      if (!updatedAction) {
+      if (!action) {
         throw new 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: strapi2
+        }
+      ) : 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
+        }
+      });
+      getService("release", { strapi: strapi2 }).updateReleaseStatus(releaseId);
       return updatedAction;
     },
-    async deleteAction(actionId, releaseId) {
+    async delete(actionId, releaseId) {
       const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
         where: {
           id: actionId,
@@ -984,87 +1123,104 @@ const createReleaseService = ({ strapi: strapi2 }) => {
           `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
         );
       }
-      this.updateReleaseStatus(releaseId);
+      getService("release", { strapi: strapi2 }).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"
+    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
             }
-          });
-        }
-        return strapi2.db.query(RELEASE_MODEL_UID).update({
+          }
+        },
+        populate: { release: true }
+      });
+      const releasesUpdated = [];
+      await 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: releaseId
+            id: action.id
           },
           data: {
-            status: "ready"
+            isEntryValid: isValid
           }
         });
-      }
-      return strapi2.db.query(RELEASE_MODEL_UID).update({
-        where: {
-          id: releaseId
-        },
-        data: {
-          status: "empty"
+        if (!releasesUpdated.includes(action.release.id)) {
+          releasesUpdated.push(action.release.id);
         }
+        return {
+          id: action.id,
+          isEntryValid: isValid
+        };
       });
+      if (releasesUpdated.length > 0) {
+        await async.map(releasesUpdated, async (releaseId) => {
+          await getService("release", { strapi: strapi2 }).updateReleaseStatus(releaseId);
+        });
+      }
     }
   };
 };
+class AlreadyOnReleaseError extends 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 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 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 errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
     }
-    if (!contentType.options?.draftAndPublish) {
+    if (!contentTypes$1.hasDraftAndPublish(contentType)) {
       throw new errors.ValidationError(
         `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`
       );
     }
+    if (contentType.kind === "collectionType" && !entryDocumentId) {
+      throw new errors.ValidationError("Document id is required for collection type");
+    }
   },
   async validatePendingReleasesLimit() {
-    const maximumPendingReleases = (
-      // @ts-expect-error - options is not typed into features
-      EE.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: {
@@ -1077,8 +1233,8 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
     }
   },
   async validateUniqueNameForPendingRelease(name, id) {
-    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
-      filters: {
+    const pendingReleases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+      where: {
         releasedAt: {
           $null: true
         },
@@ -1107,7 +1263,7 @@ const createSchedulingService = ({ strapi: strapi2 }) => {
       }
       const job = scheduleJob(scheduleDate, async () => {
         try {
-          await getService("release").publish(releaseId);
+          await getService("release", { strapi: strapi2 }).publish(releaseId);
         } catch (error) {
         }
         this.cancel(releaseId);
@@ -1149,85 +1305,172 @@ const createSchedulingService = ({ strapi: strapi2 }) => {
     }
   };
 };
+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 || {}
+      };
+    }
+  };
+};
 const services = {
   release: createReleaseService,
+  "release-action": createReleaseActionService,
   "release-validation": createReleaseValidationService,
-  ...strapi.features.future.isEnabled("contentReleasesScheduling") ? { scheduling: createSchedulingService } : {}
+  scheduling: createSchedulingService,
+  settings: createSettingsService
 };
-const RELEASE_SCHEMA = yup.object().shape({
-  name: yup.string().trim().required(),
-  scheduledAt: yup.string().nullable(),
-  isScheduled: yup.boolean().optional(),
-  time: yup.string().when("isScheduled", {
-    is: true,
-    then: yup.string().trim().required(),
-    otherwise: yup.string().nullable()
-  }),
-  timezone: yup.string().when("isScheduled", {
-    is: true,
-    then: yup.string().required().nullable(),
-    otherwise: yup.string().nullable()
-  }),
-  date: yup.string().when("isScheduled", {
-    is: true,
-    then: yup.string().required().nullable(),
-    otherwise: yup.string().nullable()
+const RELEASE_SCHEMA = yup$1.object().shape({
+  name: yup$1.string().trim().required(),
+  scheduledAt: yup$1.string().nullable(),
+  timezone: yup$1.string().when("scheduledAt", {
+    is: (value) => value !== null && value !== void 0,
+    then: yup$1.string().required(),
+    otherwise: yup$1.string().nullable()
   })
 }).required().noUnknown();
+const FIND_BY_DOCUMENT_ATTACHED_PARAMS_SCHEMA = yup$1.object().shape({
+  contentType: yup$1.string().required(),
+  entryDocumentId: yup$1.string().nullable(),
+  hasEntryAttached: yup$1.string().nullable(),
+  locale: yup$1.string().nullable()
+}).required().noUnknown();
 const validateRelease = validateYupSchema(RELEASE_SCHEMA);
+const validatefindByDocumentAttachedParams = 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 = 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,
+    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 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: {
-            meta: {
-              count: actions.count
+            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 pendingReleasesCount = await strapi.query(RELEASE_MODEL_UID).count({
+      const releases = await releaseService.findMany({
         where: {
+          $or: [
+            {
+              id: {
+                $notIn: relatedReleases.map((release2) => release2.id)
+              }
+            },
+            {
+              actions: null
+            }
+          ],
           releasedAt: null
         }
       });
-      ctx.body = { data, meta: { pagination, pendingReleasesCount } };
+      ctx.body = { data: releases };
     }
   },
+  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((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 errors.NotFoundError(`Release not found for id: ${id}`);
     }
-    const count = await releaseService.countActions({
+    const count = await releaseActionService.countActions({
       filters: {
         release: id
       }
     });
     const sanitizedRelease = {
       ...release2,
-      createdBy: release2.createdBy ? strapi.admin.services.user.sanitizeUser(release2.createdBy) : null
+      createdBy: release2.createdBy ? strapi.service("admin::user").sanitizeUser(release2.createdBy) : null
     };
     const data = {
       ...sanitizedRelease,
@@ -1239,19 +1482,63 @@ const releaseController = {
     };
     ctx.body = { data };
   },
+  async mapEntriesToReleases(ctx) {
+    const { contentTypeUid, documentIds, locale } = ctx.query;
+    if (!contentTypeUid || !documentIds) {
+      throw new 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;
@@ -1260,7 +1547,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
     });
@@ -1277,18 +1564,18 @@ 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([
-      releaseService.countActions({
+      releaseActionService.countActions({
         filters: {
           release: id,
           type: "publish"
         }
       }),
-      releaseService.countActions({
+      releaseActionService.countActions({
         filters: {
           release: id,
           type: "unpublish"
@@ -1306,57 +1593,106 @@ const releaseController = {
   }
 };
 const RELEASE_ACTION_SCHEMA = yup$1.object().shape({
-  entry: yup$1.object().shape({
-    id: yup$1.strapiID().required(),
-    contentType: yup$1.string().required()
-  }).required(),
+  contentType: yup$1.string().required(),
+  entryDocumentId: yup$1.strapiID(),
+  locale: yup$1.string(),
   type: yup$1.string().oneOf(["publish", "unpublish"]).required()
 });
 const RELEASE_ACTION_UPDATE_SCHEMA = yup$1.object().shape({
   type: yup$1.string().oneOf(["publish", "unpublish"]).required()
 });
+const FIND_MANY_ACTIONS_PARAMS = yup$1.object().shape({
+  groupBy: yup$1.string().oneOf(["action", "contentType", "locale"])
+});
 const validateReleaseAction = validateYupSchema(RELEASE_ACTION_SCHEMA);
 const validateReleaseActionUpdateSchema = validateYupSchema(RELEASE_ACTION_UPDATE_SCHEMA);
+const validateFindManyActionsParams = 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 contentTypeOutputSanitizers = results.reduce((acc, action) => {
       if (acc[action.contentType]) {
         return acc;
       }
-      const contentTypePermissionsManager = strapi.admin.services.permission.createPermissionsManager({
+      const contentTypePermissionsManager = strapi.service("admin::permission").createPermissionsManager({
         ability: ctx.state.userAbility,
         model: action.contentType
       });
       acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
       return acc;
     }, {});
-    const sanitizedResults = await mapAsync(results, async (action) => ({
+    const sanitizedResults = await async.map(results, async (action) => ({
       ...action,
-      entry: await contentTypeOutputSanitizers[action.contentType](action.entry)
+      entry: action.entry ? await contentTypeOutputSanitizers[action.contentType](action.entry) : {}
     }));
-    const groupedData = await releaseService.groupActions(sanitizedResults, query.groupBy);
-    const contentTypes2 = releaseService.getContentTypeModelsFromActions(results);
+    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,
@@ -1372,8 +1708,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
@@ -1385,17 +1721,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.object().shape({
+  defaultTimezone: yup.string().nullable().default(null)
+}).required().noUnknown();
+const validateSettings = 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: "/",
@@ -1415,7 +1805,7 @@ const release = {
     {
       method: "GET",
       path: "/",
-      handler: "release.findMany",
+      handler: "release.findPage",
       config: {
         policies: [
           "admin::isAuthenticatedAdmin",
@@ -1513,6 +1903,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",
@@ -1563,13 +1969,50 @@ 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")) {
+  if (strapi.ee.features.isEnabled("cms-content-releases")) {
     return {
       register,
       bootstrap,
@@ -1581,6 +2024,9 @@ const getPlugin = () => {
     };
   }
   return {
+    // Always return register, it handles its own feature check
+    register,
+    // Always return contentTypes to avoid losing data when the feature is disabled
     contentTypes
   };
 };