@strapi/content-releases 0.0.0-next.615ae85762cbae9fc80af36685075ef25abd1c88 → 0.0.0-next.6785f47fadddb80404c824be0a0732c652850b45

package/dist/server/index.js

@@ -1,5 +1,6 @@
 "use strict";
 const utils = require("@strapi/utils");
+const isEqual = require("lodash/isEqual");
 const lodash = require("lodash");
 const _ = require("lodash/fp");
 const EE = require("@strapi/strapi/dist/utils/ee");
@@ -24,6 +25,7 @@ function _interopNamespace(e) {
   n.default = e;
   return Object.freeze(n);
 }
+const isEqual__default = /* @__PURE__ */ _interopDefault(isEqual);
 const ___default = /* @__PURE__ */ _interopDefault(_);
 const EE__default = /* @__PURE__ */ _interopDefault(EE);
 const yup__namespace = /* @__PURE__ */ _interopNamespace(yup);
@@ -73,6 +75,32 @@ const ACTIONS = [
     pluginName: "content-releases"
   }
 ];
+const ALLOWED_WEBHOOK_EVENTS = {
+  RELEASES_PUBLISH: "releases.publish"
+};
+const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  return strapi2.plugin("content-releases").service(name);
+};
+const getPopulatedEntry = async (contentTypeUid, entryId, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+  const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
+  const entry = await strapi2.entityService.findOne(contentTypeUid, entryId, { populate });
+  return entry;
+};
+const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  try {
+    await strapi2.entityValidator.validateEntityCreation(
+      strapi2.getModel(contentTypeUid),
+      entry,
+      void 0,
+      // @ts-expect-error - FIXME: entity here is unnecessary
+      entry
+    );
+    return true;
+  } catch {
+    return false;
+  }
+};
 async function deleteActionsOnDisableDraftAndPublish({
   oldContentTypes,
   contentTypes: contentTypes2
@@ -99,31 +127,202 @@ async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes:
     });
   }
 }
