@strapi/content-releases 0.0.0-experimental.e576af447d9f97e89e24c6daa32d8f714376cd5f → 0.0.0-experimental.e86ac7192458208dc921b643405f97aeba7cccb9

package/dist/server/index.mjs

@@ -1,2332 +1,1770 @@
-import { contentTypes as contentTypes$1, async, setCreatorFields, errors, yup as yup$1, validateYupSchema } from '@strapi/utils';
-import isEqual from 'lodash/isEqual';
-import { difference, keys } from 'lodash';
-import _ from 'lodash/fp';
-import { scheduleJob } from 'node-schedule';
-import * as yup from 'yup';
-
-const RELEASE_MODEL_UID = 'plugin::content-releases.release';
-const RELEASE_ACTION_MODEL_UID = 'plugin::content-releases.release-action';
+import { contentTypes as contentTypes$1, mapAsync, setCreatorFields, errors, validateYupSchema, yup as yup$1 } from "@strapi/utils";
+import isEqual from "lodash/isEqual";
+import { difference, keys } from "lodash";
+import _ from "lodash/fp";
+import EE from "@strapi/strapi/dist/utils/ee";
+import { scheduleJob } from "node-schedule";
+import * as yup from "yup";
+const RELEASE_MODEL_UID = "plugin::content-releases.release";
+const RELEASE_ACTION_MODEL_UID = "plugin::content-releases.release-action";
 const ACTIONS = [
-    {
-        section: 'plugins',
-        displayName: 'Read',
-        uid: 'read',
-        pluginName: 'content-releases'
-    },
-    {
-        section: 'plugins',
-        displayName: 'Create',
-        uid: 'create',
-        pluginName: 'content-releases'
-    },
-    {
-        section: 'plugins',
-        displayName: 'Edit',
-        uid: 'update',
-        pluginName: 'content-releases'
-    },
-    {
-        section: 'plugins',
-        displayName: 'Delete',
-        uid: 'delete',
-        pluginName: 'content-releases'
-    },
-    {
-        section: 'plugins',
-        displayName: 'Publish',
-        uid: 'publish',
-        pluginName: 'content-releases'
-    },
-    {
-        section: 'plugins',
-        displayName: 'Remove an entry from a release',
-        uid: 'delete-action',
-        pluginName: 'content-releases'
-    },
-    {
-        section: 'plugins',
-        displayName: 'Add an entry to a release',
-        uid: 'create-action',
-        pluginName: 'content-releases'
-    },
-    // Settings
-    {
-        uid: 'settings.read',
-        section: 'settings',
-        displayName: 'Read',
-        category: 'content releases',
-        subCategory: 'options',
-        pluginName: 'content-releases'
-    },
-    {
-        uid: 'settings.update',
-        section: 'settings',
-        displayName: 'Edit',
-        category: 'content releases',
-        subCategory: 'options',
-        pluginName: 'content-releases'
-    }
+  {
+    section: "plugins",
+    displayName: "Read",
+    uid: "read",
+    pluginName: "content-releases"
+  },
+  {
+    section: "plugins",
+    displayName: "Create",
+    uid: "create",
+    pluginName: "content-releases"
+  },
+  {
+    section: "plugins",
+    displayName: "Edit",
+    uid: "update",
+    pluginName: "content-releases"
+  },
+  {
+    section: "plugins",
+    displayName: "Delete",
+    uid: "delete",
+    pluginName: "content-releases"
+  },
+  {
+    section: "plugins",
+    displayName: "Publish",
+    uid: "publish",
+    pluginName: "content-releases"
+  },
+  {
+    section: "plugins",
+    displayName: "Remove an entry from a release",
+    uid: "delete-action",
+    pluginName: "content-releases"
+  },
+  {
+    section: "plugins",
+    displayName: "Add an entry to a release",
+    uid: "create-action",
+    pluginName: "content-releases"
+  }
 ];
 const ALLOWED_WEBHOOK_EVENTS = {
-    RELEASES_PUBLISH: 'releases.publish'
-};
-
-const getService = (name, { strapi: strapi1 })=>{
-    return strapi1.plugin('content-releases').service(name);
-};
-const getDraftEntryValidStatus = async ({ contentType, documentId, locale }, { strapi: strapi1 })=>{
-    const populateBuilderService = strapi1.plugin('content-manager').service('populate-builder');
-    // @ts-expect-error - populateBuilderService should be a function but is returning service
-    const populate = await populateBuilderService(contentType).populateDeep(Infinity).build();
-    const entry = await getEntry({
-        contentType,
-        documentId,
-        locale,
-        populate
-    }, {
-        strapi: strapi1
-    });
-    return isEntryValid(contentType, entry, {
-        strapi: strapi1
-    });
+  RELEASES_PUBLISH: "releases.publish"
 };
-const isEntryValid = async (contentTypeUid, entry, { strapi: strapi1 })=>{
-    try {
-        // @TODO: When documents service has validateEntityCreation method, use it instead
-        await strapi1.entityValidator.validateEntityCreation(strapi1.getModel(contentTypeUid), entry, undefined, // @ts-expect-error - FIXME: entity here is unnecessary
-        entry);
-        const workflowsService = strapi1.plugin('review-workflows').service('workflows');
-        const workflow = await workflowsService.getAssignedWorkflow(contentTypeUid, {
-            populate: 'stageRequiredToPublish'
-        });
-        if (workflow?.stageRequiredToPublish) {
-            return entry.strapi_stage.id === workflow.stageRequiredToPublish.id;
-        }
-        return true;
-    } catch  {
-        return false;
-    }
+const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  return strapi2.plugin("content-releases").service(name);
 };
-const getEntry = async ({ contentType, documentId, locale, populate, status = 'draft' }, { strapi: strapi1 })=>{
-    if (documentId) {
-        // Try to get an existing draft or published document
-        const entry = await strapi1.documents(contentType).findOne({
-            documentId,
-            locale,
-            populate,
-            status
-        });
-        // The document isn't published yet, but the action is to publish it, fetch the draft
-        if (status === 'published' && !entry) {
-            return strapi1.documents(contentType).findOne({
-                documentId,
-                locale,
-                populate,
-                status: 'draft'
-            });
-        }
-        return entry;
-    }
-    return strapi1.documents(contentType).findFirst({
-        locale,
-        populate,
-        status
-    });
+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 getEntryStatus = async (contentType, entry)=>{
-    if (entry.publishedAt) {
-        return 'published';
-    }
-    const publishedEntry = await strapi.documents(contentType).findOne({
-        documentId: entry.documentId,
-        locale: entry.locale,
-        status: 'published',
-        fields: [
-            'updatedAt'
-        ]
-    });
-    if (!publishedEntry) {
-        return 'draft';
-    }
-    const entryUpdatedAt = new Date(entry.updatedAt).getTime();
-    const publishedEntryUpdatedAt = new Date(publishedEntry.updatedAt).getTime();
-    if (entryUpdatedAt > publishedEntryUpdatedAt) {
-        return 'modified';
-    }
-    return 'published';
+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 }) {
-    if (!oldContentTypes) {
-        return;
+async function deleteActionsOnDisableDraftAndPublish({
+  oldContentTypes,
+  contentTypes: contentTypes2
+}) {
+  if (!oldContentTypes) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
     }
-    for(const uid in contentTypes){
-        if (!oldContentTypes[uid]) {
-            continue;
-        }
-        const oldContentType = oldContentTypes[uid];
-        const contentType = contentTypes[uid];
-        if (contentTypes$1.hasDraftAndPublish(oldContentType) && !contentTypes$1.hasDraftAndPublish(contentType)) {
-            await strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({
-                contentType: uid
-            }).execute();
-        }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    if (contentTypes$1.hasDraftAndPublish(oldContentType) && !contentTypes$1.hasDraftAndPublish(contentType)) {
+      await strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: uid }).execute();
     }
+  }
 }
-async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes }) {
-    const deletedContentTypes = difference(keys(oldContentTypes), keys(contentTypes)) ?? [];
-    if (deletedContentTypes.length) {
-        await async.map(deletedContentTypes, async (deletedContentTypeUID)=>{
-            return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({
-                contentType: deletedContentTypeUID
-            }).execute();
-        });
-    }
+async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes: contentTypes2 }) {
+  const deletedContentTypes = difference(keys(oldContentTypes), keys(contentTypes2)) ?? [];
+  if (deletedContentTypes.length) {
+    await mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
+      return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: deletedContentTypeUID }).execute();
+    });
+  }
 }
 async function migrateIsValidAndStatusReleases() {
-    const releasesWithoutStatus = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-            status: null,
-            releasedAt: null
-        },
+  const releasesWithoutStatus = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+    where: {
+      status: null,
+      releasedAt: null
+    },
+    populate: {
+      actions: {
         populate: {
-            actions: {
-                populate: {
-                    entry: true
-                }
-            }
-        }
-    });
-    async.map(releasesWithoutStatus, async (release)=>{
-        const actions = release.actions;
-        const notValidatedActions = actions.filter((action)=>action.isEntryValid === null);
-        for (const action of notValidatedActions){
-            // We need to check the Action is related to a valid entry because we can't assume this is gonna be always the case
-            // example: users could make changes directly to their database, or data could be lost
-            if (action.entry) {
-                const isEntryValid = getDraftEntryValidStatus({
-                    contentType: action.contentType,
-                    documentId: action.entryDocumentId,
-                    locale: action.locale
-                }, {
-                    strapi
-                });
-                await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-                    where: {
-                        id: action.id
-                    },
-                    data: {
-                        isEntryValid
-                    }
-                });
-            }
-        }
-        return getService('release', {
-            strapi
-        }).updateReleaseStatus(release.id);
-    });
-    const publishedReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-            status: null,
-            releasedAt: {
-                $notNull: true
-            }
+          entry: true
         }
-    });
-    async.map(publishedReleases, async (release)=>{
-        return strapi.db.query(RELEASE_MODEL_UID).update({
+      }
+    }
+  });
+  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: release.id
+              id: action.id
             },
             data: {
-                status: 'done'
+              isEntryValid
             }
-        });
+          });
+        }
+      }
+    }
+    return getService("release", { strapi }).updateReleaseStatus(release2.id);
+  });
+  const publishedReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+    where: {
+      status: null,
+      releasedAt: {
+        $notNull: true
+      }
+    }
+  });
+  mapAsync(publishedReleases, async (release2) => {
+    return strapi.db.query(RELEASE_MODEL_UID).update({
+      where: {
+        id: release2.id
+      },
+      data: {
+        status: "done"
+      }
     });
+  });
 }
