@strapi/content-releases 0.0.0-experimental.e02b4637b3906c6d31048d00600d09a23a0edc3d → 0.0.0-experimental.e033e9b9c89837331a60b1b6a2c21a779fffc801

package/dist/server/index.js

@@ -3,6 +3,7 @@ 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 };
@@ -26,6 +27,7 @@ function _interopNamespace(e) {
 }
 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";
@@ -71,38 +73,21 @@ 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 }) => {
+const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
   return strapi2.plugin("content-releases").service(name);
 };
-const getDraftEntryValidStatus = async ({ contentType, documentId, locale }, { strapi: strapi2 }) => {
+const getPopulatedEntry = async (contentTypeUid, entryId, { strapi: strapi2 } = { strapi: global.strapi }) => {
   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 populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
+  const entry = await strapi2.entityService.findOne(contentTypeUid, entryId, { populate });
+  return entry;
 };
-const isEntryValid = async (contentTypeUid, entry, { strapi: strapi2 }) => {
+const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } = { strapi: global.strapi }) => {
   try {
     await strapi2.entityValidator.validateEntityCreation(
       strapi2.getModel(contentTypeUid),
@@ -116,38 +101,6 @@ const isEntryValid = async (contentTypeUid, entry, { strapi: strapi2 }) => {
     return false;
   }
 };
-const getEntry = async ({
-  contentType,
-  documentId,
-  locale,
-  populate,
-  status = "draft"
-}, { strapi: strapi2 }) => {
-  if (documentId) {
-    return strapi2.documents(contentType).findOne({ documentId, locale, populate, status });
-  }
-  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
@@ -169,7 +122,7 @@ async function deleteActionsOnDisableDraftAndPublish({
 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) => {
+    await utils.mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
       return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: deletedContentTypeUID }).execute();
     });
   }
@@ -188,27 +141,25 @@ async function migrateIsValidAndStatusReleases() {
       }
     }
   });
-  utils.async.map(releasesWithoutStatus, async (release2) => {
+  utils.mapAsync(releasesWithoutStatus, async (release2) => {
     const actions = release2.actions;
     const notValidatedActions = actions.filter((action) => action.isEntryValid === null);
     for (const action of notValidatedActions) {
       if (action.entry) {
-        const 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
-          }
+        const populatedEntry = await getPopulatedEntry(action.contentType, action.entry.id, {
+          strapi
         });
+        if (populatedEntry) {
+          const isEntryValid = getEntryValidStatus(action.contentType, populatedEntry, { strapi });
+          await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+            where: {
+              id: action.id
+            },
+            data: {
+              isEntryValid
+            }
+          });
+        }
       }
     }
     return getService("release", { strapi }).updateReleaseStatus(release2.id);
@@ -221,7 +172,7 @@ async function migrateIsValidAndStatusReleases() {
       }
     }
   });