+async function migrateIsValidAndStatusReleases() {
+  const releasesWithoutStatus = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+    where: {
+      status: null,
+      releasedAt: null
+    },
+    populate: {
+      actions: {
+        populate: {
+          entry: true
+        }
+      }
+    }
+  });
+  utils.mapAsync(releasesWithoutStatus, async (release2) => {
+    const actions = release2.actions;
+    const notValidatedActions = actions.filter((action) => action.isEntryValid === null);
+    for (const action of notValidatedActions) {
+      if (action.entry) {
+        const populatedEntry = await getPopulatedEntry(action.contentType, action.entry.id, {
+          strapi
+        });
+        if (populatedEntry) {
+          const isEntryValid = getEntryValidStatus(action.contentType, populatedEntry, { strapi });
+          await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+            where: {
+              id: action.id
+            },
+            data: {
+              isEntryValid
+            }
+          });
+        }
+      }
+    }
+    return getService("release", { strapi }).updateReleaseStatus(release2.id);
+  });
+  const publishedReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+    where: {
+      status: null,
+      releasedAt: {
+        $notNull: true
+      }
+    }
+  });
+  utils.mapAsync(publishedReleases, async (release2) => {
+    return strapi.db.query(RELEASE_MODEL_UID).update({
+      where: {
+        id: release2.id
+      },
+      data: {
+        status: "done"
+      }
+    });
+  });
+}
+async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (oldContentTypes !== void 0 && contentTypes2 !== void 0) {
+    const contentTypesWithDraftAndPublish = Object.keys(oldContentTypes).filter(
+      (uid) => oldContentTypes[uid]?.options?.draftAndPublish
+    );
+    const releasesAffected = /* @__PURE__ */ new Set();
+    utils.mapAsync(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
+      const oldContentType = oldContentTypes[contentTypeUID];
+      const contentType = contentTypes2[contentTypeUID];
+      if (!isEqual__default.default(oldContentType?.attributes, contentType?.attributes)) {
+        const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+          where: {
+            contentType: contentTypeUID
+          },
+          populate: {
+            entry: true,
+            release: true
+          }
+        });
+        await utils.mapAsync(actions, async (action) => {
+          if (action.entry && action.release) {
+            const populatedEntry = await getPopulatedEntry(contentTypeUID, action.entry.id, {
+              strapi
+            });
+            if (populatedEntry) {
+              const isEntryValid = await getEntryValidStatus(contentTypeUID, populatedEntry, {
+                strapi
+              });
+              releasesAffected.add(action.release.id);
+              await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+                where: {
+                  id: action.id
+                },
+                data: {
+                  isEntryValid
+                }
+              });
+            }
+          }
+        });
+      }
+    }).then(() => {
+      utils.mapAsync(releasesAffected, async (releaseId) => {
+        return getService("release", { strapi }).updateReleaseStatus(releaseId);
+      });
+    });
+  }
+}
+async function disableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (!oldContentTypes) {
+    return;
+  }
+  const i18nPlugin = strapi.plugin("i18n");
+  if (!i18nPlugin) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    const { isLocalizedContentType } = i18nPlugin.service("content-types");
+    if (isLocalizedContentType(oldContentType) && !isLocalizedContentType(contentType)) {
+      await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
+        locale: null
+      }).where({ contentType: uid }).execute();
+    }
+  }
+}
+async function enableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (!oldContentTypes) {
+    return;
+  }
+  const i18nPlugin = strapi.plugin("i18n");
+  if (!i18nPlugin) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    const { isLocalizedContentType } = i18nPlugin.service("content-types");
+    const { getDefaultLocale } = i18nPlugin.service("locales");
+    if (!isLocalizedContentType(oldContentType) && isLocalizedContentType(contentType)) {
+      const defaultLocale = await getDefaultLocale();
+      await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
+        locale: defaultLocale
+      }).where({ contentType: uid }).execute();
+    }
+  }
+}
 const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
 const register = async ({ strapi: strapi2 }) => {
   if (features$2.isEnabled("cms-content-releases")) {
     await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
-    strapi2.hook("strapi::content-types.beforeSync").register(deleteActionsOnDisableDraftAndPublish);
-    strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType);
+    strapi2.hook("strapi::content-types.beforeSync").register(deleteActionsOnDisableDraftAndPublish).register(disableContentTypeLocalized);
+    strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType).register(enableContentTypeLocalized).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
+  }
+  if (strapi2.plugin("graphql")) {
+    const graphqlExtensionService = strapi2.plugin("graphql").service("extension");
+    graphqlExtensionService.shadowCRUD(RELEASE_MODEL_UID).disable();
+    graphqlExtensionService.shadowCRUD(RELEASE_ACTION_MODEL_UID).disable();
   }
-};
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.plugin("content-releases").service(name);
 };
 const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
 const bootstrap = async ({ strapi: strapi2 }) => {
   if (features$1.isEnabled("cms-content-releases")) {
+    const contentTypesWithDraftAndPublish = Object.keys(strapi2.contentTypes).filter(
+      (uid) => strapi2.contentTypes[uid]?.options?.draftAndPublish
+    );
     strapi2.db.lifecycles.subscribe({
-      afterDelete(event) {
-        const { model, result } = event;
-        if (model.kind === "collectionType" && model.options?.draftAndPublish) {
-          const { id } = result;
-          strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-            where: {
-              target_type: model.uid,
-              target_id: id
+      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 });
         }
       },
       /**
@@ -143,38 +342,94 @@ const bootstrap = async ({ strapi: strapi2 }) => {
        * We make this only after deleteMany is succesfully executed to avoid errors
        */
       async afterDeleteMany(event) {
-        const { model, state } = event;
-        const entriesToDelete = state.entriesToDelete;
-        if (entriesToDelete) {
-          await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-            where: {
-              target_type: model.uid,
-              target_id: {
-                $in: entriesToDelete.map((entry) => entry.id)
+        try {
+          const { model, 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 });
+        }
       }
     });
-    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;
-      });
-    }
+    getService("scheduling", { strapi: strapi2 }).syncFromDatabase().catch((err) => {
+      strapi2.log.error(
+        "Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling."
+      );
+      throw err;
+    });
+    Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
+      strapi2.webhookStore.addAllowedEvent(key, value);
+    });
   }
 };
 const 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 = {
@@ -209,6 +464,11 @@ const schema$1 = {
     timezone: {
       type: "string"
     },
+    status: {
+      type: "enumeration",
+      enum: ["ready", "blocked", "failed", "done", "empty"],
+      required: true
+    },
     actions: {
       type: "relation",
       relation: "oneToMany",
@@ -261,6 +521,9 @@ const schema = {
       relation: "manyToOne",
       target: RELEASE_MODEL_UID,
       inversedBy: "actions"
+    },
+    isEntryValid: {
+      type: "boolean"
     }
   }
 };
@@ -283,472 +546,594 @@ const getGroupName = (queryValue) => {
       return "contentType.displayName";
   }
 };