-async function revalidateChangedContentTypes({ oldContentTypes, contentTypes }) {
-    if (oldContentTypes !== undefined && contentTypes !== undefined) {
-        const contentTypesWithDraftAndPublish = Object.keys(oldContentTypes).filter((uid)=>oldContentTypes[uid]?.options?.draftAndPublish);
-        const releasesAffected = new Set();
-        async.map(contentTypesWithDraftAndPublish, async (contentTypeUID)=>{
-            const oldContentType = oldContentTypes[contentTypeUID];
-            const contentType = contentTypes[contentTypeUID];
-            // If attributes have changed, we need to revalidate actions because maybe validations rules are different
-            if (!isEqual(oldContentType?.attributes, contentType?.attributes)) {
-                const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
-                    where: {
-                        contentType: contentTypeUID
-                    },
-                    populate: {
-                        entry: true,
-                        release: true
-                    }
-                });
-                await async.map(actions, async (action)=>{
-                    if (action.entry && action.release && action.type === 'publish') {
-                        const isEntryValid = await getDraftEntryValidStatus({
-                            contentType: contentTypeUID,
-                            documentId: action.entryDocumentId,
-                            locale: action.locale
-                        }, {
-                            strapi
-                        });
-                        releasesAffected.add(action.release.id);
-                        await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-                            where: {
-                                id: action.id
-                            },
-                            data: {
-                                isEntryValid
-                            }
-                        });
-                    }
-                });
-            }
-        }).then(()=>{
-            // We need to update the status of the releases affected
-            async.map(releasesAffected, async (releaseId)=>{
-                return getService('release', {
-                    strapi
-                }).updateReleaseStatus(releaseId);
+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();
+    mapAsync(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
+      const oldContentType = oldContentTypes[contentTypeUID];
+      const contentType = contentTypes2[contentTypeUID];
+      if (!isEqual(oldContentType?.attributes, contentType?.attributes)) {
+        const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+          where: {
+            contentType: contentTypeUID
+          },
+          populate: {
+            entry: true,
+            release: true
+          }
+        });
+        await 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(() => {
+      mapAsync(releasesAffected, async (releaseId) => {
+        return getService("release", { strapi }).updateReleaseStatus(releaseId);
+      });
+    });
+  }
 }
-async function disableContentTypeLocalized({ oldContentTypes, contentTypes }) {
-    if (!oldContentTypes) {
-        return;
+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 i18nPlugin = strapi.plugin('i18n');
-    if (!i18nPlugin) {
-        return;
-    }
-    for(const uid in contentTypes){
-        if (!oldContentTypes[uid]) {
-            continue;
-        }
-        const oldContentType = oldContentTypes[uid];
-        const contentType = contentTypes[uid];
-        const { isLocalizedContentType } = i18nPlugin.service('content-types');
-        // if i18N is disabled remove non default locales before sync
-        if (isLocalizedContentType(oldContentType) && !isLocalizedContentType(contentType)) {
-            await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
-                locale: null
-            }).where({
-                contentType: uid
-            }).execute();
-        }
+    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 }) {
-    if (!oldContentTypes) {
-        return;
-    }
-    const i18nPlugin = strapi.plugin('i18n');
-    if (!i18nPlugin) {
-        return;
+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;
     }
-    for(const uid in contentTypes){
-        if (!oldContentTypes[uid]) {
-            continue;
-        }
-        const oldContentType = oldContentTypes[uid];
-        const contentType = contentTypes[uid];
-        const { isLocalizedContentType } = i18nPlugin.service('content-types');
-        const { getDefaultLocale } = i18nPlugin.service('locales');
-        // if i18N is enabled remove non default locales before sync
-        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 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();
     }
+  }
 }
-
-/**
- * On v4, release actions are linked with entries using the built in Polymorphic relations.
- *
- * On v5, we are going to save entryDocumentId on the release action and make the link manually.
- * This because entryId is not a reliable way to link documents, as it can change.
- */ const addEntryDocumentToReleaseActions = {
-    name: 'content-releases::5.0.0-add-entry-document-id-to-release-actions',
-    async up (trx, db) {
-        // Check if the table exists
-        const hasTable = await trx.schema.hasTable('strapi_release_actions');
-        if (!hasTable) {
-            return;
-        }
-        const hasPolymorphicColumn = await trx.schema.hasColumn('strapi_release_actions', 'target_id');
-        // If user has PolymorphicColumn means that is coming from v4
-        if (hasPolymorphicColumn) {
-            // First time coming from v4 user doesn't have entryDocumentId
-            // but we double check to avoid errors
-            const hasEntryDocumentIdColumn = await trx.schema.hasColumn('strapi_release_actions', 'entry_document_id');
-            if (!hasEntryDocumentIdColumn) {
-                await trx.schema.alterTable('strapi_release_actions', (table)=>{
-                    table.string('entry_document_id');
-                });
+const { 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).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 { 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({
+      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);
             }
-            const releaseActions = await trx.select('*').from('strapi_release_actions');
-            async.map(releaseActions, async (action)=>{
-                const { target_type, target_id } = action;
-                const entry = await db.query(target_type).findOne({
-                    where: {
-                        id: target_id
-                    }
-                });
-                if (entry) {
-                    await trx('strapi_release_actions').update({
-                        entry_document_id: entry.documentId
-                    }).where('id', action.id);
+          }
+        } catch (error) {
+          strapi2.log.error("Error while deleting release actions after entry delete", { error });
+        }
+      },
+      /**
+       * deleteMany hook doesn't return the deleted entries ids
+       * so we need to fetch them before deleting the entries to save the ids on our state
+       */
+      async beforeDeleteMany(event) {
+        const { model, params } = event;
+        if (model.kind === "collectionType" && model.options?.draftAndPublish) {
+          const { where } = params;
+          const entriesToDelete = await strapi2.db.query(model.uid).findMany({ select: ["id"], where });
+          event.state.entriesToDelete = entriesToDelete;
+        }
+      },
+      /**
+       * We delete the release actions related to deleted entries
+       * We make this only after deleteMany is succesfully executed to avoid errors
+       */
+      async afterDeleteMany(event) {
+        try {
+          const { model, state } = event;
+          const entriesToDelete = state.entriesToDelete;
+          if (entriesToDelete) {
+            const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+              where: {
+                actions: {
+                  target_type: model.uid,
+                  target_id: {
+                    $in: entriesToDelete.map(
+                      (entry) => entry.id
+                    )
+                  }
+                }
+              }
+            });
+            await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+              where: {
+                target_type: model.uid,
+                target_id: {
+                  $in: entriesToDelete.map((entry) => entry.id)
                 }
+              }
             });
+            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 down () {
-        throw new Error('not implemented');
-    }
-};
-
-const register = async ({ strapi })=>{
-    if (strapi.ee.features.isEnabled('cms-content-releases')) {
-        await strapi.service('admin::permission').actionProvider.registerMany(ACTIONS);
-        strapi.db.migrations.providers.internal.register(addEntryDocumentToReleaseActions);
-        strapi.hook('strapi::content-types.beforeSync').register(disableContentTypeLocalized).register(deleteActionsOnDisableDraftAndPublish);
-        strapi.hook('strapi::content-types.afterSync').register(deleteActionsOnDeleteContentType).register(enableContentTypeLocalized).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
-    }
-    if (strapi.plugin('graphql')) {
-        const graphqlExtensionService = strapi.plugin('graphql').service('extension');
-        // Exclude the release and release action models from the GraphQL schema
-        graphqlExtensionService.shadowCRUD(RELEASE_MODEL_UID).disable();
-        graphqlExtensionService.shadowCRUD(RELEASE_ACTION_MODEL_UID).disable();
-    }
-};
-
-const updateActionsStatusAndUpdateReleaseStatus = async (contentType, entry)=>{
-    const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-            releasedAt: null,
-            actions: {
-                contentType,
-                entryDocumentId: entry.documentId,
-                locale: entry.locale
+      },
+      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 });
         }
+      }
     });
-    const entryStatus = await isEntryValid(contentType, entry, {
-        strapi
+    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;
     });
-    await strapi.db.query(RELEASE_ACTION_MODEL_UID).updateMany({
-        where: {
-            contentType,
-            entryDocumentId: entry.documentId,
-            locale: entry.locale
-        },
-        data: {
-            isEntryValid: entryStatus
-        }
+    Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
+      strapi2.webhookStore.addAllowedEvent(key, value);
     });
-    for (const release of releases){
-        getService('release', {
-            strapi
-        }).updateReleaseStatus(release.id);
-    }
+  }
 };
-const deleteActionsAndUpdateReleaseStatus = async (params)=>{
-    const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-            actions: params
-        }
-    });
-    await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-        where: params
-    });
-    for (const release of releases){
-        getService('release', {
-            strapi
-        }).updateReleaseStatus(release.id);
-    }
+const destroy = async ({ strapi: strapi2 }) => {
+  const scheduledJobs = getService("scheduling", {
+    strapi: strapi2
+  }).getAll();
+  for (const [, job] of scheduledJobs) {
+    job.cancel();
+  }
 };