-  utils.async.map(publishedReleases, async (release2) => {
+  utils.mapAsync(publishedReleases, async (release2) => {
     return strapi.db.query(RELEASE_MODEL_UID).update({
       where: {
         id: release2.id
@@ -238,7 +189,7 @@ async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: co
       (uid) => oldContentTypes[uid]?.options?.draftAndPublish
     );
     const releasesAffected = /* @__PURE__ */ new Set();
-    utils.async.map(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
+    utils.mapAsync(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
       const oldContentType = oldContentTypes[contentTypeUID];
       const contentType = contentTypes2[contentTypeUID];
       if (!isEqual__default.default(oldContentType?.attributes, contentType?.attributes)) {
@@ -251,30 +202,30 @@ async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: co
             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
-              }
+        await utils.mapAsync(actions, async (action) => {
+          if (action.entry && action.release) {
+            const populatedEntry = await getPopulatedEntry(contentTypeUID, action.entry.id, {
+              strapi
             });
+            if (populatedEntry) {
+              const isEntryValid = await getEntryValidStatus(contentTypeUID, populatedEntry, {
+                strapi
+              });
+              releasesAffected.add(action.release.id);
+              await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+                where: {
+                  id: action.id
+                },
+                data: {
+                  isEntryValid
+                }
+              });
+            }
           }
         });
       }
     }).then(() => {
-      utils.async.map(releasesAffected, async (releaseId) => {
+      utils.mapAsync(releasesAffected, async (releaseId) => {
         return getService("release", { strapi }).updateReleaseStatus(releaseId);
       });
     });
@@ -326,39 +277,11 @@ async function enableContentTypeLocalized({ oldContentTypes, contentTypes: conte
     }
   }
 }
-const addEntryDocumentToReleaseActions = {
-  name: "content-releases::5.0.0-add-entry-document-id-to-release-actions",
-  async up(trx, db) {
-    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 { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
 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);
+  if (features$2.isEnabled("cms-content-releases")) {
+    await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
+    strapi2.hook("strapi::content-types.beforeSync").register(deleteActionsOnDisableDraftAndPublish).register(disableContentTypeLocalized);
     strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType).register(enableContentTypeLocalized).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
   }
   if (strapi2.plugin("graphql")) {
@@ -367,134 +290,129 @@ const register = async ({ strapi: strapi2 }) => {
     graphqlExtensionService.shadowCRUD(RELEASE_ACTION_MODEL_UID).disable();
   }
 };
-const updateActionsStatusAndUpdateReleaseStatus = async (contentType, entry) => {
-  const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-    where: {
-      actions: {
-        contentType,
-        entryDocumentId: entry.documentId,
-        locale: entry.locale
-      }
-    }
-  });
-  const entryStatus = await isEntryValid(contentType, entry, { strapi });
-  await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-    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 (strapi2.ee.features.isEnabled("cms-content-releases")) {
+  if (features$1.isEnabled("cms-content-releases")) {
     const contentTypesWithDraftAndPublish = Object.keys(strapi2.contentTypes).filter(
       (uid) => strapi2.contentTypes[uid]?.options?.draftAndPublish
     );
     strapi2.db.lifecycles.subscribe({
       models: contentTypesWithDraftAndPublish,
+      async afterDelete(event) {
+        try {
+          const { model, result } = event;
+          if (model.kind === "collectionType" && model.options?.draftAndPublish) {
+            const { id } = result;
+            const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+              where: {
+                actions: {
+                  target_type: model.uid,
+                  target_id: id
+                }
+              }
+            });
+            await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+              where: {
+                target_type: model.uid,
+                target_id: id
+              }
+            });
+            for (const release2 of releases) {
+              getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
+            }
+          }
+        } catch (error) {
+          strapi2.log.error("Error while deleting release actions after entry delete", { error });
+        }
+      },
+      /**
+       * 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;
+        }
+      },
       /**
-       * deleteMany is still used outside documents service, for example when deleting a locale
+       * We delete the release actions related to deleted entries
+       * We make this only after deleteMany is succesfully executed to avoid errors
        */
       async afterDeleteMany(event) {
         try {
-          const model = 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 }
+          const { model, state } = event;
+          const entriesToDelete = state.entriesToDelete;
+          if (entriesToDelete) {
+            const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+              where: {
+                actions: {
+                  target_type: model.uid,
+                  target_id: {
+                    $in: entriesToDelete.map(
+                      (entry) => entry.id
+                    )
+                  }
+                }
+              }
+            });
+            await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+              where: {
+                target_type: model.uid,
+                target_id: {
+                  $in: entriesToDelete.map((entry) => entry.id)
+                }
+              }
             });
+            for (const release2 of releases) {
+              getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
+            }
           }
         } catch (error) {
           strapi2.log.error("Error while deleting release actions after entry deleteMany", {
             error
           });
         }
+      },
+      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 });
+        }
       }
     });
-    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."
@@ -502,7 +420,7 @@ const bootstrap = async ({ strapi: strapi2 }) => {
       throw err;
     });
     Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
-      strapi2.get("webhookStore").addAllowedEvent(key, value);
+      strapi2.webhookStore.addAllowedEvent(key, value);
     });
   }
 };
@@ -586,13 +504,15 @@ 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"
     },
@@ -614,6 +534,18 @@ const contentTypes = {
   release: release$1,
   "release-action": releaseAction$1
 };
