@strapi/content-releases 0.0.0-experimental.e3e48deb89bd0a1b6cc69b698696566fa7854a95 → 0.0.0-experimental.e47108ccbbc4ad1bfaf4526fa6b70d6ace1ca7a9

package/dist/server/index.js

@@ -3,6 +3,7 @@ const utils = require("@strapi/utils");
 const isEqual = require("lodash/isEqual");
 const lodash = require("lodash");
 const _ = require("lodash/fp");
+const EE = require("@strapi/strapi/dist/utils/ee");
 const nodeSchedule = require("node-schedule");
 const yup = require("yup");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
@@ -26,6 +27,7 @@ function _interopNamespace(e) {
 }
 const isEqual__default = /* @__PURE__ */ _interopDefault(isEqual);
 const ___default = /* @__PURE__ */ _interopDefault(_);
+const EE__default = /* @__PURE__ */ _interopDefault(EE);
 const yup__namespace = /* @__PURE__ */ _interopNamespace(yup);
 const RELEASE_MODEL_UID = "plugin::content-releases.release";
 const RELEASE_ACTION_MODEL_UID = "plugin::content-releases.release-action";
@@ -82,10 +84,7 @@ const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
 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.db.query(contentTypeUid).findOne({
-    where: { id: entryId },
-    populate
-  });
+  const entry = await strapi2.entityService.findOne(contentTypeUid, entryId, { populate });
   return entry;
 };
 const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } = { strapi: global.strapi }) => {
@@ -102,10 +101,28 @@ const getEntryValidStatus = async (contentTypeUid, entry, { strapi: strapi2 } =
     return false;
   }
 };
+async function deleteActionsOnDisableDraftAndPublish({
+  oldContentTypes,
+  contentTypes: contentTypes2
+}) {
+  if (!oldContentTypes) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    if (utils.contentTypes.hasDraftAndPublish(oldContentType) && !utils.contentTypes.hasDraftAndPublish(contentType)) {
+      await strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: uid }).execute();
+    }
+  }
+}
 async function deleteActionsOnDeleteContentType({ oldContentTypes, contentTypes: contentTypes2 }) {
   const deletedContentTypes = lodash.difference(lodash.keys(oldContentTypes), lodash.keys(contentTypes2)) ?? [];
   if (deletedContentTypes.length) {
-    await utils.async.map(deletedContentTypes, async (deletedContentTypeUID) => {
+    await utils.mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
       return strapi.db?.queryBuilder(RELEASE_ACTION_MODEL_UID).delete().where({ contentType: deletedContentTypeUID }).execute();
     });
   }
@@ -124,7 +141,7 @@ async function migrateIsValidAndStatusReleases() {
       }
     }
   });