-const deleteActionsOnDelete = async (ctx, next)=>{
-    if (ctx.action !== 'delete') {
-        return next();
-    }
-    if (!contentTypes$1.hasDraftAndPublish(ctx.contentType)) {
-        return next();
-    }
-    const contentType = ctx.contentType.uid;
-    const { documentId, locale } = ctx.params;
-    const result = await next();
-    if (!result) {
-        return result;
+const schema$1 = {
+  collectionName: "strapi_releases",
+  info: {
+    singularName: "release",
+    pluralName: "releases",
+    displayName: "Release"
+  },
+  options: {
+    draftAndPublish: false
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false
+    },
+    "content-type-builder": {
+      visible: false
     }
-    try {
-        deleteActionsAndUpdateReleaseStatus({
-            contentType,
-            entryDocumentId: documentId,
-            ...locale !== '*' && {
-                locale
-            }
-        });
-    } catch (error) {
-        strapi.log.error('Error while deleting release actions after delete', {
-            error
-        });
+  },
+  attributes: {
+    name: {
+      type: "string",
+      required: true
+    },
+    releasedAt: {
+      type: "datetime"
+    },
+    scheduledAt: {
+      type: "datetime"
+    },
+    timezone: {
+      type: "string"
+    },
+    status: {
+      type: "enumeration",
+      enum: ["ready", "blocked", "failed", "done", "empty"],
+      required: true
+    },
+    actions: {
+      type: "relation",
+      relation: "oneToMany",
+      target: RELEASE_ACTION_MODEL_UID,
+      mappedBy: "release"
     }
-    return result;
+  }
 };
-const updateActionsOnUpdate = async (ctx, next)=>{
-    if (ctx.action !== 'update') {
-        return next();
-    }
-    if (!contentTypes$1.hasDraftAndPublish(ctx.contentType)) {
-        return next();
+const release$1 = {
+  schema: schema$1
+};
+const schema = {
+  collectionName: "strapi_release_actions",
+  info: {
+    singularName: "release-action",
+    pluralName: "release-actions",
+    displayName: "Release Action"
+  },
+  options: {
+    draftAndPublish: false
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false
+    },
+    "content-type-builder": {
+      visible: false
     }
-    const contentType = ctx.contentType.uid;
-    const result = await next();
-    if (!result) {
-        return result;
+  },
+  attributes: {
+    type: {
+      type: "enumeration",
+      enum: ["publish", "unpublish"],
+      required: true
+    },
+    entry: {
+      type: "relation",
+      relation: "morphToOne",
+      configurable: false
+    },
+    contentType: {
+      type: "string",
+      required: true
+    },
+    locale: {
+      type: "string"
+    },
+    release: {
+      type: "relation",
+      relation: "manyToOne",
+      target: RELEASE_MODEL_UID,
+      inversedBy: "actions"
+    },
+    isEntryValid: {
+      type: "boolean"
     }
+  }
+};
+const releaseAction$1 = {
+  schema
+};
+const contentTypes = {
+  release: release$1,
+  "release-action": releaseAction$1
+};
+const getGroupName = (queryValue) => {
+  switch (queryValue) {
+    case "contentType":
+      return "contentType.displayName";
+    case "action":
+      return "type";
+    case "locale":
+      return _.getOr("No locale", "locale.name");
+    default:
+      return "contentType.displayName";
+  }
+};
+const createReleaseService = ({ strapi: strapi2 }) => {
+  const dispatchWebhook = (event, { isPublished, release: release2, error }) => {
+    strapi2.eventHub.emit(event, {
+      isPublished,
+      error,
+      release: release2
+    });
+  };
+  const publishSingleTypeAction = async (uid, actionType, entryId) => {
+    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+    const entry = await strapi2.entityService.findOne(uid, entryId, { populate });
     try {
-        updateActionsStatusAndUpdateReleaseStatus(contentType, result);
+      if (actionType === "publish") {
+        await entityManagerService.publish(entry, uid);
+      } else {
+        await entityManagerService.unpublish(entry, uid);
+      }
     } catch (error) {
-        strapi.log.error('Error while updating release actions after update', {
-            error
-        });
+      if (error instanceof errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft"))
+        ;
+      else {
+        throw error;
+      }
     }
-    return result;
-};
-
-const deleteReleasesActionsAndUpdateReleaseStatus = async (params)=>{
-    const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-        where: {
-            actions: params
+  };
+  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
     });
-    await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-        where: params
+    const entriesToUnpublish = await strapi2.entityService.findMany(uid, {
+      filters: {
+        id: {
+          $in: entriestoUnpublishIds
+        }
+      },
+      populate
     });
-    // We update the status of each release after delete the actions
-    for (const release of releases){
-        getService('release', {
-            strapi
-        }).updateReleaseStatus(release.id);
+    if (entriesToPublish.length > 0) {
+      await entityManagerService.publishMany(entriesToPublish, uid);
     }
-};
-const bootstrap = async ({ strapi: strapi1 })=>{
-    if (strapi1.ee.features.isEnabled('cms-content-releases')) {
-        const contentTypesWithDraftAndPublish = Object.keys(strapi1.contentTypes).filter((uid)=>strapi1.contentTypes[uid]?.options?.draftAndPublish);
-        strapi1.db.lifecycles.subscribe({
-            models: contentTypesWithDraftAndPublish,
-            /**
-       * deleteMany is still used outside documents service, for example when deleting a locale
-       */ async afterDeleteMany (event) {
-                try {
-                    const model = strapi1.getModel(event.model.uid);
-                    // @ts-expect-error TODO: lifecycles types looks like are not 100% finished
-                    if (model.kind === 'collectionType' && model.options?.draftAndPublish) {
-                        const { where } = event.params;
-                        deleteReleasesActionsAndUpdateReleaseStatus({
-                            contentType: model.uid,
-                            locale: where?.locale ?? null,
-                            ...where?.documentId && {
-                                entryDocumentId: where.documentId
-                            }
-                        });
-                    }
-                } catch (error) {
-                    // If an error happens we don't want to block the delete entry flow, but we log the error
-                    strapi1.log.error('Error while deleting release actions after entry deleteMany', {
-                        error
-                    });
-                }
-            }
-        });
-        // We register middleware to handle ReleaseActions when changes on documents are made
-        strapi1.documents.use(deleteActionsOnDelete);
-        strapi1.documents.use(updateActionsOnUpdate);
-        getService('scheduling', {
-            strapi: strapi1
-        }).syncFromDatabase().catch((err)=>{
-            strapi1.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])=>{
-            strapi1.get('webhookStore').addAllowedEvent(key, value);
-        });
+    if (entriesToUnpublish.length > 0) {
+      await entityManagerService.unpublishMany(entriesToUnpublish, uid);
     }
-};
-
-const destroy = async ({ strapi })=>{
-    const scheduledJobs = getService('scheduling', {
-        strapi
-    }).getAll();
-    for (const [, job] of scheduledJobs){
-        job.cancel();
+  };
+  const getFormattedActions = async (releaseId) => {
+    const actions = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+      where: {
+        release: {
+          id: releaseId
+        }
+      },
+      populate: {
+        entry: {
+          fields: ["id"]
+        }
+      }
+    });
+    if (actions.length === 0) {
+      throw new errors.ValidationError("No entries to publish");
     }
-};
-
-var schema$1 = {
-    collectionName: 'strapi_releases',
-    info: {
-        singularName: 'release',
-        pluralName: 'releases',
-        displayName: 'Release'
+    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 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;
     },
-    options: {
-        draftAndPublish: false
+    async findOne(id, query = {}) {
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
+        ...query
+      });
+      return release2;
     },
-    pluginOptions: {
-        'content-manager': {
-            visible: false
-        },
-        'content-type-builder': {
-            visible: false
+    findPage(query) {
+      return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
+        ...query,
+        populate: {
+          actions: {
+            // @ts-expect-error Ignore missing properties
+            count: true
+          }
         }
+      });
     },
-    attributes: {
-        name: {
-            type: 'string',
-            required: true
-        },
-        releasedAt: {
-            type: 'datetime'
-        },
-        scheduledAt: {
-            type: 'datetime'
+    async findManyWithContentTypeEntryAttached(contentTypeUid, entriesIds) {
+      let entries = entriesIds;
+      if (!Array.isArray(entriesIds)) {
+        entries = [entriesIds];
+      }
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          actions: {
+            target_type: contentTypeUid,
+            target_id: {
+              $in: entries
+            }
+          },
+          releasedAt: {
+            $null: true
+          }
         },
-        timezone: {
-            type: 'string'
+        populate: {
+          // Filter the action to get only the content type entry
+          actions: {
+            where: {
+              target_type: contentTypeUid,
+              target_id: {
+                $in: entries
+              }
+            },
+            populate: {
+              entry: {
+                select: ["id"]
+              }
+            }
+          }
+        }
+      });
+      return releases.map((release2) => {
+        if (release2.actions?.length) {
+          const actionsForEntry = release2.actions;
+          delete release2.actions;
+          return {
+            ...release2,
+            actions: actionsForEntry
+          };
+        }
+        return release2;
+      });
+    },
+    async findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId) {
+      const releasesRelated = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          releasedAt: {
+            $null: true
+          },
+          actions: {
+            target_type: contentTypeUid,
+            target_id: entryId
+          }
+        }
+      });
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          $or: [
+            {
+              id: {
+                $notIn: releasesRelated.map((release2) => release2.id)
+              }
+            },
+            {
+              actions: null
+            }
+          ],
+          releasedAt: {
+            $null: true
+          }
+        }
+      });
+      return releases.map((release2) => {
+        if (release2.actions?.length) {
+          const [actionForEntry] = release2.actions;
+          delete release2.actions;
+          return {
+            ...release2,
+            action: actionForEntry
+          };
+        }
+        return release2;
+      });
+    },
+    async update(id, releaseData, { user }) {
+      const releaseWithCreatorFields = await 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 errors.NotFoundError(`No release found for id ${id}`);
+      }
+      if (release2.releasedAt) {
+        throw new errors.ValidationError("Release already published");
+      }
+      const updatedRelease = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
+        /*
+         * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">>
+         * is not compatible with the type we are passing here: UpdateRelease.Request['body']
+         */
+        // @ts-expect-error see above
+        data: releaseWithCreatorFields
+      });
+      const schedulingService = getService("scheduling", { strapi: strapi2 });
+      if (releaseData.scheduledAt) {
+        await schedulingService.set(id, releaseData.scheduledAt);
+      } else if (release2.scheduledAt) {
+        schedulingService.cancel(id);
+      }
+      this.updateReleaseStatus(id);
+      strapi2.telemetry.send("didUpdateContentRelease");
+      return updatedRelease;
+    },
+    async createAction(releaseId, action, { disableUpdateReleaseStatus = false } = {}) {
+      const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
+        strapi: strapi2
+      });
+      await Promise.all([
+        validateEntryContentType(action.entry.contentType),
+        validateUniqueEntry(releaseId, action)
+      ]);
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
+      if (!release2) {
+        throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      if (release2.releasedAt) {
+        throw new errors.ValidationError("Release already published");
+      }
+      const { entry, type } = action;
+      const populatedEntry = await getPopulatedEntry(entry.contentType, entry.id, { strapi: strapi2 });
+      const isEntryValid = await getEntryValidStatus(entry.contentType, populatedEntry, { strapi: strapi2 });
+      const releaseAction2 = await strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
+        data: {
+          type,
+          contentType: entry.contentType,
+          locale: entry.locale,
+          isEntryValid,
+          entry: {
+            id: entry.id,
+            __type: entry.contentType,
+            __pivot: { field: "entry" }
+          },
+          release: releaseId
         },
-        status: {
-            type: 'enumeration',
-            enum: [
-                'ready',
-                'blocked',
-                'failed',
-                'done',
-                'empty'
-            ],
-            required: true
+        populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
+      });
+      if (!disableUpdateReleaseStatus) {
+        this.updateReleaseStatus(releaseId);
+      }
+      return releaseAction2;
+    },
+    async findActions(releaseId, query) {
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+        fields: ["id"]
+      });
+      if (!release2) {
+        throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
+        ...query,
+        populate: {
+          entry: {
+            populate: "*"
+          }
         },
-        actions: {
-            type: 'relation',
-            relation: 'oneToMany',
-            target: RELEASE_ACTION_MODEL_UID,
-            mappedBy: 'release'
+        filters: {
+          release: releaseId
         }
-    }
-};
-
-const release$1 = {
-    schema: schema$1
-};
-
-var schema = {
-    collectionName: 'strapi_release_actions',
-    info: {
-        singularName: 'release-action',
-        pluralName: 'release-actions',
-        displayName: 'Release Action'
+      });
     },
