@strapi/content-releases 0.0.0-next.e1ede8c55a0e1e22ce20137bf238fc374bd5dd51 → 0.0.0-next.f8af92b375dc730ba47ed2117f25df893aae696c

package/dist/server/index.js

@@ -1,6 +1,9 @@
 "use strict";
 const utils = require("@strapi/utils");
+const lodash = require("lodash");
 const _ = require("lodash/fp");
+const EE = require("@strapi/strapi/dist/utils/ee");
+const nodeSchedule = require("node-schedule");
 const yup = require("yup");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
@@ -22,6 +25,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 const ___default = /* @__PURE__ */ _interopDefault(_);
+const EE__default = /* @__PURE__ */ _interopDefault(EE);
 const yup__namespace = /* @__PURE__ */ _interopNamespace(yup);
 const RELEASE_MODEL_UID = "plugin::content-releases.release";
 const RELEASE_ACTION_MODEL_UID = "plugin::content-releases.release-action";
@@ -69,10 +73,114 @@ const ACTIONS = [
     pluginName: "content-releases"
   }
 ];
-const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
+const ALLOWED_WEBHOOK_EVENTS = {
+  RELEASES_PUBLISH: "releases.publish"
+};
+async function deleteActionsOnDisableDraftAndPublish({
+  oldContentTypes,
+  contentTypes: contentTypes2
+}) {
+  if (!oldContentTypes) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    if (utils.contentTypes.hasDraftAndPublish(oldContentType) && !utils.contentTypes.hasDraftAndPublish(contentType)) {
+      await strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: uid }).execute();
+    }
+  }
+}
+async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes: contentTypes2 }) {
+  const deletedContentTypes = lodash.difference(lodash.keys(oldContentTypes), lodash.keys(contentTypes2)) ?? [];
+  if (deletedContentTypes.length) {
+    await utils.mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
+      return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: deletedContentTypeUID }).execute();
+    });
+  }
+}
+const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
 const register = async ({ strapi: strapi2 }) => {
-  if (features$1.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
+  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);
+  }
+};
+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")) {
+    strapi2.db.lifecycles.subscribe({
+      afterDelete(event) {
+        const { model, result } = event;
+        if (model.kind === "collectionType" && model.options?.draftAndPublish) {
+          const { id } = result;
+          strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+            where: {
+              target_type: model.uid,
+              target_id: id
+            }
+          });
+        }
+      },
+      /**
+       * deleteMany hook doesn't return the deleted entries ids
+       * so we need to fetch them before deleting the entries to save the ids on our state
+       */
+      async beforeDeleteMany(event) {
+        const { model, params } = event;
+        if (model.kind === "collectionType" && model.options?.draftAndPublish) {
+          const { where } = params;
+          const entriesToDelete = await strapi2.db.query(model.uid).findMany({ select: ["id"], where });
+          event.state.entriesToDelete = entriesToDelete;
+        }
+      },
+      /**
+       * We delete the release actions related to deleted entries
+       * 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)
+              }
+            }
+          });
+        }
+      }
+    });
+    if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+      getService("scheduling", { strapi: strapi2 }).syncFromDatabase().catch((err) => {
+        strapi2.log.error(
+          "Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling."
+        );
+        throw err;
+      });
+      Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
+        strapi2.webhookStore.addAllowedEvent(key, value);
+      });
+    }
+  }
+};
+const 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 schema$1 = {
@@ -101,6 +209,12 @@ const schema$1 = {
     releasedAt: {
       type: "datetime"
     },
+    scheduledAt: {
+      type: "datetime"
+    },
+    timezone: {
+      type: "string"
+    },
     actions: {
       type: "relation",
       relation: "oneToMany",
@@ -163,327 +277,516 @@ const contentTypes = {
   release: release$1,
   "release-action": releaseAction$1
 };
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.plugin("content-releases").service(name);
-};
 const getGroupName = (queryValue) => {
   switch (queryValue) {
     case "contentType":
-      return "entry.contentType.displayName";
+      return "contentType.displayName";
     case "action":
       return "type";
     case "locale":
-      return ___default.default.getOr("No locale", "entry.locale.name");
+      return ___default.default.getOr("No locale", "locale.name");
     default:
-      return "entry.contentType.displayName";
+      return "contentType.displayName";
   }
 };
-const createReleaseService = ({ strapi: strapi2 }) => ({
-  async create(releaseData, { user }) {
-    const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
-    return 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
     });
-  },
-  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
-        }
+  };
+  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
+      });
+      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && releaseWithCreatorFields.scheduledAt) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        await schedulingService.set(release2.id, release2.scheduledAt);
       }
-    });
-  },
-  async findManyForContentTypeEntry(contentTypeUid, entryId, {
-    hasEntryAttached
-  } = {
-    hasEntryAttached: false
-  }) {
-    const whereActions = hasEntryAttached ? {
-      // Find all Releases where the content type entry is present
-      actions: {
-        target_type: contentTypeUid,
-        target_id: entryId
-      }
-    } : {
-      // Find all Releases where the content type entry is not present
-      $or: [
-        {
-          $not: {
-            actions: {
+      strapi2.telemetry.send("didCreateContentRelease");
+      return release2;
+    },
+    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, entryId) {
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          actions: {
+            target_type: contentTypeUid,
+            target_id: entryId
+          },
+          releasedAt: {
+            $null: true
+          }
+        },
+        populate: {
+          // Filter the action to get only the content type entry
+          actions: {
+            where: {
               target_type: contentTypeUid,
               target_id: entryId
             }
           }
-        },
-        {
-          actions: null
         }
-      ]
-    };
-    const populateAttachedAction = hasEntryAttached ? {
-      // Filter the action to get only the content type entry
-      actions: {
+      });
+      return releases.map((release2) => {
+        if (release2.actions?.length) {
+          const [actionForEntry] = release2.actions;
+          delete release2.actions;
+          return {
+            ...release2,
+            action: actionForEntry
+          };
+        }
+        return release2;
+      });
+    },
+    async findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId) {
+      const releasesRelated = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
         where: {
-          target_type: contentTypeUid,
-          target_id: entryId
+          releasedAt: {
+            $null: true
+          },
+          actions: {
+            target_type: contentTypeUid,
+            target_id: entryId
+          }
         }
-      }
-    } : {};
-    const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-      where: {
-        ...whereActions,
-        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
+          }
         }
-      },
-      populate: {
-        ...populateAttachedAction
+      });
+      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 updatedRelease = await utils.setCreatorFields({ user, isEdition: true })(releaseData);
-    const release2 = 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: updatedRelease
-    });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${id}`);
-    }
-    return release2;
-  },
-  async createAction(releaseId, action) {
-    const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
-      strapi: strapi2
-    });
-    await Promise.all([
-      validateEntryContentType(action.entry.contentType),
-      validateUniqueEntry(releaseId, action)
-    ]);
-    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: true
-      },
-      filters: {
-        release: releaseId
+      const updatedRelease = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
+        /*
+         * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">>
+         * is not compatible with the type we are passing here: UpdateRelease.Request['body']
+         */
+        // @ts-expect-error see above
+        data: releaseWithCreatorFields
+      });
+      if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        if (releaseData.scheduledAt) {
+          await schedulingService.set(id, releaseData.scheduledAt);
+        } else if (release2.scheduledAt) {
+          schedulingService.cancel(id);
+        }
       }