-  utils.async.map(releasesWithoutStatus, async (release2) => {
+  utils.mapAsync(releasesWithoutStatus, async (release2) => {
     const actions = release2.actions;
     const notValidatedActions = actions.filter((action) => action.isEntryValid === null);
     for (const action of notValidatedActions) {
@@ -155,7 +172,7 @@ async function migrateIsValidAndStatusReleases() {
       }
     }
   });
-  utils.async.map(publishedReleases, async (release2) => {
+  utils.mapAsync(publishedReleases, async (release2) => {
     return strapi.db.query(RELEASE_MODEL_UID).update({
       where: {
         id: release2.id
@@ -168,9 +185,11 @@ async function migrateIsValidAndStatusReleases() {
 }
 async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: contentTypes2 }) {
   if (oldContentTypes !== void 0 && contentTypes2 !== void 0) {
-    const contentTypesWithDraftAndPublish = Object.keys(oldContentTypes);
+    const contentTypesWithDraftAndPublish = Object.keys(oldContentTypes).filter(
+      (uid) => oldContentTypes[uid]?.options?.draftAndPublish
+    );
     const releasesAffected = /* @__PURE__ */ new Set();
-    utils.async.map(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
+    utils.mapAsync(contentTypesWithDraftAndPublish, async (contentTypeUID) => {
       const oldContentType = oldContentTypes[contentTypeUID];
       const contentType = contentTypes2[contentTypeUID];
       if (!isEqual__default.default(oldContentType?.attributes, contentType?.attributes)) {
@@ -183,8 +202,8 @@ async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: co
             release: true
           }
         });
-        await utils.async.map(actions, async (action) => {
-          if (action.entry) {
+        await utils.mapAsync(actions, async (action) => {
+          if (action.entry && action.release) {
             const populatedEntry = await getPopulatedEntry(contentTypeUID, action.entry.id, {
               strapi
             });
@@ -206,21 +225,71 @@ async function revalidateChangedContentTypes({ oldContentTypes, contentTypes: co
         });
       }
     }).then(() => {
-      utils.async.map(releasesAffected, async (releaseId) => {
+      utils.mapAsync(releasesAffected, async (releaseId) => {
         return getService("release", { strapi }).updateReleaseStatus(releaseId);
       });
     });
   }
 }
+async function disableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (!oldContentTypes) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    const i18nPlugin = strapi.plugin("i18n");
+    const { isLocalizedContentType } = i18nPlugin.service("content-types");
+    if (isLocalizedContentType(oldContentType) && !isLocalizedContentType(contentType)) {
+      await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
+        locale: null
+      }).where({ contentType: uid }).execute();
+    }
+  }
+}
+async function enableContentTypeLocalized({ oldContentTypes, contentTypes: contentTypes2 }) {
+  if (!oldContentTypes) {
+    return;
+  }
+  for (const uid in contentTypes2) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes2[uid];
+    const i18nPlugin = strapi.plugin("i18n");
+    const { isLocalizedContentType } = i18nPlugin.service("content-types");
+    const { getDefaultLocale } = i18nPlugin.service("locales");
+    if (!isLocalizedContentType(oldContentType) && isLocalizedContentType(contentType)) {
+      const defaultLocale = await getDefaultLocale();
+      await strapi.db.queryBuilder(RELEASE_ACTION_MODEL_UID).update({
+        locale: defaultLocale
+      }).where({ contentType: uid }).execute();
+    }
+  }
+}
+const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
 const register = async ({ strapi: strapi2 }) => {
-  if (strapi2.ee.features.isEnabled("cms-content-releases")) {
+  if (features$2.isEnabled("cms-content-releases")) {
     await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
-    strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType).register(revalidateChangedContentTypes).register(migrateIsValidAndStatusReleases);
+    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 (strapi2.ee.features.isEnabled("cms-content-releases")) {
-    const contentTypesWithDraftAndPublish = Object.keys(strapi2.contentTypes);
+  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) {
@@ -256,7 +325,7 @@ const bootstrap = async ({ strapi: strapi2 }) => {
        */
       async beforeDeleteMany(event) {
         const { model, params } = event;
-        if (model.kind === "collectionType") {
+        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;
@@ -338,27 +407,23 @@ const bootstrap = async ({ strapi: strapi2 }) => {
         }
       }
     });
-    if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-      getService("scheduling", { strapi: strapi2 }).syncFromDatabase().catch((err) => {
-        strapi2.log.error(
-          "Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling."
-        );
-        throw err;
-      });
-      Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
-        strapi2.webhookStore.addAllowedEvent(key, value);
-      });
-    }
+    getService("scheduling", { strapi: strapi2 }).syncFromDatabase().catch((err) => {
+      strapi2.log.error(
+        "Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling."
+      );
+      throw err;
+    });
+    Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
+      strapi2.webhookStore.addAllowedEvent(key, value);
+    });
   }
 };
 const destroy = async ({ strapi: strapi2 }) => {
-  if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-    const scheduledJobs = getService("scheduling", {
-      strapi: strapi2
-    }).getAll();
-    for (const [, job] of scheduledJobs) {
-      job.cancel();
-    }
+  const scheduledJobs = getService("scheduling", {
+    strapi: strapi2
+  }).getAll();
+  for (const [, job] of scheduledJobs) {
+    job.cancel();
   }
 };
 const schema$1 = {
@@ -483,6 +548,94 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       release: release2
     });
   };
+  const publishSingleTypeAction = async (uid, actionType, entryId) => {
+    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+    const entry = await strapi2.entityService.findOne(uid, entryId, { populate });
+    try {
+      if (actionType === "publish") {
+        await entityManagerService.publish(entry, uid);
+      } else {
+        await entityManagerService.unpublish(entry, uid);
+      }
+    } catch (error) {
+      if (error instanceof utils.errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft"))
+        ;
+      else {
+        throw error;
+      }
+    }
+  };
+  const publishCollectionTypeAction = async (uid, entriesToPublishIds, entriestoUnpublishIds) => {
+    const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
+    const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+    const entriesToPublish = await strapi2.entityService.findMany(uid, {
+      filters: {
+        id: {
+          $in: entriesToPublishIds
+        }
+      },
+      populate
+    });
+    const entriesToUnpublish = await strapi2.entityService.findMany(uid, {
+      filters: {
+        id: {
+          $in: entriestoUnpublishIds
+        }
+      },
+      populate
+    });
+    if (entriesToPublish.length > 0) {
+      await entityManagerService.publishMany(entriesToPublish, uid);
+    }
+    if (entriesToUnpublish.length > 0) {
+      await entityManagerService.unpublishMany(entriesToUnpublish, uid);
+    }
+  };
+  const getFormattedActions = async (releaseId) => {
+    const actions = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).findMany({
+      where: {
+        release: {
+          id: releaseId
+        }
+      },
+      populate: {
+        entry: {
+          fields: ["id"]
+        }
+      }
+    });
+    if (actions.length === 0) {
+      throw new utils.errors.ValidationError("No entries to publish");
+    }
+    const collectionTypeActions = {};
+    const singleTypeActions = [];
+    for (const action of actions) {
+      const contentTypeUid = action.contentType;
+      if (strapi2.contentTypes[contentTypeUid].kind === "collectionType") {
+        if (!collectionTypeActions[contentTypeUid]) {
+          collectionTypeActions[contentTypeUid] = {
+            entriesToPublishIds: [],
+            entriesToUnpublishIds: []
+          };
+        }
+        if (action.type === "publish") {
+          collectionTypeActions[contentTypeUid].entriesToPublishIds.push(action.entry.id);
+        } else {
+          collectionTypeActions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
+        }
+      } else {
+        singleTypeActions.push({
+          uid: contentTypeUid,
+          action: action.type,
+          id: action.entry.id
+        });
+      }
+    }
+    return { collectionTypeActions, singleTypeActions };
+  };
   return {
     async create(releaseData, { user }) {
       const releaseWithCreatorFields = await utils.setCreatorFields({ user })(releaseData);
@@ -496,13 +649,13 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
         validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
       ]);
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).create({
+      const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
         data: {
           ...releaseWithCreatorFields,
           status: "empty"
         }
       });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && releaseWithCreatorFields.scheduledAt) {
+      if (releaseWithCreatorFields.scheduledAt) {
         const schedulingService = getService("scheduling", { strapi: strapi2 });
         await schedulingService.set(release2.id, release2.scheduledAt);
       }
@@ -510,19 +663,17 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return release2;
     },
     async findOne(id, query = {}) {
-      const dbQuery = utils.convertQueryParams.transformParamsToQuery(RELEASE_MODEL_UID, query);
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-        ...dbQuery,
-        where: { id }
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
+        ...query
       });
       return release2;
     },
     findPage(query) {
-      const dbQuery = utils.convertQueryParams.transformParamsToQuery(RELEASE_MODEL_UID, query ?? {});
-      return strapi2.db.query(RELEASE_MODEL_UID).findPage({
-        ...dbQuery,
+      return strapi2.entityService.findPage(RELEASE_MODEL_UID, {
+        ...query,
         populate: {
           actions: {
+            // @ts-expect-error Ignore missing properties
             count: true
           }
         }
@@ -614,24 +765,26 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
         validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
       ]);
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id } });
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
       if (!release2) {
         throw new utils.errors.NotFoundError(`No release found for id ${id}`);
       }
       if (release2.releasedAt) {
         throw new utils.errors.ValidationError("Release already published");
       }