-    options: {
-        draftAndPublish: false
+    async countActions(query) {
+      return strapi2.entityService.count(RELEASE_ACTION_MODEL_UID, query);
     },
-    pluginOptions: {
-        'content-manager': {
-            visible: false
-        },
-        'content-type-builder': {
-            visible: false
+    async groupActions(actions, groupBy) {
+      const contentTypeUids = actions.reduce((acc, action) => {
+        if (!acc.includes(action.contentType)) {
+          acc.push(action.contentType);
         }
+        return acc;
+      }, []);
+      const allReleaseContentTypesDictionary = await this.getContentTypesDataForActions(
+        contentTypeUids
+      );
+      const allLocalesDictionary = await this.getLocalesDataForActions();
+      const formattedData = actions.map((action) => {
+        const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
+        return {
+          ...action,
+          locale: action.locale ? allLocalesDictionary[action.locale] : null,
+          contentType: {
+            displayName,
+            mainFieldValue: action.entry[mainField],
+            uid: action.contentType
+          }
+        };
+      });
+      const groupName = getGroupName(groupBy);
+      return _.groupBy(groupName)(formattedData);
     },
-    attributes: {
-        type: {
-            type: 'enumeration',
-            enum: [
-                'publish',
-                'unpublish'
-            ],
-            required: true
-        },
-        contentType: {
-            type: 'string',
-            required: true
-        },
-        entryDocumentId: {
-            type: 'string'
-        },
-        locale: {
-            type: 'string'
+    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;
         },
-        release: {
-            type: 'relation',
-            relation: 'manyToOne',
-            target: RELEASE_MODEL_UID,
-            inversedBy: 'actions'
+        {}
+      );
+      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;
         },
-        isEntryValid: {
-            type: 'boolean'
+        {}
+      );
+      return componentsMap;
+    },
+    async delete(releaseId) {
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+        populate: {
+          actions: {
+            fields: ["id"]
+          }
         }
-    }
-};
-
-const releaseAction$1 = {
-    schema
-};
-
-const contentTypes = {
-    release: release$1,
-    'release-action': releaseAction$1
-};
-
-const createReleaseService = ({ strapi })=>{
-    const dispatchWebhook = (event, { isPublished, release, error })=>{
-        strapi.eventHub.emit(event, {
-            isPublished,
-            error,
-            release
+      });
+      if (!release2) {
+        throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      if (release2.releasedAt) {
+        throw new 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)
+            }
+          }
         });
-    };
-    /**
-   * Given a release id, it returns the actions formatted ready to be used to publish them.
-   * We split them by contentType and type (publish/unpublish) and extract only the documentIds and locales.
-   */ const getFormattedActions = async (releaseId)=>{
-        const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
+      });
+      if (release2.scheduledAt) {
+        const schedulingService = getService("scheduling", { strapi: strapi2 });
+        await schedulingService.cancel(release2.id);
+      }
+      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 errors.NotFoundError(`No release found for id ${releaseId}`);
+        }
+        if (lockedRelease.releasedAt) {
+          throw new errors.ValidationError("Release already published");
+        }
+        if (lockedRelease.status === "failed") {
+          throw new errors.ValidationError("Release failed to publish");
+        }
+        try {
+          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: {
-                release: {
-                    id: releaseId
-                }
-            }
-        });
-        if (actions.length === 0) {
-            throw new errors.ValidationError('No entries to publish');
+              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
+          };
         }
-        /**
-     * We separate publish and unpublish actions, grouping them by contentType and extracting only their documentIds and locales.
-     */ const formattedActions = {};
-        for (const action of actions){
-            const contentTypeUid = action.contentType;
-            if (!formattedActions[contentTypeUid]) {
-                formattedActions[contentTypeUid] = {
-                    publish: [],
-                    unpublish: []
-                };
+      });
+      if (error) {
+        throw error;
+      }
+      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
             }
-            formattedActions[contentTypeUid][action.type].push({
-                documentId: action.entryDocumentId,
-                locale: action.locale
-            });
+          }
+        },
+        data: update
+      });
+      if (!updatedAction) {
+        throw new 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
+            }
+          }
         }