+const getGroupName = (queryValue) => {
+  switch (queryValue) {
+    case "contentType":
+      return "contentType.displayName";
+    case "action":
+      return "type";
+    case "locale":
+      return ___default.default.getOr("No locale", "locale.name");
+    default:
+      return "contentType.displayName";
+  }
+};
 const createReleaseService = ({ strapi: strapi2 }) => {
   const dispatchWebhook = (event, { isPublished, release: release2, error }) => {
     strapi2.eventHub.emit(event, {
@@ -622,32 +554,93 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       release: release2
     });
   };
+  const publishSingleTypeAction = async (uid, actionType, entryId) => {
+    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+    const entry = await strapi2.entityService.findOne(uid, entryId, { populate });
+    try {
+      if (actionType === "publish") {
+        await entityManagerService.publish(entry, uid);
+      } else {
+        await entityManagerService.unpublish(entry, uid);
+      }
+    } catch (error) {
+      if (error instanceof utils.errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft"))
+        ;
+      else {
+        throw error;
+      }
+    }
+  };
+  const publishCollectionTypeAction = async (uid, entriesToPublishIds, entriestoUnpublishIds) => {
+    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+    const entriesToPublish = await strapi2.entityService.findMany(uid, {
+      filters: {
+        id: {
+          $in: entriesToPublishIds
+        }
+      },
+      populate
+    });
+    const entriesToUnpublish = await strapi2.entityService.findMany(uid, {
+      filters: {
+        id: {
+          $in: entriestoUnpublishIds
+        }
+      },
+      populate
+    });
+    if (entriesToPublish.length > 0) {
+      await entityManagerService.publishMany(entriesToPublish, uid);
+    }
+    if (entriesToUnpublish.length > 0) {
+      await entityManagerService.unpublishMany(entriesToUnpublish, uid);
+    }
+  };
   const getFormattedActions = async (releaseId) => {
     const actions = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findMany({
       where: {
         release: {
           id: releaseId
         }
+      },
+      populate: {
+        entry: {
+          fields: ["id"]
+        }
       }
     });
     if (actions.length === 0) {
       throw new utils.errors.ValidationError("No entries to publish");
     }
-    const formattedActions = {};
+    const collectionTypeActions = {};
+    const singleTypeActions = [];
     for (const action of actions) {
       const contentTypeUid = action.contentType;
-      if (!formattedActions[contentTypeUid]) {
-        formattedActions[contentTypeUid] = {
-          publish: [],
-          unpublish: []
-        };
+      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
+        });
       }
-      formattedActions[contentTypeUid][action.type].push({
-        documentId: action.entryDocumentId,
-        locale: action.locale
-      });
     }
-    return formattedActions;
+    return { collectionTypeActions, singleTypeActions };
   };
   return {
     async create(releaseData, { user }) {
@@ -662,7 +655,7 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
         validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
       ]);
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).create({
+      const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
         data: {
           ...releaseWithCreatorFields,
           status: "empty"
@@ -676,28 +669,107 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       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 }
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
+        ...query
       });
       return release2;
     },
     findPage(query) {
-      const dbQuery = strapi2.get("query-params").transform(RELEASE_MODEL_UID, query ?? {});
-      return strapi2.db.query(RELEASE_MODEL_UID).findPage({
-        ...dbQuery,
+      return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
+        ...query,
         populate: {
           actions: {
+            // @ts-expect-error Ignore missing properties
             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 findManyWithContentTypeEntryAttached(contentTypeUid, entriesIds) {
+      let entries = entriesIds;
+      if (!Array.isArray(entriesIds)) {
+        entries = [entriesIds];
+      }
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          actions: {
+            target_type: contentTypeUid,
+            target_id: {
+              $in: entries
+            }
+          },
+          releasedAt: {
+            $null: true
+          }
+        },
+        populate: {
+          // Filter the action to get only the content type entry
+          actions: {
+            where: {
+              target_type: contentTypeUid,
+              target_id: {
+                $in: entries
+              }
+            },
+            populate: {
+              entry: {
+                select: ["id"]
+              }
+            }
+          }
+        }
+      });
+      return releases.map((release2) => {
+        if (release2.actions?.length) {
+          const actionsForEntry = release2.actions;
+          delete release2.actions;
+          return {
+            ...release2,
+            actions: actionsForEntry
+          };
+        }
+        return release2;
+      });
+    },
+    async findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId) {
+      const releasesRelated = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          releasedAt: {
+            $null: true
+          },
+          actions: {
+            target_type: contentTypeUid,
+            target_id: entryId
+          }
+        }
+      });
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          $or: [
+            {
+              id: {
+                $notIn: releasesRelated.map((release2) => release2.id)
+              }
+            },
+            {
+              actions: null
+            }
+          ],
+          releasedAt: {
+            $null: true
+          }
+        }
+      });
+      return releases.map((release2) => {
+        if (release2.actions?.length) {
+          const [actionForEntry] = release2.actions;
+          delete release2.actions;
+          return {
+            ...release2,
+            action: actionForEntry
+          };
+        }
+        return release2;
       });
     },
     async update(id, releaseData, { user }) {
@@ -712,15 +784,19 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
         validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
       ]);
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id } });
+      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.db.query(RELEASE_MODEL_UID).update({
-        where: { id },
+      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
       });
       const schedulingService = getService("scheduling", { strapi: strapi2 });