-      const updatedRelease = await strapi2.db.query(RELEASE_MODEL_UID).update({
-        where: { id },
+      const updatedRelease = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
+        /*
+         * The type returned from the entity service: Partial<Input<"plugin::content-releases.release">>
+         * is not compatible with the type we are passing here: UpdateRelease.Request['body']
+         */
+        // @ts-expect-error see above
         data: releaseWithCreatorFields
       });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
-        const schedulingService = getService("scheduling", { strapi: strapi2 });
-        if (releaseData.scheduledAt) {
-          await schedulingService.set(id, releaseData.scheduledAt);
-        } else if (release2.scheduledAt) {
-          schedulingService.cancel(id);
-        }
+      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");
@@ -645,7 +798,7 @@ const createReleaseService = ({ strapi: strapi2 }) => {
         validateEntryContentType(action.entry.contentType),
         validateUniqueEntry(releaseId, action)
       ]);
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: releaseId } });
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
       if (!release2) {
         throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
       }
@@ -655,7 +808,7 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       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.db.query(RELEASE_ACTION_MODEL_UID).create({
+      const releaseAction2 = await strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
         data: {
           type,
           contentType: entry.contentType,
@@ -668,41 +821,32 @@ const createReleaseService = ({ strapi: strapi2 }) => {
           },
           release: releaseId
         },
-        populate: { release: { select: ["id"] }, entry: { select: ["id"] } }
+        populate: { release: { fields: ["id"] }, entry: { fields: ["id"] } }
       });
       this.updateReleaseStatus(releaseId);
       return releaseAction2;
     },
     async findActions(releaseId, query) {
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-        where: { id: releaseId },
-        select: ["id"]
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+        fields: ["id"]
       });
       if (!release2) {
         throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
       }
