@strapi/content-releases 0.0.0-experimental.950b677f6614f483cde77801d941607d6847a6e3 → 0.0.0-experimental.cae3a5a17d131a6f59673b62d01cfac869ea9cc2

package/dist/admin/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

package/dist/admin/index.mjs

@@ -1,4 +1,4 @@
-import { j } from "../_chunks/index-6ddf4a38.mjs";
+import { k } from "../_chunks/index-bsuc8ZwZ.mjs";
 import "@strapi/helper-plugin";
 import "@strapi/icons";
 import "react/jsx-runtime";
@@ -13,7 +13,8 @@ import "react-router-dom";
 import "yup";
 import "@reduxjs/toolkit/query/react";
 import "styled-components";
+import "react-redux";
 export {
-  j as default
+  k as default
 };
 //# sourceMappingURL=index.mjs.map

package/dist/admin/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/server/index.js

@@ -1,6 +1,10 @@
 "use strict";
 const utils = require("@strapi/utils");
+const lodash = require("lodash");
+const _ = require("lodash/fp");
+const EE = require("@strapi/strapi/dist/utils/ee");
 const yup = require("yup");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
   if (e && e.__esModule)
     return e;
@@ -19,6 +23,8 @@ function _interopNamespace(e) {
   n.default = 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";
@@ -66,10 +72,87 @@ const ACTIONS = [
     pluginName: "content-releases"
   }
 ];
-const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
+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 { 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)
+              }
+            }
+          });
+        }
+      }
+    });
   }
 };
 const schema$1 = {
@@ -142,6 +225,9 @@ const schema = {
       type: "string",
       required: true
     },
+    locale: {
+      type: "string"
+    },
     release: {
       type: "relation",
       relation: "manyToOne",
@@ -160,9 +246,29 @@ const contentTypes = {
 const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
   return strapi2.plugin("content-releases").service(name);
 };
+const getGroupName = (queryValue) => {
+  switch (queryValue) {
+    case "contentType":
+      return "contentType.displayName";
+    case "action":
+      return "type";
+    case "locale":
+      return ___default.default.getOr("No locale", "locale.name");
+    default:
+      return "contentType.displayName";
+  }
+};
 const createReleaseService = ({ strapi: strapi2 }) => ({
   async create(releaseData, { user }) {
     const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
+    const { validatePendingReleasesLimit, validateUniqueNameForPendingRelease } = getService(
+      "release-validation",
+      { strapi: strapi2 }
+    );
+    await Promise.all([
+      validatePendingReleasesLimit(),
+      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name)
+    ]);
     return strapi2.entityService.create(RELEASE_MODEL_UID, {
       data: releaseWithCreatorFields
     });
@@ -184,51 +290,66 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       }
     });
   },
-  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: {
-              target_type: contentTypeUid,
-              target_id: entryId
-            }
-          }
+  async findManyWithContentTypeEntryAttached(contentTypeUid, entryId) {
+    const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+      where: {
+        actions: {
+          target_type: contentTypeUid,
+          target_id: entryId
         },
-        {
-          actions: null
+        releasedAt: {
+          $null: true
         }
-      ]
-    };
-    const populateAttachedAction = hasEntryAttached ? {
-      // Filter the action to get only the content type entry
-      actions: {
-        where: {
+      },
+      populate: {
+        // Filter the action to get only the content type entry
+        actions: {
+          where: {
+            target_type: contentTypeUid,
+            target_id: entryId
+          }
+        }
+      }
+    });
+    return releases.map((release2) => {
+      if (release2.actions?.length) {
+        const [actionForEntry] = release2.actions;
+        delete release2.actions;
+        return {
+          ...release2,
+          action: actionForEntry
+        };
+      }
+      return release2;
+    });
+  },
+  async findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId) {
+    const releasesRelated = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+      where: {
+        releasedAt: {
+          $null: true
+        },
+        actions: {
           target_type: contentTypeUid,
           target_id: entryId
         }
       }
-    } : {};
+    });
     const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
       where: {
-        ...whereActions,
+        $or: [
+          {
+            id: {
+              $notIn: releasesRelated.map((release2) => release2.id)
+            }
+          },
+          {
+            actions: null
+          }
+        ],
         releasedAt: {
           $null: true
         }
-      },
-      populate: {
-        ...populateAttachedAction
       }
     });
     return releases.map((release2) => {
@@ -244,19 +365,23 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     });
   },
   async update(id, releaseData, { user }) {
-    const updatedRelease = await utils.setCreatorFields({ user, isEdition: true })(releaseData);
-    const release2 = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
+    const releaseWithCreatorFields = await utils.setCreatorFields({ user, isEdition: true })(releaseData);
+    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
+    if (!release2) {
+      throw new utils.errors.NotFoundError(`No release found for id ${id}`);
+    }
+    if (release2.releasedAt) {
+      throw new utils.errors.ValidationError("Release already published");
+    }
+    const updatedRelease = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
       /*
        * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">>
        * is not compatible with the type we are passing here: UpdateRelease.Request['body']
        */
       // @ts-expect-error see above
-      data: updatedRelease
+      data: releaseWithCreatorFields
     });