@@ -733,6 +809,132 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       strapi2.telemetry.send("didUpdateContentRelease");
       return updatedRelease;
     },
+    async createAction(releaseId, action, { disableUpdateReleaseStatus = false } = {}) {
+      const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
+        strapi: strapi2
+      });
+      await Promise.all([
+        validateEntryContentType(action.entry.contentType),
+        validateUniqueEntry(releaseId, action)
+      ]);
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      if (release2.releasedAt) {
+        throw new utils.errors.ValidationError("Release already published");
+      }
+      const { entry, type } = action;
+      const populatedEntry = await getPopulatedEntry(entry.contentType, entry.id, { strapi: strapi2 });
+      const isEntryValid = await getEntryValidStatus(entry.contentType, populatedEntry, { strapi: strapi2 });
+      const releaseAction2 = await strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
+        data: {
+          type,
+          contentType: entry.contentType,
+          locale: entry.locale,
+          isEntryValid,
+          entry: {
+            id: entry.id,
+            __type: entry.contentType,
+            __pivot: { field: "entry" }
+          },
+          release: releaseId
+        },
+        populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
+      });
+      if (!disableUpdateReleaseStatus) {
+        this.updateReleaseStatus(releaseId);
+      }
+      return releaseAction2;
+    },
+    async findActions(releaseId, query) {
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+        fields: ["id"]
+      });
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
+        ...query,
+        populate: {
+          entry: {
+            populate: "*"
+          }
+        },
+        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 ___default.default.groupBy(groupName)(formattedData);
+    },
+    async getLocalesDataForActions() {
+      if (!strapi2.plugin("i18n")) {
+        return {};
+      }
+      const allLocales = await strapi2.plugin("i18n").service("locales").find() || [];
+      return allLocales.reduce((acc, locale) => {
+        acc[locale.code] = { name: locale.name, code: locale.code };
+        return acc;
+      }, {});
+    },
+    async getContentTypesDataForActions(contentTypesUids) {
+      const contentManagerContentTypeService = strapi2.plugin("content-manager").service("content-types");
+      const contentTypesData = {};
+      for (const contentTypeUid of contentTypesUids) {
+        const contentTypeConfig = await contentManagerContentTypeService.findConfiguration({
+          uid: contentTypeUid
+        });
+        contentTypesData[contentTypeUid] = {
+          mainField: contentTypeConfig.settings.mainField,
+          displayName: strapi2.getModel(contentTypeUid).info.displayName
+        };
+      }
+      return contentTypesData;
+    },
+    getContentTypeModelsFromActions(actions) {
+      const contentTypeUids = actions.reduce((acc, action) => {
+        if (!acc.includes(action.contentType)) {
+          acc.push(action.contentType);
+        }
+        return acc;
+      }, []);
+      const contentTypeModelsMap = contentTypeUids.reduce(
+        (acc, contentTypeUid) => {
+          acc[contentTypeUid] = strapi2.getModel(contentTypeUid);
+          return acc;
+        },
+        {}
+      );
+      return contentTypeModelsMap;
+    },
     async getAllComponents() {
       const contentManagerComponentsService = strapi2.plugin("content-manager").service("components");
       const components = await contentManagerComponentsService.findAllComponents();
@@ -746,11 +948,10 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return componentsMap;
     },
     async delete(releaseId) {
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-        where: { id: releaseId },
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
         populate: {
           actions: {
-            select: ["id"]
+            fields: ["id"]
           }
         }
       });