-      const dbQuery = utils.convertQueryParams.transformParamsToQuery(
-        RELEASE_ACTION_MODEL_UID,
-        query ?? {}
-      );
-      return strapi2.db.query(RELEASE_ACTION_MODEL_UID).findPage({
-        ...dbQuery,
+      return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
+        ...query,
         populate: {
           entry: {
             populate: "*"
           }
         },
-        where: {
+        filters: {
           release: releaseId
         }
       });
     },
     async countActions(query) {
-      const dbQuery = utils.convertQueryParams.transformParamsToQuery(
-        RELEASE_ACTION_MODEL_UID,
-        query ?? {}
-      );
-      return strapi2.db.query(RELEASE_ACTION_MODEL_UID).count(dbQuery);
+      return strapi2.entityService.count(RELEASE_ACTION_MODEL_UID, query);
     },
     async groupActions(actions, groupBy) {
       const contentTypeUids = actions.reduce((acc, action) => {
@@ -783,11 +927,10 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return componentsMap;
     },
     async delete(releaseId) {
-      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-        where: { id: releaseId },
+      const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
         populate: {
           actions: {
-            select: ["id"]
+            fields: ["id"]
           }
         }
       });
@@ -805,13 +948,9 @@ const createReleaseService = ({ strapi: strapi2 }) => {
             }
           }
         });
-        await strapi2.db.query(RELEASE_MODEL_UID).delete({
-          where: {
-            id: releaseId
-          }
-        });
+        await strapi2.entityService.delete(RELEASE_MODEL_UID, releaseId);
       });