-    if (!release2) {
-      throw new utils.errors.NotFoundError(`No release found for id ${id}`);
-    }
-    return release2;
+    return updatedRelease;
   },
   async createAction(releaseId, action) {
     const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
@@ -266,11 +391,19 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       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,
@@ -282,14 +415,18 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     });
   },
   async findActions(releaseId, query) {
-    const result = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
-    if (!result) {
+    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
+        entry: {
+          populate: "*"
+        }
       },
       filters: {
         release: releaseId
@@ -299,18 +436,43 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
   async countActions(query) {
     return strapi2.entityService.count(RELEASE_ACTION_MODEL_UID, query);
   },
-  async getAllContentTypeUids(releaseId) {
-    const contentTypesFromReleaseActions = await strapi2.db.queryBuilder(RELEASE_ACTION_MODEL_UID).select("content_type").where({
-      $and: [
-        {
-          release: releaseId
+  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
         }
-      ]
-    }).groupBy("content_type").execute();
-    return contentTypesFromReleaseActions.map(({ contentType: contentTypeUid }) => contentTypeUid);
+      };
+    });
+    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(releaseId) {
-    const contentTypesUids = await this.getAllContentTypeUids(releaseId);
+  async getContentTypesDataForActions(contentTypesUids) {
     const contentManagerContentTypeService = strapi2.plugin("content-manager").service("content-types");
     const contentTypesData = {};
     for (const contentTypeUid of contentTypesUids) {
@@ -324,6 +486,34 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     }
     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: {
@@ -358,7 +548,9 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
         populate: {
           actions: {
             populate: {
-              entry: true
+              entry: {
+                fields: ["id"]
+              }
             }
           }
         }
@@ -378,25 +570,49 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       const contentTypeUid = action.contentType;
       if (!actions[contentTypeUid]) {
         actions[contentTypeUid] = {
-          publish: [],
-          unpublish: []
+          entriestoPublishIds: [],
+          entriesToUnpublishIds: []
         };
       }
       if (action.type === "publish") {
-        actions[contentTypeUid].publish.push(action.entry);
+        actions[contentTypeUid].entriestoPublishIds.push(action.entry.id);
       } else {
-        actions[contentTypeUid].unpublish.push(action.entry);
+        actions[contentTypeUid].entriesToUnpublishIds.push(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 contentTypeUid of Object.keys(actions)) {
-        const { publish, unpublish } = actions[contentTypeUid];
-        if (publish.length > 0) {
-          await entityManagerService.publishMany(publish, contentTypeUid);
+        const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
+        const { entriestoPublishIds, entriesToUnpublishIds } = actions[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 (unpublish.length > 0) {
-          await entityManagerService.unpublishMany(unpublish, contentTypeUid);
+        if (entriesToUnpublish.length > 0) {
+          await entityManagerService.unpublishMany(entriesToUnpublish, contentTypeUid);
         }
       }
     });
@@ -415,13 +631,18 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
       where: {
         id: actionId,
-        release: releaseId
+        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}`
+        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
       );
     }
     return updatedAction;
@@ -430,12 +651,17 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
       where: {
         id: actionId,
-        release: releaseId
+        release: {
+          id: releaseId,
+          releasedAt: {
+            $null: true
+          }
+        }
       }
     });
     if (!deletedAction) {
       throw new utils.errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId}`
+        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
       );
     }
     return deletedAction;
@@ -468,9 +694,42 @@ 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) {
+    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
+      filters: {
+        releasedAt: {
+          $null: true
+        },
+        name
+      }
+    });
+    const isNameUnique = pendingReleases.length === 0;
+    if (!isNameUnique) {
+      throw new utils.errors.ValidationError(`Release with name ${name} already exists`);
+    }
   }
 });
-const services = { release: createReleaseService, "release-validation": createReleaseValidationService };
+const services = {
+  release: createReleaseService,
+  "release-validation": createReleaseValidationService
+};
 const RELEASE_SCHEMA = yup__namespace.object().shape({
   name: yup__namespace.string().trim().required()
 }).required().noUnknown();
@@ -489,9 +748,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);
@@ -615,33 +872,34 @@ const releaseActionController = {
     });
     const query = await permissionsManager.sanitizeQuery(ctx.query);
     const releaseService = getService("release", { strapi });
-    const { results, pagination } = await releaseService.findActions(releaseId, query);
-    const allReleaseContentTypesDictionary = await releaseService.getContentTypesDataForActions(
-      releaseId
-    );
-    const allLocales = await strapi.plugin("i18n").service("locales").find();
-    const allLocalesDictionary = allLocales.reduce((acc, locale) => {
-      acc[locale.code] = { name: locale.name, code: locale.code };
+    const { results, pagination } = await releaseService.findActions(releaseId, {
+      sort: query.groupBy === "action" ? "type" : query.groupBy,
+      ...query
+    });
+    const contentTypeOutputSanitizers = results.reduce((acc, action) => {
+      if (acc[action.contentType]) {
+        return acc;
+      }
+      const contentTypePermissionsManager = strapi.admin.services.permission.createPermissionsManager({
+        ability: ctx.state.userAbility,
+        model: action.contentType
+      });
+      acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
       return acc;
     }, {});
-    const data = results.map((action) => {
-      const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
-      return {
-        ...action,
-        entry: {
-          id: action.entry.id,
-          contentType: {
-            displayName,
-            mainFieldValue: action.entry[mainField]
-          },
-          locale: allLocalesDictionary[action.entry.locale]
-        }
-      };
-    });
+    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,
+      data: groupedData,
       meta: {
-        pagination
+        pagination,
+        contentTypes: contentTypes2,
+        components
       }
     };
   },
@@ -663,10 +921,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
     };
@@ -849,9 +1105,10 @@ 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,
       contentTypes,
       services,
       controllers,