-const createReleaseService = ({ strapi: strapi2 }) => ({
-  async create(releaseData, { user }) {
-    const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
-    const {
-      validatePendingReleasesLimit,
-      validateUniqueNameForPendingRelease,
-      validateScheduledAtIsLaterThanNow
-    } = getService("release-validation", { strapi: strapi2 });
-    await Promise.all([
-      validatePendingReleasesLimit(),
-      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
-      validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
-    ]);
-    const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
-      data: releaseWithCreatorFields
+const createReleaseService = ({ strapi: strapi2 }) => {
+  const dispatchWebhook = (event, { isPublished, release: release2, error }) => {
+    strapi2.eventHub.emit(event, {
+      isPublished,
+      error,
+      release: release2
     });
-    if (strapi2.features.future.isEnabled("contentReleasesScheduling") && releaseWithCreatorFields.scheduledAt) {
-      const schedulingService = getService("scheduling", { strapi: strapi2 });
-      await schedulingService.set(release2.id, release2.scheduledAt);
+  };
+  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;
+      }
     }
-    strapi2.telemetry.send("didCreateContentRelease");
-    return release2;
-  },
-  async findOne(id, query = {}) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
-      ...query
+  };
+  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
     });
-    return release2;
-  },
-  findPage(query) {
-    return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
-      ...query,
-      populate: {
-        actions: {
-          // @ts-expect-error Ignore missing properties
-          count: true
+    const entriesToUnpublish = await strapi2.entityService.findMany(uid, {
+      filters: {
+        id: {
+          $in: entriestoUnpublishIds
         }
-      }
+      },
+      populate
     });
-  },
-  async findManyWithContentTypeEntryAttached(contentTypeUid, entryId) {
-    const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+    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: {
-        actions: {
-          target_type: contentTypeUid,
-          target_id: entryId
-        },
-        releasedAt: {
-          $null: true
+        release: {
+          id: releaseId
         }
       },
       populate: {
-        // Filter the action to get only the content type entry
-        actions: {
-          where: {
-            target_type: contentTypeUid,
-            target_id: entryId
-          }
+        entry: {
+          fields: ["id"]
         }
       }
     });
-    return releases.map((release2) => {
-      if (release2.actions?.length) {
-        const [actionForEntry] = release2.actions;
-        delete release2.actions;
-        return {
-          ...release2,
-          action: actionForEntry
-        };
+    if (actions.length === 0) {
+      throw new utils.errors.ValidationError("No entries to publish");
+    }
+    const collectionTypeActions = {};
+    const singleTypeActions = [];
+    for (const action of actions) {
+      const contentTypeUid = action.contentType;
+      if (strapi2.contentTypes[contentTypeUid].kind === "collectionType") {
+        if (!collectionTypeActions[contentTypeUid]) {
+          collectionTypeActions[contentTypeUid] = {
+            entriesToPublishIds: [],
+            entriesToUnpublishIds: []
+          };
+        }
+        if (action.type === "publish") {
+          collectionTypeActions[contentTypeUid].entriesToPublishIds.push(action.entry.id);
+        } else {
+          collectionTypeActions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
+        }
+      } else {
+        singleTypeActions.push({
+          uid: contentTypeUid,
+          action: action.type,
+          id: action.entry.id
+        });
       }
+    }
+    return { collectionTypeActions, singleTypeActions };
+  };
+  return {
+    async create(releaseData, { user }) {
+      const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
+      const {
+        validatePendingReleasesLimit,
+        validateUniqueNameForPendingRelease,
+        validateScheduledAtIsLaterThanNow
+      } = getService("release-validation", { strapi: strapi2 });
+      await Promise.all([
+        validatePendingReleasesLimit(),
+        validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
+        validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
+      ]);
+      const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
+        data: {
+          ...releaseWithCreatorFields,
+          status: "empty"
+        }
+      });
+      if (releaseWithCreatorFields.scheduledAt) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        await schedulingService.set(release2.id, release2.scheduledAt);
+      }
+      strapi2.telemetry.send("didCreateContentRelease");
       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
+    },
+    async findOne(id, query = {}) {
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
+        ...query
+      });
+      return release2;
+    },
+    findPage(query) {
+      return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
+        ...query,
+        populate: {
+          actions: {
+            // @ts-expect-error Ignore missing properties
+            count: true
+          }
         }
+      });
+    },
+    async findManyWithContentTypeEntryAttached(contentTypeUid, entriesIds) {
+      let entries = entriesIds;
+      if (!Array.isArray(entriesIds)) {
+        entries = [entriesIds];
       }
-    });
-    const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-      where: {
-        $or: [
-          {
-            id: {
-              $notIn: releasesRelated.map((release2) => release2.id)
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          actions: {
+            target_type: contentTypeUid,
+            target_id: {
+              $in: entries
             }
           },
-          {
-            actions: null
+          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
           }
-        ],
-        releasedAt: {
-          $null: true
         }
+      });
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          $or: [
+            {
+              id: {
+                $notIn: releasesRelated.map((release2) => release2.id)
+              }
+            },
+            {
+              actions: null
+            }
+          ],
+          releasedAt: {
+            $null: true
+          }
+        }
+      });
+      return releases.map((release2) => {
+        if (release2.actions?.length) {
+          const [actionForEntry] = release2.actions;
+          delete release2.actions;
+          return {
+            ...release2,
+            action: actionForEntry
+          };
+        }
+        return release2;
+      });
+    },
+    async update(id, releaseData, { user }) {
+      const releaseWithCreatorFields = await utils.setCreatorFields({ user, isEdition: true })(
+        releaseData
+      );
+      const { validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService(
+        "release-validation",
+        { strapi: strapi2 }
+      );
+      await Promise.all([
+        validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
+        validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
+      ]);
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${id}`);
       }
-    });
-    return releases.map((release2) => {
-      if (release2.actions?.length) {
-        const [actionForEntry] = release2.actions;
-        delete release2.actions;
-        return {
-          ...release2,
-          action: actionForEntry
-        };
+      if (release2.releasedAt) {
+        throw new utils.errors.ValidationError("Release already published");
       }
-      return release2;
-    });
-  },
-  async update(id, releaseData, { user }) {
-    const releaseWithCreatorFields = await utils.setCreatorFields({ user, isEdition: true })(releaseData);
-    const { validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService(
-      "release-validation",
-      { strapi: strapi2 }
-    );
-    await Promise.all([
-      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
-      validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
-    ]);
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${id}`);
-    }
-    if (release2.releasedAt) {
-      throw new utils.errors.ValidationError("Release already published");
-    }
-    const updatedRelease = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
-      /*
-       * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">>
-       * is not compatible with the type we are passing here: UpdateRelease.Request['body']
-       */
-      // @ts-expect-error see above
-      data: releaseWithCreatorFields
-    });
-    if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+      const 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 });
       if (releaseData.scheduledAt) {
         await schedulingService.set(id, releaseData.scheduledAt);
       } else if (release2.scheduledAt) {
         schedulingService.cancel(id);
       }