-      if (strapi2.features.future.isEnabled("contentReleasesScheduling") && release2.scheduledAt) {
+      if (release2.scheduledAt) {
         const schedulingService = getService("scheduling", { strapi: strapi2 });
         await schedulingService.cancel(release2.id);
       }
@@ -819,132 +958,71 @@ const createReleaseService = ({ strapi: strapi2 }) => {
       return release2;
     },
     async publish(releaseId) {
-      try {
-        const releaseWithPopulatedActionEntries = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-          where: { id: releaseId },
-          populate: {
-            actions: {
-              populate: {
-                entry: {
-                  select: ["id"]
-                }
-              }
-            }
-          }
-        });
-        if (!releaseWithPopulatedActionEntries) {
+      const {
+        release: release2,
+        error
+      } = await strapi2.db.transaction(async ({ trx }) => {
+        const lockedRelease = await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).select(["id", "name", "releasedAt", "status"]).first().transacting(trx).forUpdate().execute();
+        if (!lockedRelease) {
           throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
         }
-        if (releaseWithPopulatedActionEntries.releasedAt) {
+        if (lockedRelease.releasedAt) {
           throw new utils.errors.ValidationError("Release already published");
         }
-        if (releaseWithPopulatedActionEntries.actions.length === 0) {
-          throw new utils.errors.ValidationError("No entries to publish");
-        }
-        const collectionTypeActions = {};
-        const singleTypeActions = [];
-        for (const action of releaseWithPopulatedActionEntries.actions) {
-          const contentTypeUid = action.contentType;
-          if (strapi2.contentTypes[contentTypeUid].kind === "collectionType") {
-            if (!collectionTypeActions[contentTypeUid]) {
-              collectionTypeActions[contentTypeUid] = {
-                entriestoPublishIds: [],
-                entriesToUnpublishIds: []
-              };
-            }
-            if (action.type === "publish") {
-              collectionTypeActions[contentTypeUid].entriestoPublishIds.push(action.entry.id);
-            } else {
-              collectionTypeActions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
-            }
-          } else {
-            singleTypeActions.push({
-              uid: contentTypeUid,
-              action: action.type,
-              id: action.entry.id
-            });
-          }
+        if (lockedRelease.status === "failed") {
+          throw new utils.errors.ValidationError("Release failed to publish");
         }
-        const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
-        const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
-        await strapi2.db.transaction(async () => {
-          for (const { uid, action, id } of singleTypeActions) {
-            const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
-            const entry = await strapi2.db.query(uid).findOne({ where: { id }, populate });
-            try {
-              if (action === "publish") {
-                await entityManagerService.publish(entry, uid);
-              } else {
-                await entityManagerService.unpublish(entry, uid);
-              }
-            } catch (error) {
-              if (error instanceof utils.errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft")) {
-              } else {
-                throw error;
-              }
-            }
-          }
-          for (const contentTypeUid of Object.keys(collectionTypeActions)) {
-            const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
-            const { entriestoPublishIds, entriesToUnpublishIds } = collectionTypeActions[contentTypeUid];
-            const entriesToPublish = await strapi2.db.query(contentTypeUid).findMany({
-              where: {
-                id: {
-                  $in: entriestoPublishIds
-                }
-              },
-              populate
-            });
-            const entriesToUnpublish = await strapi2.db.query(contentTypeUid).findMany({
-              where: {
-                id: {
-                  $in: entriesToUnpublishIds
-                }
-              },
-              populate
-            });
-            if (entriesToPublish.length > 0) {
-              await entityManagerService.publishMany(entriesToPublish, contentTypeUid);
+        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);
             }
-            if (entriesToUnpublish.length > 0) {
-              await entityManagerService.unpublishMany(entriesToUnpublish, contentTypeUid);
+            for (const contentTypeUid of Object.keys(collectionTypeActions)) {
+              const uid = contentTypeUid;
+              await publishCollectionTypeAction(
+                uid,
+                collectionTypeActions[uid].entriesToPublishIds,
+                collectionTypeActions[uid].entriesToUnpublishIds
+              );
             }
-          }
-        });
-        const release2 = await strapi2.db.query(RELEASE_MODEL_UID).update({
-          where: { id: releaseId },
-          data: {
-            releasedAt: /* @__PURE__ */ new Date()
-          },
-          populate: {
-            actions: {
-              count: true
+          });
+          const release22 = await strapi2.db.query(RELEASE_MODEL_UID).update({
+            where: {
+              id: releaseId
+            },
+            data: {
+              status: "done",
+              releasedAt: /* @__PURE__ */ new Date()
             }
-          }
-        });
-        if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+          });
           dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
             isPublished: true,
-            release: release2
+            release: release22
           });
-        }
-        strapi2.telemetry.send("didPublishContentRelease");
-        return release2;
-      } catch (error) {
-        if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+          strapi2.telemetry.send("didPublishContentRelease");
+          return { release: release22, error: null };
+        } catch (error2) {
           dispatchWebhook(ALLOWED_WEBHOOK_EVENTS.RELEASES_PUBLISH, {
             isPublished: false,
-            error
+            error: error2
           });
-        }
-        strapi2.db.query(RELEASE_MODEL_UID).update({
-          where: { id: releaseId },
-          data: {
+          await strapi2.db?.queryBuilder(RELEASE_MODEL_UID).where({ id: releaseId }).update({
             status: "failed"
-          }
-        });
+          }).transacting(trx).execute();
+          return {
+            release: null,
+            error: error2
+          };
+        }
+      });
+      if (error) {
         throw error;
       }
+      return release2;
     },
     async updateAction(actionId, releaseId, update) {
       const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
@@ -1031,13 +1109,16 @@ const createReleaseService = ({ strapi: strapi2 }) => {
     }
   };
 };