-        return formattedActions;
-    };
-    return {
-        async create (releaseData, { user }) {
-            const releaseWithCreatorFields = await setCreatorFields({
-                user
-            })(releaseData);
-            const { validatePendingReleasesLimit, validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService('release-validation', {
-                strapi
-            });
-            await Promise.all([
-                validatePendingReleasesLimit(),
-                validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
-                validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
-            ]);
-            const release = await strapi.db.query(RELEASE_MODEL_UID).create({
-                data: {
-                    ...releaseWithCreatorFields,
-                    status: 'empty'
-                }
-            });
-            if (releaseWithCreatorFields.scheduledAt) {
-                const schedulingService = getService('scheduling', {
-                    strapi
-                });
-                await schedulingService.set(release.id, release.scheduledAt);
+      });
+      if (!deletedAction) {
+        throw new errors.NotFoundError(
+          `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
+        );
+      }
+      this.updateReleaseStatus(releaseId);
+      return deletedAction;
+    },
+    async updateReleaseStatus(releaseId) {
+      const [totalActions, invalidActions] = await Promise.all([
+        this.countActions({
+          filters: {
+            release: releaseId
+          }
+        }),
+        this.countActions({
+          filters: {
+            release: releaseId,
+            isEntryValid: false
+          }
+        })
+      ]);
+      if (totalActions > 0) {
+        if (invalidActions > 0) {
+          return strapi2.db.query(RELEASE_MODEL_UID).update({
+            where: {
+              id: releaseId
+            },
+            data: {
+              status: "blocked"
             }
-            strapi.telemetry.send('didCreateContentRelease');
-            return release;
-        },
-        async findOne (id, query = {}) {
-            const dbQuery = strapi.get('query-params').transform(RELEASE_MODEL_UID, query);
-            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                ...dbQuery,
-                where: {
-                    id
-                }
-            });
-            return release;
+          });
+        }
+        return strapi2.db.query(RELEASE_MODEL_UID).update({
+          where: {
+            id: releaseId
+          },
+          data: {
+            status: "ready"
+          }
+        });
+      }
+      return strapi2.db.query(RELEASE_MODEL_UID).update({
+        where: {
+          id: releaseId
         },
-        findPage (query) {
-            const dbQuery = strapi.get('query-params').transform(RELEASE_MODEL_UID, query ?? {});
-            return strapi.db.query(RELEASE_MODEL_UID).findPage({
-                ...dbQuery,
-                populate: {
-                    actions: {
-                        count: true
-                    }
-                }
-            });
-        },
-        findMany (query) {
-            const dbQuery = strapi.get('query-params').transform(RELEASE_MODEL_UID, query ?? {});
-            return strapi.db.query(RELEASE_MODEL_UID).findMany({
-                ...dbQuery
-            });
-        },
-        async update (id, releaseData, { user }) {
-            const releaseWithCreatorFields = await setCreatorFields({
-                user,
-                isEdition: true
-            })(releaseData);
-            const { validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService('release-validation', {
-                strapi
-            });
-            await Promise.all([
-                validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
-                validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
-            ]);
-            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                where: {
-                    id
-                }
-            });
-            if (!release) {
-                throw new errors.NotFoundError(`No release found for id ${id}`);
-            }
-            if (release.releasedAt) {
-                throw new errors.ValidationError('Release already published');
-            }
-            const updatedRelease = await strapi.db.query(RELEASE_MODEL_UID).update({
-                where: {
-                    id
-                },
-                data: releaseWithCreatorFields
-            });
-            const schedulingService = getService('scheduling', {
-                strapi
-            });
-            if (releaseData.scheduledAt) {
-                // set function always cancel the previous job if it exists, so we can call it directly
-                await schedulingService.set(id, releaseData.scheduledAt);
-            } else if (release.scheduledAt) {
-                // When user don't send a scheduledAt and we have one on the release, means that user want to unschedule it
-                schedulingService.cancel(id);
-            }
-            this.updateReleaseStatus(id);
-            strapi.telemetry.send('didUpdateContentRelease');
-            return updatedRelease;
-        },
-        async getAllComponents () {
-            const contentManagerComponentsService = strapi.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 release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                where: {
-                    id: releaseId
-                },
-                populate: {
-                    actions: {
-                        select: [
-                            'id'
-                        ]
-                    }
-                }
-            });
-            if (!release) {
-                throw new errors.NotFoundError(`No release found for id ${releaseId}`);
-            }
-            if (release.releasedAt) {
-                throw new errors.ValidationError('Release already published');
-            }
-            // Only delete the release and its actions is you in fact can delete all the actions and the release
-            // Otherwise, if the transaction fails it throws an error
-            await strapi.db.transaction(async ()=>{
-                await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-                    where: {
-                        id: {
-                            $in: release.actions.map((action)=>action.id)
-                        }
-                    }
-                });
-                await strapi.db.query(RELEASE_MODEL_UID).delete({
-                    where: {
-                        id: releaseId
-                    }
-                });
-            });
-            if (release.scheduledAt) {
-                const schedulingService = getService('scheduling', {
-                    strapi
-                });
-                await schedulingService.cancel(release.id);
-            }
-            strapi.telemetry.send('didDeleteContentRelease');
-            return release;
-        },
-        async publish (releaseId) {
-            const { release, error } = await strapi.db.transaction(async ({ trx })=>{
-                /**
-           * We lock the release in this transaction, so any other process trying to publish it will wait until this transaction is finished
-           * In this transaction we don't care about rollback, becasue we want to persist the lock until the end and if it fails we want to change the release status to failed
-           */ const lockedRelease = await strapi.db?.queryBuilder(RELEASE_MODEL_UID).where({
-                    id: releaseId
-                }).select([
-                    'id',
-                    'name',
-                    'releasedAt',
-                    'status'
-                ]).first().transacting(trx).forUpdate().execute();
-                if (!lockedRelease) {
-                    throw new errors.NotFoundError(`No release found for id ${releaseId}`);
-                }
-                if (lockedRelease.releasedAt) {
-                    throw new errors.ValidationError('Release already published');
-                }
-                if (lockedRelease.status === 'failed') {
-                    throw new errors.ValidationError('Release failed to publish');
-                }
-                try {
-                    strapi.log.info(`[Content Releases] Starting to publish release ${lockedRelease.name}`);
-                    const formattedActions = await getFormattedActions(releaseId);
-                    await strapi.db.transaction(async ()=>Promise.all(Object.keys(formattedActions).map(async (contentTypeUid)=>{
-                            const contentType = contentTypeUid;
-                            const { publish, unpublish } = formattedActions[contentType];
-                            return Promise.all([
-                                ...publish.map((params)=>strapi.documents(contentType).publish(params)),
-                                ...unpublish.map((params)=>strapi.documents(contentType).unpublish(params))
-                            ]);
-                        })));
-                    const release = await strapi.db.query(RELEASE_MODEL_UID).update({
-                        where: {
-                            id: releaseId
-                        },
-                        data: {
-                            status: 'done',
-                            releasedAt: new Date()
-                        }
-                    });
-                    dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
-                        isPublished: true,
-                        release
-                    });
-                    strapi.telemetry.send('didPublishContentRelease');
-                    return {
-                        release,
-                        error: null
-                    };
-                } catch (error) {
-                    dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
-                        isPublished: false,
-                        error
-                    });
-                    // We need to run the update in the same transaction because the release is locked
-                    await strapi.db?.queryBuilder(RELEASE_MODEL_UID).where({
-                        id: releaseId
-                    }).update({
-                        status: 'failed'
-                    }).transacting(trx).execute();
-                    // At this point, we don't want to throw the error because if that happen we rollback the change in the release status
-                    // We want to throw the error after the transaction is finished, so we return the error
-                    return {
-                        release: null,
-                        error
-                    };
-                }
-            });
-            // Now the first transaction is commited, we can safely throw the error if it exists
-            if (error instanceof Error) {
-                throw error;
-            }
-            return release;
-        },
-        async updateReleaseStatus (releaseId) {
-            const releaseActionService = getService('release-action', {
-                strapi
-            });
-            const [totalActions, invalidActions] = await Promise.all([
-                releaseActionService.countActions({
-                    filters: {
-                        release: releaseId
-                    }
-                }),
-                releaseActionService.countActions({
-                    filters: {
-                        release: releaseId,
-                        isEntryValid: false
-                    }
-                })
-            ]);
-            if (totalActions > 0) {
-                if (invalidActions > 0) {
-                    return strapi.db.query(RELEASE_MODEL_UID).update({
-                        where: {
-                            id: releaseId
-                        },
-                        data: {
-                            status: 'blocked'
-                        }
-                    });
-                }
-                return strapi.db.query(RELEASE_MODEL_UID).update({
-                    where: {
-                        id: releaseId
-                    },
-                    data: {
-                        status: 'ready'
-                    }
-                });
-            }
-            return strapi.db.query(RELEASE_MODEL_UID).update({
-                where: {
-                    id: releaseId
-                },
-                data: {
-                    status: 'empty'
-                }
-            });
+        data: {
+          status: "empty"
         }
-    };
-};
-
-const getGroupName = (queryValue)=>{
-    switch(queryValue){
-        case 'contentType':
-            return 'contentType.displayName';
-        case 'type':
-            return 'type';
-        case 'locale':
-            return _.getOr('No locale', 'locale.name');
-        default:
-            return 'contentType.displayName';
+      });
     }
+  };
 };
-const createReleaseActionService = ({ strapi })=>{
-    const getLocalesDataForActions = async ()=>{
-        if (!strapi.plugin('i18n')) {
-            return {};
-        }
-        const allLocales = await strapi.plugin('i18n').service('locales').find() || [];
-        return allLocales.reduce((acc, locale)=>{
-            acc[locale.code] = {
-                name: locale.name,
-                code: locale.code
-            };
-            return acc;
-        }, {});
-    };
-    const getContentTypesDataForActions = async (contentTypesUids)=>{
-        const contentManagerContentTypeService = strapi.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: strapi.getModel(contentTypeUid).info.displayName
-            };
-        }
-        return contentTypesData;
-    };
-    return {
-        async create (releaseId, action, { disableUpdateReleaseStatus = false } = {}) {
-            const { validateEntryData, validateUniqueEntry } = getService('release-validation', {
-                strapi
-            });
-            await Promise.all([
-                validateEntryData(action.contentType, action.entryDocumentId),
-                validateUniqueEntry(releaseId, action)
-            ]);
-            // If we are adding a singleType, we need to append the documentId of that singleType
-            const model = strapi.contentType(action.contentType);
-            if (model.kind === 'singleType') {
-                const document = await strapi.db.query(model.uid).findOne({
-                    select: [
-                        'documentId'
-                    ]
-                });
-                if (!document) {
-                    throw new errors.NotFoundError(`No entry found for contentType ${action.contentType}`);
-                }
-                action.entryDocumentId = document.documentId;
-            }
-            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                where: {
-                    id: releaseId
-                }
-            });
-            if (!release) {
-                throw new errors.NotFoundError(`No release found for id ${releaseId}`);
-            }
-            if (release.releasedAt) {
-                throw new errors.ValidationError('Release already published');
-            }
-            // If the action is a publish, check if the entry is valid
-            // If the action is an unpublish, skip the validation
-            const actionStatus = action.type === 'publish' ? await getDraftEntryValidStatus({
-                contentType: action.contentType,
-                documentId: action.entryDocumentId,
-                locale: action.locale
-            }, {
-                strapi
-            }) : true;
-            const releaseAction = await strapi.db.query(RELEASE_ACTION_MODEL_UID).create({
-                data: {
-                    ...action,
-                    release: release.id,
-                    isEntryValid: actionStatus
-                },
-                populate: {
-                    release: {
-                        select: [
-                            'id'
-                        ]
-                    }
-                }
-            });
-            if (!disableUpdateReleaseStatus) {
-                getService('release', {
-                    strapi
-                }).updateReleaseStatus(release.id);
-            }
-            return releaseAction;
-        },
-        async findPage (releaseId, query) {
-            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                where: {
-                    id: releaseId
-                },
-                select: [
-                    'id'
-                ]
-            });
-            if (!release) {
-                throw new errors.NotFoundError(`No release found for id ${releaseId}`);
-            }
-            const dbQuery = strapi.get('query-params').transform(RELEASE_ACTION_MODEL_UID, query ?? {});
-            const { results: actions, pagination } = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findPage({
-                ...dbQuery,
-                where: {
-                    release: releaseId
-                }
-            });
-            // For each contentType on the release, we create a custom populate object for nested relations
-            const populateBuilderService = strapi.plugin('content-manager').service('populate-builder');
-            const actionsWithEntry = await async.map(actions, async (action)=>{
-                // @ts-expect-error - Core.Service type is not a function
-                const populate = await populateBuilderService(action.contentType).populateDeep(Infinity).build();
-                const entry = await getEntry({
-                    contentType: action.contentType,
-                    documentId: action.entryDocumentId,
-                    locale: action.locale,
-                    populate,
-                    status: action.type === 'publish' ? 'draft' : 'published'
-                }, {
-                    strapi
-                });
-                return {
-                    ...action,
-                    entry,
-                    status: entry ? await getEntryStatus(action.contentType, entry) : null
-                };
-            });
-            return {
-                results: actionsWithEntry,
-                pagination
-            };
-        },
-        async groupActions (actions, groupBy) {
-            const contentTypeUids = actions.reduce((acc, action)=>{
-                if (!acc.includes(action.contentType)) {
-                    acc.push(action.contentType);
-                }
-                return acc;
-            }, []);
-            const allReleaseContentTypesDictionary = await getContentTypesDataForActions(contentTypeUids);
-            const allLocalesDictionary = await getLocalesDataForActions();
-            const formattedData = actions.map((action)=>{
-                const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
-                return {
-                    ...action,
-                    locale: action.locale ? allLocalesDictionary[action.locale] : null,
-                    contentType: {
-                        displayName,
-                        mainFieldValue: action.entry[mainField],
-                        uid: action.contentType
-                    }
-                };
-            });
-            const groupName = getGroupName(groupBy);
-            return _.groupBy(groupName)(formattedData);
-        },
-        async getContentTypeModelsFromActions (actions) {
-            const contentTypeUids = actions.reduce((acc, action)=>{
-                if (!acc.includes(action.contentType)) {
-                    acc.push(action.contentType);
-                }
-                return acc;
-            }, []);
-            const workflowsService = strapi.plugin('review-workflows').service('workflows');
-            const contentTypeModelsMap = await async.reduce(contentTypeUids)(async (accPromise, contentTypeUid)=>{
-                const acc = await accPromise;
-                const contentTypeModel = strapi.getModel(contentTypeUid);
-                const workflow = await workflowsService.getAssignedWorkflow(contentTypeUid, {
-                    populate: 'stageRequiredToPublish'
-                });
-                acc[contentTypeUid] = {
-                    ...contentTypeModel,
-                    hasReviewWorkflow: !!workflow,
-                    stageRequiredToPublish: workflow?.stageRequiredToPublish
-                };
-                return acc;
-            }, {});
-            return contentTypeModelsMap;
-        },
-        async countActions (query) {
-            const dbQuery = strapi.get('query-params').transform(RELEASE_ACTION_MODEL_UID, query ?? {});
-            return strapi.db.query(RELEASE_ACTION_MODEL_UID).count(dbQuery);
-        },
-        async update (actionId, releaseId, update) {
-            const action = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findOne({
-                where: {
-                    id: actionId,
-                    release: {
-                        id: releaseId,
-                        releasedAt: {
-                            $null: true
-                        }
-                    }
-                }
-            });
-            if (!action) {
-                throw new errors.NotFoundError(`Action with id ${actionId} not found in release with id ${releaseId} or it is already published`);
-            }
-            const actionStatus = update.type === 'publish' ? await getDraftEntryValidStatus({
-                contentType: action.contentType,
-                documentId: action.entryDocumentId,
-                locale: action.locale
-            }, {
-                strapi
-            }) : true;
-            const updatedAction = await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-                where: {
-                    id: actionId,
-                    release: {
-                        id: releaseId,
-                        releasedAt: {
-                            $null: true
-                        }
-                    }
-                },
-                data: {
-                    ...update,
-                    isEntryValid: actionStatus
-                }
-            });
-            getService('release', {
-                strapi
-            }).updateReleaseStatus(releaseId);
-            return updatedAction;
-        },
-        async delete (actionId, releaseId) {
-            const deletedAction = await strapi.db.query(RELEASE_ACTION_MODEL_UID).delete({
-                where: {
-                    id: actionId,
-                    release: {
-                        id: releaseId,
-                        releasedAt: {
-                            $null: true
-                        }
-                    }
-                }
-            });
-            if (!deletedAction) {
-                throw new errors.NotFoundError(`Action with id ${actionId} not found in release with id ${releaseId} or it is already published`);
-            }
-            getService('release', {
-                strapi
-            }).updateReleaseStatus(releaseId);
-            return deletedAction;
-        },
-        async validateActionsByContentTypes (contentTypeUids) {
-            const actions = await strapi.db.query(RELEASE_ACTION_MODEL_UID).findMany({
-                where: {
-                    contentType: {
-                        $in: contentTypeUids
-                    },
-                    // We only want to validate actions that are going to be published
-                    type: 'publish',
-                    release: {
-                        releasedAt: {
-                            $null: true
-                        }
-                    }
-                },
-                populate: {
-                    release: true
-                }
-            });
-            const releasesUpdated = [];
-            await async.map(actions, async (action)=>{
-                const isValid = await getDraftEntryValidStatus({
-                    contentType: action.contentType,
-                    documentId: action.entryDocumentId,
-                    locale: action.locale
-                }, {
-                    strapi
-                });
-                await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
-                    where: {
-                        id: action.id
-                    },
-                    data: {
-                        isEntryValid: isValid
-                    }
-                });
-                if (!releasesUpdated.includes(action.release.id)) {
-                    releasesUpdated.push(action.release.id);
-                }
-                return {
-                    id: action.id,
-                    isEntryValid: isValid
-                };
-            });
-            if (releasesUpdated.length > 0) {
-                await async.map(releasesUpdated, async (releaseId)=>{
-                    await getService('release', {
-                        strapi
-                    }).updateReleaseStatus(releaseId);
-                });
-            }
-        }
-    };
-};
-
 class AlreadyOnReleaseError extends errors.ApplicationError {
-    constructor(message){
-        super(message);
-        this.name = 'AlreadyOnReleaseError';
-    }
+  constructor(message) {
+    super(message);
+    this.name = "AlreadyOnReleaseError";
+  }
 }
-const createReleaseValidationService = ({ strapi })=>({
-        async validateUniqueEntry (releaseId, releaseActionArgs) {
-            /**
-     * Asserting the type, otherwise TS complains: 'release.actions' is of type 'unknown', even though the types come through for non-populated fields...
-     * Possibly related to the comment on GetValues: https://github.com/strapi/strapi/blob/main/packages/core/types/src/modules/entity-service/result.ts
-     */ const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                where: {
-                    id: releaseId
-                },
-                populate: {
-                    actions: true
-                }
-            });
-            if (!release) {
-                throw new errors.NotFoundError(`No release found for id ${releaseId}`);
-            }
-            const isEntryInRelease = release.actions.some((action)=>action.entryDocumentId === releaseActionArgs.entryDocumentId && action.contentType === releaseActionArgs.contentType && (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true));
-            if (isEntryInRelease) {
-                throw new AlreadyOnReleaseError(`Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ''} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`);
-            }
-        },
-        validateEntryData (contentTypeUid, entryDocumentId) {
-            const contentType = strapi.contentType(contentTypeUid);
-            if (!contentType) {
-                throw new errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
-            }
-            if (!contentTypes$1.hasDraftAndPublish(contentType)) {
-                throw new errors.ValidationError(`Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`);
-            }
-            if (contentType.kind === 'collectionType' && !entryDocumentId) {
-                throw new errors.ValidationError('Document id is required for collection type');
-            }
-        },
-        async validatePendingReleasesLimit () {
-            // Use the maximum releases option if it exists, otherwise default to 3
-            const featureCfg = strapi.ee.features.get('cms-content-releases');
-            const maximumPendingReleases = typeof featureCfg === 'object' && featureCfg?.options?.maximumReleases || 3;
-            const [, pendingReleasesCount] = await strapi.db.query(RELEASE_MODEL_UID).findWithCount({
-                filters: {
-                    releasedAt: {
-                        $null: true
-                    }
-                }
-            });
-            // Unlimited is a number that will never be reached like 9999
-            if (pendingReleasesCount >= maximumPendingReleases) {
-                throw new errors.ValidationError('You have reached the maximum number of pending releases');
-            }
-        },
-        async validateUniqueNameForPendingRelease (name, id) {
-            const pendingReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
-                where: {
-                    releasedAt: {
-                        $null: true
-                    },
-                    name,
-                    ...id && {
-                        id: {
-                            $ne: id
-                        }
-                    }
-                }
-            });
-            const isNameUnique = pendingReleases.length === 0;
-            if (!isNameUnique) {
-                throw new errors.ValidationError(`Release with name ${name} already exists`);
-            }
-        },
-        async validateScheduledAtIsLaterThanNow (scheduledAt) {
-            if (scheduledAt && new Date(scheduledAt) <= new Date()) {
-                throw new errors.ValidationError('Scheduled at must be later than now');
-            }
+const createReleaseValidationService = ({ strapi: strapi2 }) => ({
+  async validateUniqueEntry(releaseId, releaseActionArgs) {
+    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+      populate: { actions: { populate: { entry: { fields: ["id"] } } } }
+    });
+    if (!release2) {
+      throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+    }
+    const isEntryInRelease = release2.actions.some(
+      (action) => Number(action.entry.id) === Number(releaseActionArgs.entry.id) && action.contentType === releaseActionArgs.entry.contentType
+    );
+    if (isEntryInRelease) {
+      throw new AlreadyOnReleaseError(
+        `Entry with id ${releaseActionArgs.entry.id} and contentType ${releaseActionArgs.entry.contentType} already exists in release with id ${releaseId}`
+      );
+    }
+  },
+  validateEntryContentType(contentTypeUid) {
+    const contentType = strapi2.contentType(contentTypeUid);
+    if (!contentType) {
+      throw new errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
+    }
+    if (!contentType.options?.draftAndPublish) {
+      throw new errors.ValidationError(
+        `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`
+      );
+    }
+  },
+  async validatePendingReleasesLimit() {
+    const maximumPendingReleases = (
+      // @ts-expect-error - options is not typed into features
+      EE.features.get("cms-content-releases")?.options?.maximumReleases || 3
+    );
+    const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
+      filters: {
+        releasedAt: {
+          $null: true
         }
+      }
     });
-
-const createSchedulingService = ({ strapi })=>{
-    const scheduledJobs = new Map();
-    return {
-        async set (releaseId, scheduleDate) {
-            const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
-                where: {
-                    id: releaseId,
-                    releasedAt: null
-                }
-            });
-            if (!release) {
-                throw new errors.NotFoundError(`No release found for id ${releaseId}`);
-            }
-            const job = scheduleJob(scheduleDate, async ()=>{
-                try {
-                    await getService('release', {
-                        strapi
-                    }).publish(releaseId);
-                // @TODO: Trigger webhook with success message
-                } catch (error) {
-                // @TODO: Trigger webhook with error message
-                }
-                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;
+    if (pendingReleasesCount >= maximumPendingReleases) {
+      throw new 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 errors.ValidationError(`Release with name ${name} already exists`);
+    }
+  },
+  async validateScheduledAtIsLaterThanNow(scheduledAt) {
+    if (scheduledAt && new Date(scheduledAt) <= /* @__PURE__ */ new Date()) {
+      throw new errors.ValidationError("Scheduled at must be later than now");
+    }
+  }
+});
+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 errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      const job = 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 strapi.db.query(RELEASE_MODEL_UID).findMany({
-                where: {
-                    scheduledAt: {
-                        $gte: new Date()
-                    },
-                    releasedAt: null
-                }
-            });
-            for (const release of releases){
-                this.set(release.id, release.scheduledAt);
-            }
-            return scheduledJobs;
-        }
-    };
-};
-
-const DEFAULT_SETTINGS = {
-    defaultTimezone: null
-};
-const createSettingsService = ({ strapi })=>{
-    const getStore = async ()=>strapi.store({
-            type: 'core',
-            name: 'content-releases'
-        });
-    return {
-        async update ({ settings }) {
-            const store = await getStore();
-            store.set({
-                key: 'settings',
-                value: settings
-            });
-            return settings;
-        },
-        async find () {
-            const store = await getStore();
-            const settings = await store.get({
-                key: 'settings'
-            });
-            return {
-                ...DEFAULT_SETTINGS,
-                ...settings || {}
-            };
+     */
+    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-action': createReleaseActionService,
-    'release-validation': createReleaseValidationService,
-    scheduling: createSchedulingService,
-    settings: createSettingsService
+  release: createReleaseService,
+  "release-validation": createReleaseValidationService,
+  scheduling: createSchedulingService
 };
-
-const RELEASE_SCHEMA = yup$1.object().shape({
-    name: yup$1.string().trim().required(),
-    scheduledAt: yup$1.string().nullable(),
-    timezone: yup$1.string().when('scheduledAt', {
-        is: (value)=>value !== null && value !== undefined,
-        then: yup$1.string().required(),
-        otherwise: yup$1.string().nullable()
-    })
-}).required().noUnknown();
-const FIND_BY_DOCUMENT_ATTACHED_PARAMS_SCHEMA = yup$1.object().shape({
-    contentType: yup$1.string().required(),
-    entryDocumentId: yup$1.string().nullable(),
-    hasEntryAttached: yup$1.string().nullable(),
-    locale: yup$1.string().nullable()
+const RELEASE_SCHEMA = yup.object().shape({
+  name: yup.string().trim().required(),
+  scheduledAt: yup.string().nullable(),
+  isScheduled: yup.boolean().optional(),
+  time: yup.string().when("isScheduled", {
+    is: true,
+    then: yup.string().trim().required(),
+    otherwise: yup.string().nullable()
+  }),
+  timezone: yup.string().when("isScheduled", {
+    is: true,
+    then: yup.string().required().nullable(),
+    otherwise: yup.string().nullable()
+  }),
+  date: yup.string().when("isScheduled", {
+    is: true,
+    then: yup.string().required().nullable(),
+    otherwise: yup.string().nullable()
+  })
 }).required().noUnknown();
 const validateRelease = validateYupSchema(RELEASE_SCHEMA);
-const validatefindByDocumentAttachedParams = validateYupSchema(FIND_BY_DOCUMENT_ATTACHED_PARAMS_SCHEMA);
-
 const releaseController = {
-    /**
-   * Find releases based on documents attached or not to the release.
-   * If `hasEntryAttached` is true, it will return all releases that have the entry attached.
-   * If `hasEntryAttached` is false, it will return all releases that don't have the entry attached.
-   */ async findByDocumentAttached (ctx) {
-        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
-            ability: ctx.state.userAbility,
-            model: RELEASE_MODEL_UID
-        });
-        await permissionsManager.validateQuery(ctx.query);
-        const releaseService = getService('release', {
-            strapi
-        });
-        const query = await permissionsManager.sanitizeQuery(ctx.query);
-        await validatefindByDocumentAttachedParams(query);
-        // If entry is a singleType, we need to manually add the entryDocumentId to the query
-        const model = strapi.getModel(query.contentType);
-        if (model.kind && model.kind === 'singleType') {
-            const document = await strapi.db.query(model.uid).findOne({
-                select: [
-                    'documentId'
-                ]
-            });
-            if (!document) {
-                throw new errors.NotFoundError(`No entry found for contentType ${query.contentType}`);
-            }
-            query.entryDocumentId = document.documentId;
-        }
-        const { contentType, hasEntryAttached, entryDocumentId, locale } = query;
-        const isEntryAttached = typeof hasEntryAttached === 'string' ? Boolean(JSON.parse(hasEntryAttached)) : false;
-        if (isEntryAttached) {
-            const releases = await releaseService.findMany({
-                where: {
-                    releasedAt: null,
-                    actions: {
-                        contentType,
-                        entryDocumentId: entryDocumentId ?? null,
-                        locale: locale ?? null
-                    }
-                },
-                populate: {
-                    actions: {
-                        fields: [
-                            'type'
-                        ],
-                        filters: {
-                            contentType,
-                            entryDocumentId: entryDocumentId ?? null,
-                            locale: locale ?? null
-                        }
-                    }
-                }
-            });
-            ctx.body = {
-                data: releases
-            };
-        } else {
-            const relatedReleases = await releaseService.findMany({
-                where: {
-                    releasedAt: null,
-                    actions: {
-                        contentType,
-                        entryDocumentId: entryDocumentId ?? null,
-                        locale: locale ?? null
-                    }
-                }
-            });
-            const releases = await releaseService.findMany({
-                where: {
-                    $or: [
-                        {
-                            id: {
-                                $notIn: relatedReleases.map((release)=>release.id)
-                            }
-                        },
-                        {
-                            actions: null
-                        }
-                    ],
-                    releasedAt: null
-                }
-            });
-            ctx.body = {
-                data: releases
-            };
-        }
-    },
-    async findPage (ctx) {
-        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
-            ability: ctx.state.userAbility,
-            model: RELEASE_MODEL_UID
-        });
-        await permissionsManager.validateQuery(ctx.query);
-        const releaseService = getService('release', {
-            strapi
-        });
-        const query = await permissionsManager.sanitizeQuery(ctx.query);
-        const { results, pagination } = await releaseService.findPage(query);
-        const data = results.map((release)=>{
-            const { actions, ...releaseData } = release;
-            return {
-                ...releaseData,
-                actions: {
-                    meta: {
-                        count: actions.count
-                    }
-                }
-            };
-        });
-        const pendingReleasesCount = await strapi.db.query(RELEASE_MODEL_UID).count({
-            where: {
-                releasedAt: null
-            }
-        });
-        ctx.body = {
-            data,
+  async findMany(ctx) {
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+      ability: ctx.state.userAbility,
+      model: RELEASE_MODEL_UID
+    });
+    await permissionsManager.validateQuery(ctx.query);
+    const releaseService = getService("release", { strapi });
+    const isFindManyForContentTypeEntry = Boolean(ctx.query?.contentTypeUid && ctx.query?.entryId);
+    if (isFindManyForContentTypeEntry) {
+      const query = await permissionsManager.sanitizeQuery(ctx.query);
+      const contentTypeUid = query.contentTypeUid;
+      const entryId = query.entryId;
+      const hasEntryAttached = typeof query.hasEntryAttached === "string" ? JSON.parse(query.hasEntryAttached) : false;
+      const data = hasEntryAttached ? await releaseService.findManyWithContentTypeEntryAttached(contentTypeUid, entryId) : await releaseService.findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId);
+      ctx.body = { data };
+    } else {
+      const query = await permissionsManager.sanitizeQuery(ctx.query);
+      const { results, pagination } = await releaseService.findPage(query);
+      const data = results.map((release2) => {
+        const { actions, ...releaseData } = release2;
+        return {
+          ...releaseData,
+          actions: {
             meta: {
-                pagination,
-                pendingReleasesCount
+              count: actions.count
             }
+          }
         };
-    },
-    async findOne (ctx) {
-        const id = ctx.params.id;
-        const releaseService = getService('release', {
-            strapi
-        });
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const release = await releaseService.findOne(id, {
-            populate: [
-                'createdBy'
-            ]
-        });
-        if (!release) {
-            throw new errors.NotFoundError(`Release not found for id: ${id}`);
+      });
+      const pendingReleasesCount = await strapi.query(RELEASE_MODEL_UID).count({
+        where: {
+          releasedAt: null
         }
-        const count = await releaseActionService.countActions({
-            filters: {
-                release: id
-            }
-        });
-        const sanitizedRelease = {
-            ...release,
-            createdBy: release.createdBy ? strapi.service('admin::user').sanitizeUser(release.createdBy) : null
-        };
-        // Format the data object
-        const data = {
-            ...sanitizedRelease,
-            actions: {
-                meta: {
-                    count
-                }
-            }
-        };
-        ctx.body = {
-            data
-        };
-    },
-    async mapEntriesToReleases (ctx) {
-        const { contentTypeUid, documentIds, locale } = ctx.query;
-        if (!contentTypeUid || !documentIds) {
-            throw new errors.ValidationError('Missing required query parameters');
+      });
+      ctx.body = { data, meta: { pagination, pendingReleasesCount } };
+    }
+  },
+  async findOne(ctx) {
+    const id = ctx.params.id;
+    const releaseService = getService("release", { strapi });
+    const release2 = await releaseService.findOne(id, { populate: ["createdBy"] });
+    if (!release2) {
+      throw new errors.NotFoundError(`Release not found for id: ${id}`);
+    }
+    const count = await releaseService.countActions({
+      filters: {
+        release: id
+      }
+    });
+    const sanitizedRelease = {
+      ...release2,
+      createdBy: release2.createdBy ? strapi.admin.services.user.sanitizeUser(release2.createdBy) : null
+    };
+    const data = {
+      ...sanitizedRelease,
+      actions: {
+        meta: {
+          count
         }
-        const releaseService = getService('release', {
-            strapi
-        });
-        const releasesWithActions = await releaseService.findMany({
-            where: {
-                releasedAt: null,
-                actions: {
-                    contentType: contentTypeUid,
-                    entryDocumentId: {
-                        $in: documentIds
-                    },
-                    locale
-                }
-            },
-            populate: {
-                actions: true
-            }
-        });
-        const mappedEntriesInReleases = releasesWithActions.reduce((acc, release)=>{
-            release.actions.forEach((action)=>{
-                if (action.contentType !== contentTypeUid) {
-                    return;
-                }
-                if (locale && action.locale !== locale) {
-                    return;
-                }
-                if (!acc[action.entryDocumentId]) {
-                    acc[action.entryDocumentId] = [
-                        {
-                            id: release.id,
-                            name: release.name
-                        }
-                    ];
-                } else {
-                    acc[action.entryDocumentId].push({
-                        id: release.id,
-                        name: release.name
-                    });
-                }
-            });
-            return acc;
-        }, {});
-        ctx.body = {
-            data: mappedEntriesInReleases
-        };
-    },
-    async create (ctx) {
-        const user = ctx.state.user;
-        const releaseArgs = ctx.request.body;
-        await validateRelease(releaseArgs);
-        const releaseService = getService('release', {
-            strapi
-        });
-        const release = await releaseService.create(releaseArgs, {
-            user
-        });
-        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
-            ability: ctx.state.userAbility,
-            model: RELEASE_MODEL_UID
-        });
-        ctx.created({
-            data: await permissionsManager.sanitizeOutput(release)
-        });
-    },
-    async update (ctx) {
-        const user = ctx.state.user;
-        const releaseArgs = ctx.request.body;
-        const id = ctx.params.id;
-        await validateRelease(releaseArgs);
-        const releaseService = getService('release', {
-            strapi
-        });
-        const release = await releaseService.update(id, releaseArgs, {
-            user
-        });
-        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
-            ability: ctx.state.userAbility,
-            model: RELEASE_MODEL_UID
-        });
-        ctx.body = {
-            data: await permissionsManager.sanitizeOutput(release)
-        };
-    },
-    async delete (ctx) {
-        const id = ctx.params.id;
-        const releaseService = getService('release', {
-            strapi
-        });
-        const release = await releaseService.delete(id);
-        ctx.body = {
-            data: release
-        };
-    },
-    async publish (ctx) {
-        const id = ctx.params.id;
-        const releaseService = getService('release', {
-            strapi
-        });
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const release = await releaseService.publish(id);
-        const [countPublishActions, countUnpublishActions] = await Promise.all([
-            releaseActionService.countActions({
-                filters: {
-                    release: id,
-                    type: 'publish'
-                }
-            }),
-            releaseActionService.countActions({
-                filters: {
-                    release: id,
-                    type: 'unpublish'
-                }
-            })
-        ]);
-        ctx.body = {
-            data: release,
-            meta: {
-                totalEntries: countPublishActions + countUnpublishActions,
-                totalPublishedEntries: countPublishActions,
-                totalUnpublishedEntries: countUnpublishActions
-            }
-        };
+      }
+    };
+    ctx.body = { data };
+  },
+  async mapEntriesToReleases(ctx) {
+    const { contentTypeUid, entriesIds } = ctx.query;
+    if (!contentTypeUid || !entriesIds) {
+      throw new 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;
+    await validateRelease(releaseArgs);
+    const releaseService = getService("release", { strapi });
+    const release2 = await releaseService.create(releaseArgs, { user });
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+      ability: ctx.state.userAbility,
+      model: RELEASE_MODEL_UID
+    });
+    ctx.body = {
+      data: await permissionsManager.sanitizeOutput(release2)
+    };
+  },
+  async update(ctx) {
+    const user = ctx.state.user;
+    const releaseArgs = ctx.request.body;
+    const id = ctx.params.id;
+    await validateRelease(releaseArgs);
+    const releaseService = getService("release", { strapi });
+    const release2 = await releaseService.update(id, releaseArgs, { user });
+    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+      ability: ctx.state.userAbility,
+      model: RELEASE_MODEL_UID
+    });
+    ctx.body = {
+      data: await permissionsManager.sanitizeOutput(release2)
+    };
+  },
+  async delete(ctx) {
+    const id = ctx.params.id;
+    const releaseService = getService("release", { strapi });
+    const release2 = await releaseService.delete(id);
+    ctx.body = {
+      data: release2
+    };
+  },
+  async publish(ctx) {
+    const user = ctx.state.user;
+    const id = ctx.params.id;
+    const releaseService = getService("release", { strapi });
+    const release2 = await releaseService.publish(id, { user });
+    const [countPublishActions, countUnpublishActions] = await Promise.all([
+      releaseService.countActions({
+        filters: {
+          release: id,
+          type: "publish"
+        }
+      }),
+      releaseService.countActions({
+        filters: {
+          release: id,
+          type: "unpublish"
+        }
+      })
+    ]);
+    ctx.body = {
+      data: release2,
+      meta: {
+        totalEntries: countPublishActions + countUnpublishActions,
+        totalPublishedEntries: countPublishActions,
+        totalUnpublishedEntries: countUnpublishActions
+      }
+    };
+  }
 };
-
 const RELEASE_ACTION_SCHEMA = yup$1.object().shape({
-    contentType: yup$1.string().required(),
-    entryDocumentId: yup$1.strapiID(),
-    locale: yup$1.string(),
-    type: yup$1.string().oneOf([
-        'publish',
-        'unpublish'
-    ]).required()
+  entry: yup$1.object().shape({
+    id: yup$1.strapiID().required(),
+    contentType: yup$1.string().required()
+  }).required(),
+  type: yup$1.string().oneOf(["publish", "unpublish"]).required()
 });
 const RELEASE_ACTION_UPDATE_SCHEMA = yup$1.object().shape({
-    type: yup$1.string().oneOf([
-        'publish',
-        'unpublish'
-    ]).required()
-});
-const FIND_MANY_ACTIONS_PARAMS = yup$1.object().shape({
-    groupBy: yup$1.string().oneOf([
-        'action',
-        'contentType',
-        'locale'
-    ])
+  type: yup$1.string().oneOf(["publish", "unpublish"]).required()
 });
 const validateReleaseAction = validateYupSchema(RELEASE_ACTION_SCHEMA);
 const validateReleaseActionUpdateSchema = validateYupSchema(RELEASE_ACTION_UPDATE_SCHEMA);
-const validateFindManyActionsParams = validateYupSchema(FIND_MANY_ACTIONS_PARAMS);
-
 const releaseActionController = {
-    async create (ctx) {
-        const releaseId = ctx.params.releaseId;
-        const releaseActionArgs = ctx.request.body;
-        await validateReleaseAction(releaseActionArgs);
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const releaseAction = await releaseActionService.create(releaseId, releaseActionArgs);
-        ctx.created({
-            data: releaseAction
-        });
-    },
-    async createMany (ctx) {
-        const releaseId = ctx.params.releaseId;
-        const releaseActionsArgs = ctx.request.body;
-        await Promise.all(releaseActionsArgs.map((releaseActionArgs)=>validateReleaseAction(releaseActionArgs)));
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const releaseService = getService('release', {
-            strapi
-        });
-        const releaseActions = await strapi.db.transaction(async ()=>{
-            const releaseActions = await Promise.all(releaseActionsArgs.map(async (releaseActionArgs)=>{
-                try {
-                    const action = await releaseActionService.create(releaseId, releaseActionArgs, {
-                        disableUpdateReleaseStatus: true
-                    });
-                    return action;
-                } catch (error) {
-                    // If the entry is already in the release, we don't want to throw an error, so we catch and ignore it
-                    if (error instanceof AlreadyOnReleaseError) {
-                        return null;
-                    }
-                    throw error;
-                }
-            }));
-            return releaseActions;
-        });
-        const newReleaseActions = releaseActions.filter((action)=>action !== null);
-        if (newReleaseActions.length > 0) {
-            releaseService.updateReleaseStatus(releaseId);
-        }
-        ctx.created({
-            data: newReleaseActions,
-            meta: {
-                entriesAlreadyInRelease: releaseActions.length - newReleaseActions.length,
-                totalEntries: releaseActions.length
-            }
-        });
-    },
-    async findMany (ctx) {
-        const releaseId = ctx.params.releaseId;
-        const permissionsManager = strapi.service('admin::permission').createPermissionsManager({
-            ability: ctx.state.userAbility,
-            model: RELEASE_ACTION_MODEL_UID
-        });
-        await validateFindManyActionsParams(ctx.query);
-        if (ctx.query.groupBy) {
-            if (![
-                'action',
-                'contentType',
-                'locale'
-            ].includes(ctx.query.groupBy)) {
-                ctx.badRequest('Invalid groupBy parameter');
-            }
-        }
-        ctx.query.sort = ctx.query.groupBy === 'action' ? 'type' : ctx.query.groupBy;
-        delete ctx.query.groupBy;
-        const query = await permissionsManager.sanitizeQuery(ctx.query);
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const { results, pagination } = await releaseActionService.findPage(releaseId, {
-            ...query
-        });
-        /**
-     * Release actions can be related to entries of different content types.
-     * We need to sanitize the entry output according to that content type.
-     * So, we group the sanitized output function by content type.
-     */ const contentTypeOutputSanitizers = results.reduce((acc, action)=>{
-            if (acc[action.contentType]) {
-                return acc;
-            }
-            const contentTypePermissionsManager = strapi.service('admin::permission').createPermissionsManager({
-                ability: ctx.state.userAbility,
-                model: action.contentType
+  async create(ctx) {
+    const releaseId = ctx.params.releaseId;
+    const releaseActionArgs = ctx.request.body;
+    await validateReleaseAction(releaseActionArgs);
+    const releaseService = getService("release", { strapi });
+    const releaseAction2 = await releaseService.createAction(releaseId, releaseActionArgs);
+    ctx.body = {
+      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, {
+              disableUpdateReleaseStatus: true
             });
-            acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
-            return acc;
-        }, {});
-        /**
-     * sanitizeOutput doesn't work if you use it directly on the Release Action model, it doesn't sanitize the entries
-     * So, we need to sanitize manually each entry inside a Release Action
-     */ const sanitizedResults = await async.map(results, async (action)=>({
-                ...action,
-                entry: action.entry ? await contentTypeOutputSanitizers[action.contentType](action.entry) : {}
-            }));
-        const groupedData = await releaseActionService.groupActions(sanitizedResults, query.sort);
-        const contentTypes = await releaseActionService.getContentTypeModelsFromActions(results);
-        const releaseService = getService('release', {
-            strapi
-        });
-        const components = await releaseService.getAllComponents();
-        ctx.body = {
-            data: groupedData,
-            meta: {
-                pagination,
-                contentTypes,
-                components
-            }
-        };
-    },
-    async update (ctx) {
-        const actionId = ctx.params.actionId;
-        const releaseId = ctx.params.releaseId;
-        const releaseActionUpdateArgs = ctx.request.body;
-        await validateReleaseActionUpdateSchema(releaseActionUpdateArgs);
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const updatedAction = await releaseActionService.update(actionId, releaseId, releaseActionUpdateArgs);
-        ctx.body = {
-            data: updatedAction
-        };
-    },
-    async delete (ctx) {
-        const actionId = ctx.params.actionId;
-        const releaseId = ctx.params.releaseId;
-        const releaseActionService = getService('release-action', {
-            strapi
-        });
-        const deletedReleaseAction = await releaseActionService.delete(actionId, releaseId);
-        ctx.body = {
-            data: deletedReleaseAction
-        };
-    }
-};
-
-const SETTINGS_SCHEMA = yup.object().shape({
-    defaultTimezone: yup.string().nullable().default(null)
-}).required().noUnknown();
-const validateSettings = validateYupSchema(SETTINGS_SCHEMA);
-
-const settingsController = {
-    async find (ctx) {
-        // Get settings
-        const settingsService = getService('settings', {
-            strapi
-        });
-        const settings = await settingsService.find();
-        // Response
-        ctx.body = {
-            data: settings
-        };
-    },
-    async update (ctx) {
-        // Data validation
-        const settingsBody = ctx.request.body;
-        const settings = await validateSettings(settingsBody);
-        // Update
-        const settingsService = getService('settings', {
-            strapi
-        });
-        const updatedSettings = await settingsService.update({
-            settings
-        });
-        // Response
-        ctx.body = {
-            data: updatedSettings
-        };
+            return action;
+          } catch (error) {
+            if (error instanceof AlreadyOnReleaseError) {
+              return null;
+            }
+            throw error;
+          }
+        })
+      );
+      return releaseActions2;
+    });
+    const newReleaseActions = releaseActions.filter((action) => action !== null);
+    if (newReleaseActions.length > 0) {
+      releaseService.updateReleaseStatus(releaseId);
     }
+    ctx.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({
+      ability: ctx.state.userAbility,
+      model: RELEASE_ACTION_MODEL_UID
+    });
+    const query = await permissionsManager.sanitizeQuery(ctx.query);
+    const releaseService = getService("release", { strapi });
+    const { results, pagination } = await releaseService.findActions(releaseId, {
+      sort: query.groupBy === "action" ? "type" : query.groupBy,
+      ...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 sanitizedResults = await 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,
+        contentTypes: contentTypes2,
+        components
+      }
+    };
+  },
+  async update(ctx) {
+    const actionId = ctx.params.actionId;
+    const releaseId = ctx.params.releaseId;
+    const releaseActionUpdateArgs = ctx.request.body;
+    await validateReleaseActionUpdateSchema(releaseActionUpdateArgs);
+    const releaseService = getService("release", { strapi });
+    const updatedAction = await releaseService.updateAction(
+      actionId,
+      releaseId,
+      releaseActionUpdateArgs
+    );
+    ctx.body = {
+      data: updatedAction
+    };
+  },
+  async delete(ctx) {
+    const actionId = ctx.params.actionId;
+    const releaseId = ctx.params.releaseId;
+    const releaseService = getService("release", { strapi });
+    const deletedReleaseAction = await releaseService.deleteAction(actionId, releaseId);
+    ctx.body = {
+      data: deletedReleaseAction
+    };
+  }
 };
-
-const controllers = {
-    release: releaseController,
-    'release-action': releaseActionController,
-    settings: settingsController
-};
-
-var release = {
-    type: 'admin',
-    routes: [
-        {
-            method: 'GET',
-            path: '/mapEntriesToReleases',
-            handler: 'release.mapEntriesToReleases',
-            config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.read'
-                            ]
-                        }
-                    }
-                ]
-            }
-        },
-        {
-            method: 'GET',
-            path: '/getByDocumentAttached',
-            handler: 'release.findByDocumentAttached',
+const controllers = { release: releaseController, "release-action": releaseActionController };
+const release = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/mapEntriesToReleases",
+      handler: "release.mapEntriesToReleases",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.read'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.read"]
             }
-        },
-        {
-            method: 'POST',
-            path: '/',
-            handler: 'release.create',
+          }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/",
+      handler: "release.create",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.create'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.create"]
             }
-        },
-        {
-            method: 'GET',
-            path: '/',
-            handler: 'release.findPage',
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/",
+      handler: "release.findMany",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.read'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.read"]
             }
-        },
-        {
-            method: 'GET',
-            path: '/:id',
-            handler: 'release.findOne',
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/:id",
+      handler: "release.findOne",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.read'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.read"]
             }
-        },
-        {
-            method: 'PUT',
-            path: '/:id',
-            handler: 'release.update',
+          }
+        ]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/:id",
+      handler: "release.update",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.update'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.update"]
             }
-        },
-        {
-            method: 'DELETE',
-            path: '/:id',
-            handler: 'release.delete',
+          }
+        ]
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/:id",
+      handler: "release.delete",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.delete'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.delete"]
             }
-        },
-        {
-            method: 'POST',
-            path: '/:id/publish',
-            handler: 'release.publish',
+          }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/:id/publish",
+      handler: "release.publish",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.publish'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.publish"]
             }
-        }
-    ]
+          }
+        ]
+      }
+    }
+  ]
 };
-
-var releaseAction = {
-    type: 'admin',
-    routes: [
-        {
-            method: 'POST',
-            path: '/:releaseId/actions',
-            handler: 'release-action.create',
-            config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.create-action'
-                            ]
-                        }
-                    }
-                ]
-            }
-        },
-        {
-            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',
-            handler: 'release-action.findMany',
+const releaseAction = {
+  type: "admin",
+  routes: [
+    {
+      method: "POST",
+      path: "/:releaseId/actions",
+      handler: "release-action.create",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.read'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.create-action"]
             }
-        },
-        {
-            method: 'PUT',
-            path: '/:releaseId/actions/:actionId',
-            handler: 'release-action.update',
+          }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/:releaseId/actions/bulk",
+      handler: "release-action.createMany",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.update'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.create-action"]
             }
-        },
-        {
-            method: 'DELETE',
-            path: '/:releaseId/actions/:actionId',
-            handler: 'release-action.delete',
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/:releaseId/actions",
+      handler: "release-action.findMany",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.delete-action'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.read"]
             }
-        }
-    ]
-};
-
-var settings = {
-    type: 'admin',
-    routes: [
-        {
-            method: 'GET',
-            path: '/settings',
-            handler: 'settings.find',
+          }
+        ]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/:releaseId/actions/:actionId",
+      handler: "release-action.update",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.settings.read'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.update"]
             }
-        },
-        {
-            method: 'PUT',
-            path: '/settings',
-            handler: 'settings.update',
+          }
+        ]
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/:releaseId/actions/:actionId",
+      handler: "release-action.delete",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
             config: {
-                policies: [
-                    'admin::isAuthenticatedAdmin',
-                    {
-                        name: 'admin::hasPermissions',
-                        config: {
-                            actions: [
-                                'plugin::content-releases.settings.update'
-                            ]
-                        }
-                    }
-                ]
+              actions: ["plugin::content-releases.delete-action"]
             }
-        }
-    ]
+          }
+        ]
+      }
+    }
+  ]
 };
-
 const routes = {
-    settings,
-    release,
-    'release-action': releaseAction
+  release,
+  "release-action": releaseAction
 };
-
-const getPlugin = ()=>{
-    if (strapi.ee.features.isEnabled('cms-content-releases')) {
-        return {
-            register,
-            bootstrap,
-            destroy,
-            contentTypes,
-            services,
-            controllers,
-            routes
-        };
-    }
+const { features } = require("@strapi/strapi/dist/utils/ee");
+const getPlugin = () => {
+  if (features.isEnabled("cms-content-releases")) {
     return {
-        // Always return register, it handles its own feature check
-        register,
-        // Always return contentTypes to avoid losing data when the feature is disabled
-        contentTypes
+      register,
+      bootstrap,
+      destroy,
+      contentTypes,
+      services,
+      controllers,
+      routes
     };
+  }
+  return {
+    // Always return register, it handles its own feature check
+    register,
+    // Always return contentTypes to avoid losing data when the feature is disabled
+    contentTypes
+  };
+};
+const index = getPlugin();
+export {
+  index as default
 };
-var index = getPlugin();
-
-export { index as default };
 //# sourceMappingURL=index.mjs.map