-    }
-    strapi2.telemetry.send("didUpdateContentRelease");
-    return updatedRelease;
-  },
-  async createAction(releaseId, action) {
-    const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
-      strapi: strapi2
-    });
-    await Promise.all([
-      validateEntryContentType(action.entry.contentType),
-      validateUniqueEntry(releaseId, action)
-    ]);
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-    }
-    if (release2.releasedAt) {
-      throw new utils.errors.ValidationError("Release already published");
-    }
-    const { entry, type } = action;
-    return strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
-      data: {
-        type,
-        contentType: entry.contentType,
-        locale: entry.locale,
-        entry: {
-          id: entry.id,
-          __type: entry.contentType,
-          __pivot: { field: "entry" }
-        },
-        release: releaseId
-      },
-      populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
-    });
-  },
-  async findActions(releaseId, query) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-      fields: ["id"]
-    });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-    }
-    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);
+      this.updateReleaseStatus(id);
+      strapi2.telemetry.send("didUpdateContentRelease");
+      return updatedRelease;
+    },
+    async createAction(releaseId, action) {
+      const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
+        strapi: strapi2
+      });
+      await Promise.all([
+        validateEntryContentType(action.entry.contentType),
+        validateUniqueEntry(releaseId, action)
+      ]);
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
       }