-    });
-  },
-  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);
+      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 allLocales = await strapi2.plugin("i18n").service("locales").find();
-    const allLocalesDictionary = allLocales.reduce((acc, locale) => {
-      acc[locale.code] = { name: locale.name, code: locale.code };
-      return acc;
-    }, {});
-    const formattedData = actions.map((action) => {
-      const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
-      return {
-        ...action,
-        entry: {
-          id: action.entry.id,
-          contentType: {
-            displayName,
-            mainFieldValue: action.entry[mainField]
+      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" }
           },
-          locale: action.locale ? allLocalesDictionary[action.locale] : null,
-          status: action.entry.publishedAt ? "published" : "draft"
-        }
-      };
-    });
-    const groupName = getGroupName(groupBy);
-    return ___default.default.groupBy(groupName)(formattedData);
-  },
-  async getContentTypesDataForActions(contentTypesUids) {
-    const contentManagerContentTypeService = strapi2.plugin("content-manager").service("content-types");
-    const contentTypesData = {};
-    for (const contentTypeUid of contentTypesUids) {
-      const contentTypeConfig = await contentManagerContentTypeService.findConfiguration({
-        uid: contentTypeUid
+          release: releaseId
+        },
+        populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
       });
-      contentTypesData[contentTypeUid] = {
-        mainField: contentTypeConfig.settings.mainField,
-        displayName: strapi2.getModel(contentTypeUid).info.displayName
-      };
-    }
-    return contentTypesData;
-  },
-  async delete(releaseId) {
-    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
-      populate: {
-        actions: {
-          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}`);
       }
-    });
-    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 strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
+        ...query,
+        populate: {
+          entry: {
+            populate: "*"
           }
+        },
+        filters: {
+          release: releaseId
         }
       });
-      await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
-    });
-    return release2;
-  },
-  async publish(releaseId) {
-    const releaseWithPopulatedActionEntries = await strapi2.entityService.findOne(
-      RELEASE_MODEL_UID,
-      releaseId,
-      {
+    },
+    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();
+      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: true
-            }
+            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 actions = {};
-    for (const action of releaseWithPopulatedActionEntries.actions) {
-      const contentTypeUid = action.contentType;
-      if (!actions[contentTypeUid]) {
-        actions[contentTypeUid] = {
-          publish: [],
-          unpublish: []
-        };
+      if (release2.releasedAt) {
+        throw new utils.errors.ValidationError("Release already published");
       }
-      if (action.type === "publish") {
-        actions[contentTypeUid].publish.push(action.entry);
-      } else {
-        actions[contentTypeUid].unpublish.push(action.entry);
+      await strapi2.db.transaction(async () => {
+        await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+          where: {
+            id: {
+              $in: release2.actions.map((action) => action.id)
+            }
+          }
+        });
+        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
+      });
+      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && release2.scheduledAt) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        await schedulingService.cancel(release2.id);
       }
-    }
-    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
-    await strapi2.db.transaction(async () => {
-      for (const contentTypeUid of Object.keys(actions)) {
-        const { publish, unpublish } = actions[contentTypeUid];
-        if (publish.length > 0) {
-          await entityManagerService.publishMany(publish, contentTypeUid);
+      strapi2.telemetry.send("didDeleteContentRelease");
+      return release2;
+    },
+    async publish(releaseId) {
+      try {
+        const releaseWithPopulatedActionEntries = await strapi2.entityService.findOne(
+          RELEASE_MODEL_UID,
+          releaseId,
+          {
+            populate: {
+              actions: {
+                populate: {
+                  entry: {
+                    fields: ["id"]
+                  }
+                }
+              }
+            }
+          }
+        );
+        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");
         }
-        if (unpublish.length > 0) {
-          await entityManagerService.unpublishMany(unpublish, contentTypeUid);
+        const collectionTypeActions = {};
+        const singleTypeActions = [];
+        for (const action of releaseWithPopulatedActionEntries.actions) {
+          const contentTypeUid = action.contentType;
+          if (strapi2.contentTypes[contentTypeUid].kind === "collectionType") {
+            if (!collectionTypeActions[contentTypeUid]) {
+              collectionTypeActions[contentTypeUid] = {
+                entriestoPublishIds: [],
+                entriesToUnpublishIds: []
+              };
+            }
+            if (action.type === "publish") {
+              collectionTypeActions[contentTypeUid].entriestoPublishIds.push(action.entry.id);
+            } else {
+              collectionTypeActions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
+            }
+          } else {
+            singleTypeActions.push({
+              uid: contentTypeUid,
+              action: action.type,
+              id: action.entry.id
+            });
+          }
         }
+        const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+        const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+        await strapi2.db.transaction(async () => {
+          for (const { uid, action, id } of singleTypeActions) {
+            const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+            const entry = await strapi2.entityService.findOne(uid, id, { populate });
+            try {
+              if (action === "publish") {
+                await entityManagerService.publish(entry, uid);
+              } else {
+                await entityManagerService.unpublish(entry, uid);
+              }
+            } catch (error) {
+              if (error instanceof utils.errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft")) {
+              } else {
+                throw error;
+              }
+            }
+          }
+          for (const contentTypeUid of Object.keys(collectionTypeActions)) {
+            const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
+            const { entriestoPublishIds, entriesToUnpublishIds } = collectionTypeActions[contentTypeUid];
+            const entriesToPublish = await strapi2.entityService.findMany(
+              contentTypeUid,
+              {
+                filters: {
+                  id: {
+                    $in: entriestoPublishIds
+                  }
+                },
+                populate
+              }
+            );
+            const entriesToUnpublish = await strapi2.entityService.findMany(
+              contentTypeUid,
+              {
+                filters: {
+                  id: {
+                    $in: entriesToUnpublishIds
+                  }
+                },
+                populate
+              }
+            );
+            if (entriesToPublish.length > 0) {
+              await entityManagerService.publishMany(entriesToPublish, contentTypeUid);
+            }
+            if (entriesToUnpublish.length > 0) {
+              await entityManagerService.unpublishMany(entriesToUnpublish, contentTypeUid);
+            }
+          }
+        });
+        const release2 = await strapi2.entityService.update(RELEASE_MODEL_UID, releaseId, {
+          data: {
+            /*
+             * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">> looks like it's wrong
+             */
+            // @ts-expect-error see above
+            releasedAt: /* @__PURE__ */ new Date()
+          },
+          populate: {
+            actions: {
+              // @ts-expect-error is not expecting count but it is working
+              count: true
+            }
+          }
+        });
+        if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+          dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+            isPublished: true,
+            release: release2
+          });
+        }
+        strapi2.telemetry.send("didPublishContentRelease");
+        return release2;
+      } catch (error) {
+        if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+          dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
+            isPublished: false,
+            error
+          });
+        }
+        throw error;
       }
-    });
-    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()
+    },
+    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`
+        );
       }