@@ -768,11 +969,7 @@ const createReleaseService = ({ strapi: strapi2 }) => {
             }
           }
         });
-        await strapi2.db.query(RELEASE_MODEL_UID).delete({
-          where: {
-            id: releaseId
-          }
-        });
+        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
       });
       if (release2.scheduledAt) {
         const schedulingService = getService("scheduling", { strapi: strapi2 });
@@ -798,19 +995,22 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         }
         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 { collectionTypeActions, singleTypeActions } = await getFormattedActions(
+            releaseId
           );
+          await strapi2.db.transaction(async () => {
+            for (const { uid, action, id } of singleTypeActions) {
+              await publishSingleTypeAction(uid, action, id);
+            }
+            for (const contentTypeUid of Object.keys(collectionTypeActions)) {
+              const uid = contentTypeUid;
+              await publishCollectionTypeAction(
+                uid,
+                collectionTypeActions[uid].entriesToPublishIds,
+                collectionTypeActions[uid].entriesToUnpublishIds
+              );
+            }
+          });
           const release22 = await strapi2.db.query(RELEASE_MODEL_UID).update({
             where: {
               id: releaseId
@@ -840,226 +1040,13 @@ const createReleaseService = ({ strapi: strapi2 }) => {
           };
         }
       });
-      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"
-            }
-          });
-        }
-        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
-        },
-        data: {
-          status: "empty"
-        }
-      });
-    }
-  };
-};
-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 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 utils.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 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}`);
+      if (error) {
+        throw error;
       }
-      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 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);
-    },
-    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 countActions(query) {
-      const dbQuery = strapi2.get("query-params").transform(RELEASE_ACTION_MODEL_UID, query ?? {});
-      return strapi2.db.query(RELEASE_ACTION_MODEL_UID).count(dbQuery);
+      return release2;
     },
-    async update(actionId, releaseId, update) {
-      const action = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findOne({
+    async updateAction(actionId, releaseId, update) {
+      const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
         where: {
           id: actionId,
           release: {
@@ -1068,42 +1055,17 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
               $null: true
             }
           }
-        }
+        },
+        data: update
       });
-      if (!action) {
+      if (!updatedAction) {
         throw new utils.errors.NotFoundError(
           `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
         );
       }