-      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
+      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"] } }
       });
-      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);
+      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 acc;
-    }, []);
-    const contentTypeModelsMap = contentTypeUids.reduce(
-      (acc, contentTypeUid) => {
-        acc[contentTypeUid] = strapi2.getModel(contentTypeUid);
+      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;
-      },
-      {}
-    );
-    return contentTypeModelsMap;
-  },
-  async getAllComponents() {
-    const contentManagerComponentsService = strapi2.plugin("content-manager").service("components");
-    const components = await contentManagerComponentsService.findAllComponents();
-    const componentsMap = components.reduce(
-      (acc, component) => {
-        acc[component.uid] = component;
+      }, []);
+      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;
-      },
-      {}
-    );
-    return componentsMap;
-  },
-  async delete(releaseId) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-      populate: {
-        actions: {
-          fields: ["id"]
-        }
+      }, {});
+    },
+    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
+        };
       }
-    });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-    }
-    if (release2.releasedAt) {
-      throw new utils.errors.ValidationError("Release already published");
-    }
-    await strapi2.db.transaction(async () => {
-      await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-        where: {
-          id: {
-            $in: release2.actions.map((action) => action.id)
-          }
+      return contentTypesData;
+    },
+    getContentTypeModelsFromActions(actions) {
+      const contentTypeUids = actions.reduce((acc, action) => {
+        if (!acc.includes(action.contentType)) {
+          acc.push(action.contentType);
         }
-      });
-      await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
-    });
-    if (strapi2.features.future.isEnabled("contentReleasesScheduling") && release2.scheduledAt) {
-      const schedulingService = getService("scheduling", { strapi: strapi2 });
-      await schedulingService.cancel(release2.id);
-    }
-    strapi2.telemetry.send("didDeleteContentRelease");
-    return release2;
-  },
-  async publish(releaseId) {
-    const releaseWithPopulatedActionEntries = await strapi2.entityService.findOne(
-      RELEASE_MODEL_UID,
-      releaseId,
-      {
+        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();
+      const componentsMap = components.reduce(
+        (acc, component) => {
+          acc[component.uid] = component;
+          return acc;
+        },
+        {}
+      );
+      return componentsMap;
+    },
+    async delete(releaseId) {
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
         populate: {
           actions: {
-            populate: {
-              entry: {
-                fields: ["id"]
-              }
-            }
+            fields: ["id"]
           }
         }
+      });
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
       }
-    );
-    if (!releaseWithPopulatedActionEntries) {
-      throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
-    }
-    if (releaseWithPopulatedActionEntries.releasedAt) {
-      throw new utils.errors.ValidationError("Release already published");
-    }
-    if (releaseWithPopulatedActionEntries.actions.length === 0) {
-      throw new utils.errors.ValidationError("No entries to publish");
-    }
-    const 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
+      if (release2.releasedAt) {
+        throw new utils.errors.ValidationError("Release already published");
+      }
+      await strapi2.db.transaction(async () => {
+        await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+          where: {
+            id: {
+              $in: release2.actions.map((action) => action.id)
+            }
+          }
         });