-    });
-    return release2;
-  },
-  async updateAction(actionId, releaseId, update) {
-    const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
-      where: {
-        id: actionId,
-        release: releaseId
-      },
-      data: update
-    });
-    if (!updatedAction) {
-      throw new utils.errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId}`
-      );
-    }
-    return updatedAction;
-  },
-  async deleteAction(actionId, releaseId) {
-    const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
-      where: {
-        id: actionId,
-        release: releaseId
+      return updatedAction;
+    },
+    async deleteAction(actionId, releaseId) {
+      const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
+        where: {
+          id: actionId,
+          release: {
+            id: releaseId,
+            releasedAt: {
+              $null: true
+            }
+          }
+        }
+      });
+      if (!deletedAction) {
+        throw new utils.errors.NotFoundError(
+          `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
+        );
       }
-    });
-    if (!deletedAction) {
-      throw new utils.errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId}`
-      );
+      return deletedAction;
     }
-    return deletedAction;
-  }
-});
+  };
+};
 const createReleaseValidationService = ({ strapi: strapi2 }) => ({
   async validateUniqueEntry(releaseId, releaseActionArgs) {
     const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
@@ -511,11 +814,120 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
         `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`
       );
     }
+  },
+  async validatePendingReleasesLimit() {
+    const maximumPendingReleases = (
+      // @ts-expect-error - options is not typed into features
+      EE__default.default.features.get("cms-content-releases")?.options?.maximumReleases || 3
+    );
+    const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
+      filters: {
+        releasedAt: {
+          $null: true
+        }
+      }
+    });
+    if (pendingReleasesCount >= maximumPendingReleases) {
+      throw new utils.errors.ValidationError("You have reached the maximum number of pending releases");
+    }
+  },
+  async validateUniqueNameForPendingRelease(name, id) {
+    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
+      filters: {
+        releasedAt: {
+          $null: true
+        },
+        name,
+        ...id && { id: { $ne: id } }
+      }
+    });
+    const isNameUnique = pendingReleases.length === 0;
+    if (!isNameUnique) {
+      throw new utils.errors.ValidationError(`Release with name ${name} already exists`);
+    }
+  },
+  async validateScheduledAtIsLaterThanNow(scheduledAt) {
+    if (scheduledAt && new Date(scheduledAt) <= /* @__PURE__ */ new Date()) {
+      throw new utils.errors.ValidationError("Scheduled at must be later than now");
+    }
   }
 });
-const services = { release: createReleaseService, "release-validation": createReleaseValidationService };
+const createSchedulingService = ({ strapi: strapi2 }) => {
+  const scheduledJobs = /* @__PURE__ */ new Map();
+  return {
+    async set(releaseId, scheduleDate) {
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: releaseId, releasedAt: null } });
+      if (!release2) {
+        throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      const job = nodeSchedule.scheduleJob(scheduleDate, async () => {
+        try {
+          await getService("release").publish(releaseId);
+        } catch (error) {
+        }
+        this.cancel(releaseId);
+      });
+      if (scheduledJobs.has(releaseId)) {
+        this.cancel(releaseId);
+      }
+      scheduledJobs.set(releaseId, job);
+      return scheduledJobs;
+    },
+    cancel(releaseId) {
+      if (scheduledJobs.has(releaseId)) {
+        scheduledJobs.get(releaseId).cancel();
+        scheduledJobs.delete(releaseId);
+      }
+      return scheduledJobs;
+    },
+    getAll() {
+      return scheduledJobs;
+    },
+    /**
+     * On bootstrap, we can use this function to make sure to sync the scheduled jobs from the database that are not yet released
+     * This is useful in case the server was restarted and the scheduled jobs were lost
+     * This also could be used to sync different Strapi instances in case of a cluster
+     */
+    async syncFromDatabase() {
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          scheduledAt: {
+            $gte: /* @__PURE__ */ new Date()
+          },
+          releasedAt: null
+        }
+      });
+      for (const release2 of releases) {
+        this.set(release2.id, release2.scheduledAt);
+      }
+      return scheduledJobs;
+    }
+  };
+};
+const services = {
+  release: createReleaseService,
+  "release-validation": createReleaseValidationService,
+  ...strapi.features.future.isEnabled("contentReleasesScheduling") ? { scheduling: createSchedulingService } : {}
+};
 const RELEASE_SCHEMA = yup__namespace.object().shape({
-  name: yup__namespace.string().trim().required()
+  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 validateRelease = utils.validateYupSchema(RELEASE_SCHEMA);
 const releaseController = {
@@ -532,9 +944,7 @@ const releaseController = {
       const contentTypeUid = query.contentTypeUid;
       const entryId = query.entryId;
       const hasEntryAttached = typeof query.hasEntryAttached === "string" ? JSON.parse(query.hasEntryAttached) : false;
-      const data = await releaseService.findManyForContentTypeEntry(contentTypeUid, entryId, {
-        hasEntryAttached
-      });
+      const data = hasEntryAttached ? await releaseService.findManyWithContentTypeEntryAttached(contentTypeUid, entryId) : await releaseService.findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId);
       ctx.body = { data };
     } else {
       const query = await permissionsManager.sanitizeQuery(ctx.query);
@@ -557,19 +967,18 @@ const releaseController = {
     const id = ctx.params.id;
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.findOne(id, { populate: ["createdBy"] });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: RELEASE_MODEL_UID
-    });
-    const sanitizedRelease = await permissionsManager.sanitizeOutput(release2);
+    if (!release2) {
+      throw new utils.errors.NotFoundError(`Release not found for id: ${id}`);
+    }
     const count = await releaseService.countActions({
       filters: {
         release: id
       }
     });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`Release not found for id: ${id}`);
-    }
+    const sanitizedRelease = {
+      ...release2,
+      createdBy: release2.createdBy ? strapi.admin.services.user.sanitizeUser(release2.createdBy) : null
+    };
     const data = {
       ...sanitizedRelease,
       actions: {
@@ -622,8 +1031,27 @@ const releaseController = {
     const id = ctx.params.id;
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.publish(id, { user });
+    const [countPublishActions, countUnpublishActions] = await Promise.all([
+      releaseService.countActions({
+        filters: {
+          release: id,
+          type: "publish"
+        }
+      }),
+      releaseService.countActions({
+        filters: {
+          release: id,
+          type: "unpublish"
+        }
+      })
+    ]);
     ctx.body = {
-      data: release2
+      data: release2,
+      meta: {
+        totalEntries: countPublishActions + countUnpublishActions,
+        totalPublishedEntries: countPublishActions,
+        totalUnpublishedEntries: countUnpublishActions
+      }
     };
   }
 };
@@ -662,11 +1090,30 @@ const releaseActionController = {
       sort: query.groupBy === "action" ? "type" : query.groupBy,
       ...query
     });
-    const groupedData = await releaseService.groupActions(results, query.groupBy);
+    const contentTypeOutputSanitizers = results.reduce((acc, action) => {
+      if (acc[action.contentType]) {
+        return acc;
+      }
+      const contentTypePermissionsManager = strapi.admin.services.permission.createPermissionsManager({
+        ability: ctx.state.userAbility,
+        model: action.contentType
+      });
+      acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
+      return acc;
+    }, {});
+    const sanitizedResults = await utils.mapAsync(results, async (action) => ({
+      ...action,
+      entry: await contentTypeOutputSanitizers[action.contentType](action.entry)
+    }));
+    const groupedData = await releaseService.groupActions(sanitizedResults, query.groupBy);
+    const contentTypes2 = releaseService.getContentTypeModelsFromActions(results);
+    const components = await releaseService.getAllComponents();
     ctx.body = {
       data: groupedData,
       meta: {
-        pagination
+        pagination,
+        contentTypes: contentTypes2,
+        components
       }
     };
   },
@@ -688,10 +1135,8 @@ const releaseActionController = {
   async delete(ctx) {
     const actionId = ctx.params.actionId;
     const releaseId = ctx.params.releaseId;
-    const deletedReleaseAction = await getService("release", { strapi }).deleteAction(
-      actionId,
-      releaseId
-    );
+    const releaseService = getService("release", { strapi });
+    const deletedReleaseAction = await releaseService.deleteAction(actionId, releaseId);
     ctx.body = {
       data: deletedReleaseAction
     };
@@ -874,9 +1319,11 @@ const routes = {
 };
 const { features } = require("@strapi/strapi/dist/utils/ee");
 const getPlugin = () => {
-  if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
+  if (features.isEnabled("cms-content-releases")) {
     return {
       register,
+      bootstrap,
+      destroy,
       contentTypes,
       services,
       controllers,