+class AlreadyOnReleaseError extends utils.errors.ApplicationError {
+  constructor(message) {
+    super(message);
+    this.name = "AlreadyOnReleaseError";
+  }
+}
 const createReleaseValidationService = ({ strapi: strapi2 }) => ({
   async validateUniqueEntry(releaseId, releaseActionArgs) {
-    const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({
-      where: {
-        id: releaseId
-      },
-      populate: { actions: { populate: { entry: { select: ["id"] } } } }
+    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+      populate: { actions: { populate: { entry: { fields: ["id"] } } } }
     });
     if (!release2) {
       throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
@@ -1046,7 +1127,7 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
       (action) => Number(action.entry.id) === Number(releaseActionArgs.entry.id) && action.contentType === releaseActionArgs.entry.contentType
     );
     if (isEntryInRelease) {
-      throw new utils.errors.ValidationError(
+      throw new AlreadyOnReleaseError(
         `Entry with id ${releaseActionArgs.entry.id} and contentType ${releaseActionArgs.entry.contentType} already exists in release with id ${releaseId}`
       );
     }
@@ -1056,9 +1137,17 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
     if (!contentType) {
       throw new utils.errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
     }
+    if (!contentType.options?.draftAndPublish) {
+      throw new utils.errors.ValidationError(
+        `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`
+      );
+    }
   },
   async validatePendingReleasesLimit() {
-    const maximumPendingReleases = strapi2.ee.features.get("cms-content-releases")?.options?.maximumReleases || 3;
+    const maximumPendingReleases = (
+      // @ts-expect-error - options is not typed into features
+      EE__default.default.features.get("cms-content-releases")?.options?.maximumReleases || 3
+    );
     const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
       filters: {
         releasedAt: {
@@ -1071,8 +1160,8 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
     }
   },
   async validateUniqueNameForPendingRelease(name, id) {
-    const pendingReleases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
-      where: {
+    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
+      filters: {
         releasedAt: {
           $null: true
         },
@@ -1146,7 +1235,7 @@ const createSchedulingService = ({ strapi: strapi2 }) => {
 const services = {
   release: createReleaseService,
   "release-validation": createReleaseValidationService,
-  ...strapi.features.future.isEnabled("contentReleasesScheduling") ? { scheduling: createSchedulingService } : {}
+  scheduling: createSchedulingService
 };
 const RELEASE_SCHEMA = yup__namespace.object().shape({
   name: yup__namespace.string().trim().required(),
@@ -1199,7 +1288,7 @@ const releaseController = {
           }
         };
       });
-      const pendingReleasesCount = await strapi.db.query(RELEASE_MODEL_UID).count({
+      const pendingReleasesCount = await strapi.query(RELEASE_MODEL_UID).count({
         where: {
           releasedAt: null
         }
@@ -1322,6 +1411,38 @@ const releaseActionController = {
       data: releaseAction2
     };
   },
+  async createMany(ctx) {
+    const releaseId = ctx.params.releaseId;
+    const releaseActionsArgs = ctx.request.body;
+    await Promise.all(
+      releaseActionsArgs.map((releaseActionArgs) => validateReleaseAction(releaseActionArgs))
+    );
+    const releaseService = getService("release", { strapi });
+    const releaseActions = await strapi.db.transaction(async () => {
+      const releaseActions2 = await Promise.all(
+        releaseActionsArgs.map(async (releaseActionArgs) => {
+          try {
+            const action = await releaseService.createAction(releaseId, releaseActionArgs);
+            return action;
+          } catch (error) {
+            if (error instanceof AlreadyOnReleaseError) {
+              return null;
+            }
+            throw error;
+          }
+        })
+      );
+      return releaseActions2;
+    });
+    const newReleaseActions = releaseActions.filter((action) => action !== null);
+    ctx.body = {
+      data: newReleaseActions,
+      meta: {
+        entriesAlreadyInRelease: releaseActions.length - newReleaseActions.length,
+        totalEntries: releaseActions.length
+      }
+    };
+  },
   async findMany(ctx) {
     const releaseId = ctx.params.releaseId;
     const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
@@ -1345,7 +1466,7 @@ const releaseActionController = {
       acc[action.contentType] = contentTypePermissionsManager.sanitizeOutput;
       return acc;
     }, {});
-    const sanitizedResults = await utils.async.map(results, async (action) => ({
+    const sanitizedResults = await utils.mapAsync(results, async (action) => ({
       ...action,
       entry: await contentTypeOutputSanitizers[action.contentType](action.entry)
     }));
@@ -1507,6 +1628,22 @@ const releaseAction = {
         ]
       }
     },
+    {
+      method: "POST",
+      path: "/:releaseId/actions/bulk",
+      handler: "release-action.createMany",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: ["plugin::content-releases.create-action"]
+            }
+          }
+        ]
+      }
+    },
     {
       method: "GET",
       path: "/:releaseId/actions",
@@ -1561,8 +1698,9 @@ const routes = {
   release,
   "release-action": releaseAction
 };
+const { features } = require("@strapi/strapi/dist/utils/ee");
 const getPlugin = () => {
-  if (strapi.ee.features.isEnabled("cms-content-releases")) {
+  if (features.isEnabled("cms-content-releases")) {
     return {
       register,
       bootstrap,
@@ -1574,6 +1712,9 @@ const getPlugin = () => {
     };
   }
   return {
+    // Always return register, it handles its own feature check
+    register,
+    // Always return contentTypes to avoid losing data when the feature is disabled
     contentTypes
   };
 };