+        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
+      });
+      if (release2.scheduledAt) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        await schedulingService.cancel(release2.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 });
+      strapi2.telemetry.send("didDeleteContentRelease");
+      return release2;
+    },
+    async publish(releaseId) {
+      const {
+        release: release2,
+        error
+      } = await strapi2.db.transaction(async ({ trx }) => {
+        const lockedRelease = await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).select(["id", "name", "releasedAt", "status"]).first().transacting(trx).forUpdate().execute();
+        if (!lockedRelease) {
+          throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+        }
+        if (lockedRelease.releasedAt) {
+          throw new utils.errors.ValidationError("Release already published");
+        }
+        if (lockedRelease.status === "failed") {
+          throw new utils.errors.ValidationError("Release failed to publish");
+        }
         try {
-          if (action === "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;
-          }
+          strapi2.log.info(`[Content Releases] Starting to publish release ${lockedRelease.name}`);
+          const { collectionTypeActions, singleTypeActions } = await getFormattedActions(
+            releaseId
+          );
+          await strapi2.db.transaction(async () => {
+            for (const { uid, action, id } of singleTypeActions) {
+              await publishSingleTypeAction(uid, action, id);
+            }
+            for (const contentTypeUid of Object.keys(collectionTypeActions)) {
+              const uid = contentTypeUid;
+              await publishCollectionTypeAction(
+                uid,
+                collectionTypeActions[uid].entriesToPublishIds,
+                collectionTypeActions[uid].entriesToUnpublishIds
+              );
+            }
+          });
+          const release22 = await strapi2.db.query(RELEASE_MODEL_UID).update({
+            where: {
+              id: releaseId
+            },
+            data: {
+              status: "done",
+              releasedAt: /* @__PURE__ */ new Date()
+            }
+          });
+          dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+            isPublished: true,
+            release: release22
+          });
+          strapi2.telemetry.send("didPublishContentRelease");
+          return { release: release22, error: null };
+        } catch (error2) {
+          dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+            isPublished: false,
+            error: error2
+          });
+          await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).update({
+            status: "failed"
+          }).transacting(trx).execute();
+          return {
+            release: null,
+            error: error2
+          };
         }
+      });
+      if (error) {
+        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
+      return release2;
+    },
+    async updateAction(actionId, releaseId, update) {
+      const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
+        where: {
+          id: actionId,
+          release: {
+            id: releaseId,
+            releasedAt: {
+              $null: true
+            }
           }
+        },
+        data: update
+      });
+      if (!updatedAction) {
+        throw new utils.errors.NotFoundError(
+          `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
         );
-        const entriesToUnpublish = await strapi2.entityService.findMany(
-          contentTypeUid,
-          {
-            filters: {
-              id: {
-                $in: entriesToUnpublishIds
-              }
-            },
-            populate
+      }
+      return updatedAction;
+    },
+    async deleteAction(actionId, releaseId) {
+      const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
+        where: {
+          id: actionId,
+          release: {
+            id: releaseId,
+            releasedAt: {
+              $null: true
+            }
           }
-        );
-        if (entriesToPublish.length > 0) {
-          await entityManagerService.publishMany(entriesToPublish, contentTypeUid);
-        }
-        if (entriesToUnpublish.length > 0) {
-          await entityManagerService.unpublishMany(entriesToUnpublish, contentTypeUid);
         }
+      });
+      if (!deletedAction) {
+        throw new utils.errors.NotFoundError(
+          `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
+        );
       }
-    });
-    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()
-      }
-    });
-    strapi2.telemetry.send("didPublishContentRelease");
-    return release2;
-  },
-  async updateAction(actionId, releaseId, update) {
-    const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
-      where: {
-        id: actionId,
-        release: {
-          id: releaseId,
-          releasedAt: {
-            $null: true
+      this.updateReleaseStatus(releaseId);
+      return deletedAction;
+    },
+    async updateReleaseStatus(releaseId) {
+      const [totalActions, invalidActions] = await Promise.all([
+        this.countActions({
+          filters: {
+            release: releaseId
           }
-        }
-      },
-      data: update
-    });
-    if (!updatedAction) {
-      throw new utils.errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
-      );
-    }
-    return updatedAction;
-  },
-  async deleteAction(actionId, releaseId) {
-    const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
-      where: {
-        id: actionId,
-        release: {
-          id: releaseId,
-          releasedAt: {
-            $null: true
+        }),
+        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"
+          }
+        });
       }