-      const actionStatus = update.type === "publish" ? await getDraftEntryValidStatus(
-        {
-          contentType: action.contentType,
-          documentId: action.entryDocumentId,
-          locale: action.locale
-        },
-        {
-          strapi: 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 delete(actionId, releaseId) {
+    async deleteAction(actionId, releaseId) {
       const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
         where: {
           id: actionId,
@@ -1120,8 +1082,51 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
           `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
         );
       }
-      getService("release", { strapi: strapi2 }).updateReleaseStatus(releaseId);
+      this.updateReleaseStatus(releaseId);
       return deletedAction;
+    },
+    async updateReleaseStatus(releaseId) {
+      const [totalActions, invalidActions] = await Promise.all([
+        this.countActions({
+          filters: {
+            release: releaseId
+          }
+        }),
+        this.countActions({
+          filters: {
+            release: releaseId,
+            isEntryValid: false
+          }
+        })
+      ]);
+      if (totalActions > 0) {
+        if (invalidActions > 0) {
+          return strapi2.db.query(RELEASE_MODEL_UID).update({
+            where: {
+              id: releaseId
+            },
+            data: {
+              status: "blocked"
+            }
+          });
+        }
+        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
+        },
+        data: {
+          status: "empty"
+        }
+      });
     }
   };
 };
@@ -1133,43 +1138,37 @@ class AlreadyOnReleaseError extends utils.errors.ApplicationError {
 }
 const createReleaseValidationService = ({ strapi: strapi2 }) => ({
   async validateUniqueEntry(releaseId, releaseActionArgs) {
-    const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-      where: {
-        id: releaseId
-      },
-      populate: {
-        actions: true
-      }
+    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+      populate: { actions: { populate: { entry: { fields: ["id"] } } } }
     });
     if (!release2) {
       throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
     }
     const isEntryInRelease = release2.actions.some(
-      (action) => action.entryDocumentId === releaseActionArgs.entryDocumentId && action.contentType === releaseActionArgs.contentType && (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true)
+      (action) => Number(action.entry.id) === Number(releaseActionArgs.entry.id) && action.contentType === releaseActionArgs.entry.contentType
     );
     if (isEntryInRelease) {
       throw new AlreadyOnReleaseError(
-        `Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ""} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`
+        `Entry with id ${releaseActionArgs.entry.id} and contentType ${releaseActionArgs.entry.contentType} already exists in release with id ${releaseId}`
       );
     }
   },
-  validateEntryData(contentTypeUid, entryDocumentId) {
+  validateEntryContentType(contentTypeUid) {
     const contentType = strapi2.contentType(contentTypeUid);
     if (!contentType) {
       throw new utils.errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
     }
-    if (!utils.contentTypes.hasDraftAndPublish(contentType)) {
+    if (!contentType.options?.draftAndPublish) {
       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 featureCfg = strapi2.ee.features.get("cms-content-releases");
-    const maximumPendingReleases = typeof featureCfg === "object" && featureCfg?.options?.maximumReleases || 3;
+    const maximumPendingReleases = (
+      // @ts-expect-error - options is not typed into features
+      EE__default.default.features.get("cms-content-releases")?.options?.maximumReleases || 3
+    );
     const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
       filters: {
         releasedAt: {
@@ -1182,8 +1181,8 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
     }
   },
   async validateUniqueNameForPendingRelease(name, id) {
-    const pendingReleases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-      where: {
+    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
+      filters: {
         releasedAt: {
           $null: true
         },
@@ -1212,7 +1211,7 @@ const createSchedulingService = ({ strapi: strapi2 }) => {
       }
       const job = nodeSchedule.scheduleJob(scheduleDate, async () => {
         try {
-          await getService("release", { strapi: strapi2 }).publish(releaseId);
+          await getService("release").publish(releaseId);
         } catch (error) {
         }
         this.cancel(releaseId);
@@ -1254,172 +1253,85 @@ 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,
-  scheduling: createSchedulingService,
-  settings: createSettingsService
+  scheduling: createSchedulingService
 };
-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()
+const RELEASE_SCHEMA = yup__namespace.object().shape({
+  name: yup__namespace.string().trim().required(),
+  scheduledAt: yup__namespace.string().nullable(),
+  isScheduled: yup__namespace.boolean().optional(),
+  time: yup__namespace.string().when("isScheduled", {
+    is: true,
+    then: yup__namespace.string().trim().required(),
+    otherwise: yup__namespace.string().nullable()
+  }),
+  timezone: yup__namespace.string().when("isScheduled", {
+    is: true,
+    then: yup__namespace.string().required().nullable(),
+    otherwise: yup__namespace.string().nullable()
+  }),
+  date: yup__namespace.string().when("isScheduled", {
+    is: true,
+    then: yup__namespace.string().required().nullable(),
+    otherwise: yup__namespace.string().nullable()
   })
 }).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 = {
-  /**
-   * 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({
+  async findMany(ctx) {
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_MODEL_UID
     });
     await permissionsManager.validateQuery(ctx.query);
     const releaseService = getService("release", { strapi });
-    const 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: releases };
+    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 relatedReleases = await releaseService.findMany({
-        where: {
-          releasedAt: null,
+      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: {
-            contentType,
-            entryDocumentId: entryDocumentId ?? null,
-            locale: locale ?? null
+            meta: {
+              count: actions.count
+            }
           }
-        }
+        };
       });
-      const releases = await releaseService.findMany({
+      const pendingReleasesCount = await strapi.query(RELEASE_MODEL_UID).count({
         where: {
-          $or: [
-            {
-              id: {
-                $notIn: relatedReleases.map((release2) => release2.id)
-              }
-            },
-            {
-              actions: null
-            }
-          ],
           releasedAt: null
         }
       });
-      ctx.body = { data: releases };
+      ctx.body = { data, meta: { pagination, pendingReleasesCount } };
     }
   },
-  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 utils.errors.NotFoundError(`Release not found for id: ${id}`);
     }
-    const count = await releaseActionService.countActions({
+    const count = await releaseService.countActions({
       filters: {
         release: id
       }
     });
     const sanitizedRelease = {
       ...release2,
-      createdBy: release2.createdBy ? strapi.service("admin::user").sanitizeUser(release2.createdBy) : null
+      createdBy: release2.createdBy ? strapi.admin.services.user.sanitizeUser(release2.createdBy) : null
     };
     const data = {
       ...sanitizedRelease,
@@ -1432,39 +1344,22 @@ const releaseController = {
     ctx.body = { data };
   },
   async mapEntriesToReleases(ctx) {
-    const { contentTypeUid, documentIds, locale } = ctx.query;
-    if (!contentTypeUid || !documentIds) {
+    const { contentTypeUid, entriesIds } = ctx.query;
+    if (!contentTypeUid || !entriesIds) {
       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 releasesWithActions = await releaseService.findManyWithContentTypeEntryAttached(
+      contentTypeUid,
+      entriesIds
+    );
     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 }];
+          if (!acc[action.entry.id]) {
+            acc[action.entry.id] = [{ id: release2.id, name: release2.name }];
           } else {
-            acc[action.entryDocumentId].push({ id: release2.id, name: release2.name });
+            acc[action.entry.id].push({ id: release2.id, name: release2.name });
           }
         });
         return acc;
@@ -1481,13 +1376,13 @@ const releaseController = {
     await validateRelease(releaseArgs);
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.create(releaseArgs, { user });
-    const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_MODEL_UID
     });
-    ctx.created({
+    ctx.body = {
       data: await permissionsManager.sanitizeOutput(release2)
-    });
+    };
   },
   async update(ctx) {
     const user = ctx.state.user;
@@ -1496,7 +1391,7 @@ const releaseController = {
     await validateRelease(releaseArgs);
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.update(id, releaseArgs, { user });
-    const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_MODEL_UID
     });
@@ -1513,18 +1408,18 @@ const releaseController = {
     };
   },
   async publish(ctx) {
+    const user = ctx.state.user;
     const id = ctx.params.id;
     const releaseService = getService("release", { strapi });
-    const releaseActionService = getService("release-action", { strapi });
-    const release2 = await releaseService.publish(id);
+    const release2 = await releaseService.publish(id, { user });
     const [countPublishActions, countUnpublishActions] = await Promise.all([
-      releaseActionService.countActions({
+      releaseService.countActions({
         filters: {
           release: id,
           type: "publish"
         }
       }),
-      releaseActionService.countActions({
+      releaseService.countActions({
         filters: {
           release: id,
           type: "unpublish"
@@ -1542,30 +1437,27 @@ const releaseController = {
   }
 };
 const RELEASE_ACTION_SCHEMA = utils.yup.object().shape({
-  contentType: utils.yup.string().required(),
-  entryDocumentId: utils.yup.strapiID(),
-  locale: utils.yup.string(),
+  entry: utils.yup.object().shape({
+    id: utils.yup.strapiID().required(),
+    contentType: utils.yup.string().required()
+  }).required(),
   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 releaseActionService = getService("release-action", { strapi });
-    const releaseAction2 = await releaseActionService.create(releaseId, releaseActionArgs);
-    ctx.created({
+    const releaseService = getService("release", { strapi });
+    const releaseAction2 = await releaseService.createAction(releaseId, releaseActionArgs);
+    ctx.body = {
       data: releaseAction2
-    });
+    };
   },
   async createMany(ctx) {
     const releaseId = ctx.params.releaseId;
@@ -1573,13 +1465,12 @@ const releaseActionController = {
     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, {
+            const action = await releaseService.createAction(releaseId, releaseActionArgs, {
               disableUpdateReleaseStatus: true
             });
             return action;
@@ -1597,51 +1488,43 @@ const releaseActionController = {
     if (newReleaseActions.length > 0) {
       releaseService.updateReleaseStatus(releaseId);
     }
-    ctx.created({
+    ctx.body = {
       data: newReleaseActions,
       meta: {
         entriesAlreadyInRelease: releaseActions.length - newReleaseActions.length,
         totalEntries: releaseActions.length
       }
-    });
+    };
   },
   async findMany(ctx) {
     const releaseId = ctx.params.releaseId;
-    const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
       ability: ctx.state.userAbility,
       model: RELEASE_ACTION_MODEL_UID
     });
-    await validateFindManyActionsParams(ctx.query);
-    if (ctx.query.groupBy) {
-      if (!["action", "contentType", "locale"].includes(ctx.query.groupBy)) {
-        ctx.badRequest("Invalid groupBy parameter");
-      }
-    }
-    ctx.query.sort = ctx.query.groupBy === "action" ? "type" : ctx.query.groupBy;
-    delete ctx.query.groupBy;
     const query = await permissionsManager.sanitizeQuery(ctx.query);
-    const releaseActionService = getService("release-action", { strapi });
-    const { results, pagination } = await releaseActionService.findPage(releaseId, {
+    const releaseService = getService("release", { strapi });
+    const { results, pagination } = await releaseService.findActions(releaseId, {
+      sort: query.groupBy === "action" ? "type" : query.groupBy,
       ...query
     });
     const contentTypeOutputSanitizers = results.reduce((acc, action) => {
       if (acc[action.contentType]) {
         return acc;
       }
-      const contentTypePermissionsManager = strapi.service("admin::permission").createPermissionsManager({
+      const contentTypePermissionsManager = strapi.admin.services.permission.createPermissionsManager({
         ability: ctx.state.userAbility,
         model: action.contentType
       });
       acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
       return acc;
     }, {});
-    const sanitizedResults = await utils.async.map(results, async (action) => ({
+    const sanitizedResults = await utils.mapAsync(results, async (action) => ({
       ...action,
-      entry: action.entry ? await contentTypeOutputSanitizers[action.contentType](action.entry) : {}
+      entry: await contentTypeOutputSanitizers[action.contentType](action.entry)
     }));
-    const groupedData = await releaseActionService.groupActions(sanitizedResults, query.sort);
-    const contentTypes2 = releaseActionService.getContentTypeModelsFromActions(results);
-    const releaseService = getService("release", { strapi });
+    const groupedData = await releaseService.groupActions(sanitizedResults, query.groupBy);
+    const contentTypes2 = releaseService.getContentTypeModelsFromActions(results);
     const components = await releaseService.getAllComponents();
     ctx.body = {
       data: groupedData,
@@ -1657,8 +1540,8 @@ const releaseActionController = {
     const releaseId = ctx.params.releaseId;
     const releaseActionUpdateArgs = ctx.request.body;
     await validateReleaseActionUpdateSchema(releaseActionUpdateArgs);
-    const releaseActionService = getService("release-action", { strapi });
-    const updatedAction = await releaseActionService.update(
+    const releaseService = getService("release", { strapi });
+    const updatedAction = await releaseService.updateAction(
       actionId,
       releaseId,
       releaseActionUpdateArgs
@@ -1670,36 +1553,14 @@ const releaseActionController = {
   async delete(ctx) {
     const actionId = ctx.params.actionId;
     const releaseId = ctx.params.releaseId;
-    const releaseActionService = getService("release-action", { strapi });
-    const deletedReleaseAction = await releaseActionService.delete(actionId, releaseId);
+    const releaseService = getService("release", { strapi });
+    const deletedReleaseAction = await releaseService.deleteAction(actionId, releaseId);
     ctx.body = {
       data: deletedReleaseAction
     };
   }
 };
-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 controllers = { release: releaseController, "release-action": releaseActionController };
 const release = {
   type: "admin",
   routes: [
@@ -1719,22 +1580,6 @@ const release = {
         ]
       }
     },
-    {
-      method: "GET",
-      path: "/getByDocumentAttached",
-      handler: "release.findByDocumentAttached",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
-            config: {
-              actions: ["plugin::content-releases.read"]
-            }
-          }
-        ]
-      }
-    },
     {
       method: "POST",
       path: "/",
@@ -1754,7 +1599,7 @@ const release = {
     {
       method: "GET",
       path: "/",
-      handler: "release.findPage",
+      handler: "release.findMany",
       config: {
         policies: [
           "admin::isAuthenticatedAdmin",
@@ -1918,50 +1763,13 @@ 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 (strapi.ee.features.isEnabled("cms-content-releases")) {
+  if (features.isEnabled("cms-content-releases")) {
     return {
       register,
       bootstrap,