-    });
-    if (!deletedAction) {
-      throw new utils.errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
-      );
+      return strapi2.db.query(RELEASE_MODEL_UID).update({
+        where: {
+          id: releaseId
+        },
+        data: {
+          status: "empty"
+        }
+      });
     }
-    return deletedAction;
+  };
+};
+class AlreadyOnReleaseError extends utils.errors.ApplicationError {
+  constructor(message) {
+    super(message);
+    this.name = "AlreadyOnReleaseError";
   }
-});
+}
 const createReleaseValidationService = ({ strapi: strapi2 }) => ({
   async validateUniqueEntry(releaseId, releaseActionArgs) {
     const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
@@ -761,7 +1146,7 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
       (action) => Number(action.entry.id) === Number(releaseActionArgs.entry.id) && action.contentType === releaseActionArgs.entry.contentType
     );
     if (isEntryInRelease) {
-      throw new utils.errors.ValidationError(
+      throw new AlreadyOnReleaseError(
         `Entry with id ${releaseActionArgs.entry.id} and contentType ${releaseActionArgs.entry.contentType} already exists in release with id ${releaseId}`
       );
     }
@@ -869,15 +1254,25 @@ const createSchedulingService = ({ strapi: strapi2 }) => {
 const services = {
   release: createReleaseService,
   "release-validation": createReleaseValidationService,
-  ...strapi.features.future.isEnabled("contentReleasesScheduling") ? { scheduling: createSchedulingService } : {}
+  scheduling: createSchedulingService
 };
 const RELEASE_SCHEMA = yup__namespace.object().shape({
   name: yup__namespace.string().trim().required(),
-  // scheduledAt is a date, but we always receive strings from the client
   scheduledAt: yup__namespace.string().nullable(),
-  timezone: yup__namespace.string().when("scheduledAt", {
-    is: (scheduledAt) => !!scheduledAt,
-    then: yup__namespace.string().required(),
+  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();
@@ -912,7 +1307,12 @@ const releaseController = {
           }
         };
       });
-      ctx.body = { data, meta: { pagination } };
+      const pendingReleasesCount = await strapi.query(RELEASE_MODEL_UID).count({
+        where: {
+          releasedAt: null
+        }
+      });
+      ctx.body = { data, meta: { pagination, pendingReleasesCount } };
     }
   },
   async findOne(ctx) {
@@ -941,6 +1341,33 @@ const releaseController = {
     };
     ctx.body = { data };
   },
+  async mapEntriesToReleases(ctx) {
+    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.findManyWithContentTypeEntryAttached(
+      contentTypeUid,
+      entriesIds
+    );
+    const mappedEntriesInReleases = releasesWithActions.reduce(
+      (acc, release2) => {
+        release2.actions.forEach((action) => {
+          if (!acc[action.entry.id]) {
+            acc[action.entry.id] = [{ id: release2.id, name: release2.name }];
+          } else {
+            acc[action.entry.id].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;
@@ -1030,6 +1457,38 @@ const releaseActionController = {
       data: releaseAction2
     };
   },
+  async createMany(ctx) {
+    const releaseId = ctx.params.releaseId;
+    const releaseActionsArgs = ctx.request.body;
+    await Promise.all(
+      releaseActionsArgs.map((releaseActionArgs) => validateReleaseAction(releaseActionArgs))
+    );
+    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 releaseService.createAction(releaseId, releaseActionArgs);
+            return action;
+          } catch (error) {
+            if (error instanceof AlreadyOnReleaseError) {
+              return null;
+            }
+            throw error;
+          }
+        })
+      );
+      return releaseActions2;
+    });
+    const newReleaseActions = releaseActions.filter((action) => action !== null);
+    ctx.body = {
+      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({
@@ -1098,6 +1557,22 @@ const controllers = { release: releaseController, "release-action": releaseActio
 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: "POST",
       path: "/",
@@ -1215,6 +1690,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",
@@ -1283,6 +1774,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
   };
 };