@strapi/content-releases 0.0.0-experimental.f7b9b47085e387e97f990d8695971b51d7f7149a → 0.0.0-next.2b10ca9b97a5854909ba0a8d1d5b00f73cae58fa

package/dist/server/index.mjs

@@ -1,4 +1,6 @@
 import { setCreatorFields, errors, validateYupSchema, yup as yup$1 } from "@strapi/utils";
+import _ from "lodash/fp";
+import EE from "@strapi/strapi/dist/utils/ee";
 import * as yup from "yup";
 const RELEASE_MODEL_UID = "plugin::content-releases.release";
 const RELEASE_ACTION_MODEL_UID = "plugin::content-releases.release-action";
@@ -46,10 +48,80 @@ const ACTIONS = [
     pluginName: "content-releases"
   }
 ];
-const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
+const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  return strapi2.plugin("content-releases").service(name);
+};
+const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
 const register = async ({ strapi: strapi2 }) => {
-  if (features$1.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
+  if (features$2.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
     await strapi2.admin.services.permission.actionProvider.registerMany(ACTIONS);
+    const releaseActionService = getService("release-action", { strapi: strapi2 });
+    const eventManager = getService("event-manager", { strapi: strapi2 });
+    const destroyContentTypeUpdateListener = strapi2.eventHub.on(
+      "content-type.update",
+      async ({ contentType }) => {
+        if (contentType.schema.options.draftAndPublish === false) {
+          await releaseActionService.deleteManyForContentType(contentType.uid);
+        }
+      }
+    );
+    eventManager.addDestroyListenerCallback(destroyContentTypeUpdateListener);
+    const destroyContentTypeDeleteListener = strapi2.eventHub.on(
+      "content-type.delete",
+      async ({ contentType }) => {
+        await releaseActionService.deleteManyForContentType(contentType.uid);
+      }
+    );
+    eventManager.addDestroyListenerCallback(destroyContentTypeDeleteListener);
+  }
+};
+const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
+const bootstrap = async ({ strapi: strapi2 }) => {
+  if (features$1.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
+    strapi2.db.lifecycles.subscribe({
+      afterDelete(event) {
+        const { model, result } = event;
+        if (model.kind === "collectionType" && model.options.draftAndPublish) {
+          const { id } = result;
+          strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+            where: {
+              target_type: model.uid,
+              target_id: id
+            }
+          });
+        }
+      },
+      /**
+       * deleteMany hook doesn't return the deleted entries ids
+       * so we need to fetch them before deleting the entries to save the ids on our state
+       */
+      async beforeDeleteMany(event) {
+        const { model, params } = event;
+        if (model.kind === "collectionType" && model.options.draftAndPublish) {
+          const { where } = params;
+          const entriesToDelete = await strapi2.db.query(model.uid).findMany({ select: ["id"], where });
+          event.state.entriesToDelete = entriesToDelete;
+        }
+      },
+      /**
+       * We delete the release actions related to deleted entries
+       * We make this only after deleteMany is succesfully executed to avoid errors
+       */
+      async afterDeleteMany(event) {
+        const { model, state } = event;
+        const entriesToDelete = state.entriesToDelete;
+        if (entriesToDelete) {
+          await strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+            where: {
+              target_type: model.uid,
+              target_id: {
+                $in: entriesToDelete.map((entry) => entry.id)
+              }
+            }
+          });
+        }
+      }
+    });
   }
 };
 const schema$1 = {
@@ -122,6 +194,9 @@ const schema = {
       type: "string",
       required: true
     },
+    locale: {
+      type: "string"
+    },
     release: {
       type: "relation",
       relation: "manyToOne",
@@ -137,12 +212,31 @@ const contentTypes = {
   release: release$1,
   "release-action": releaseAction$1
 };
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.plugin("content-releases").service(name);
+const createReleaseActionService = ({ strapi: strapi2 }) => ({
+  async deleteManyForContentType(contentTypeUid) {
+    return strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+      where: {
+        target_type: contentTypeUid
+      }
+    });
+  }
+});
+const getGroupName = (queryValue) => {
+  switch (queryValue) {
+    case "contentType":
+      return "entry.contentType.displayName";
+    case "action":
+      return "type";
+    case "locale":
+      return _.getOr("No locale", "entry.locale.name");
+    default:
+      return "entry.contentType.displayName";
+  }
 };
 const createReleaseService = ({ strapi: strapi2 }) => ({
   async create(releaseData, { user }) {
     const releaseWithCreatorFields = await setCreatorFields({ user })(releaseData);
+    await getService("release-validation", { strapi: strapi2 }).validatePendingReleasesLimit();
     return strapi2.entityService.create(RELEASE_MODEL_UID, {
       data: releaseWithCreatorFields
     });
@@ -224,19 +318,23 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     });
   },
   async update(id, releaseData, { user }) {
-    const updatedRelease = await setCreatorFields({ user, isEdition: true })(releaseData);
-    const release2 = await strapi2.entityService.update(RELEASE_MODEL_UID, id, {
+    const releaseWithCreatorFields = await setCreatorFields({ user, isEdition: true })(releaseData);
+    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: updatedRelease
+      data: releaseWithCreatorFields
     });
-    if (!release2) {
-      throw new errors.NotFoundError(`No release found for id ${id}`);
-    }
-    return release2;
+    return updatedRelease;
   },
   async createAction(releaseId, action) {
     const { validateEntryContentType, validateUniqueEntry } = getService("release-validation", {
@@ -246,11 +344,19 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       validateEntryContentType(action.entry.contentType),
       validateUniqueEntry(releaseId, action)
     ]);
+    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
+    if (!release2) {
+      throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+    }
+    if (release2.releasedAt) {
+      throw new errors.ValidationError("Release already published");
+    }
     const { entry, type } = action;
     return strapi2.entityService.create(RELEASE_ACTION_MODEL_UID, {
       data: {
         type,
         contentType: entry.contentType,
+        locale: entry.locale,
         entry: {
           id: entry.id,
           __type: entry.contentType,
@@ -262,8 +368,10 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     });
   },
   async findActions(releaseId, query) {
-    const result = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId);
-    if (!result) {
+    const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, releaseId, {
+      fields: ["id"]
+    });
+    if (!release2) {
       throw new errors.NotFoundError(`No release found for id ${releaseId}`);
     }
     return strapi2.entityService.findPage(RELEASE_ACTION_MODEL_UID, {
@@ -279,18 +387,40 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
   async countActions(query) {
     return strapi2.entityService.count(RELEASE_ACTION_MODEL_UID, query);
   },
-  async getAllContentTypeUids(releaseId) {
-    const contentTypesFromReleaseActions = await strapi2.db.queryBuilder(RELEASE_ACTION_MODEL_UID).select("content_type").where({
-      $and: [
-        {
-          release: releaseId
+  async groupActions(actions, groupBy) {
+    const contentTypeUids = actions.reduce((acc, action) => {
+      if (!acc.includes(action.contentType)) {
+        acc.push(action.contentType);
+      }
+      return acc;
+    }, []);
+    const allReleaseContentTypesDictionary = await this.getContentTypesDataForActions(
+      contentTypeUids
+    );
+    const allLocales = await strapi2.plugin("i18n").service("locales").find();
+    const allLocalesDictionary = allLocales.reduce((acc, locale) => {
+      acc[locale.code] = { name: locale.name, code: locale.code };
+      return acc;
+    }, {});
+    const formattedData = actions.map((action) => {
+      const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
+      return {
+        ...action,
+        entry: {
+          id: action.entry.id,
+          contentType: {
+            displayName,
+            mainFieldValue: action.entry[mainField]
+          },
+          locale: action.locale ? allLocalesDictionary[action.locale] : null,
+          status: action.entry.publishedAt ? "published" : "draft"
         }
-      ]
-    }).groupBy("content_type").execute();
-    return contentTypesFromReleaseActions.map(({ contentType: contentTypeUid }) => contentTypeUid);
+      };
+    });
+    const groupName = getGroupName(groupBy);
+    return _.groupBy(groupName)(formattedData);
   },
-  async getContentTypesDataForActions(releaseId) {
-    const contentTypesUids = await this.getAllContentTypeUids(releaseId);
+  async getContentTypesDataForActions(contentTypesUids) {
     const contentManagerContentTypeService = strapi2.plugin("content-manager").service("content-types");
     const contentTypesData = {};
     for (const contentTypeUid of contentTypesUids) {
@@ -395,13 +525,18 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     const updatedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).update({
       where: {
         id: actionId,
-        release: releaseId
+        release: {
+          id: releaseId,
+          releasedAt: {
+            $null: true
+          }
+        }
       },
       data: update
     });
     if (!updatedAction) {
       throw new errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId}`
+        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
       );
     }
     return updatedAction;
@@ -410,12 +545,17 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     const deletedAction = await strapi2.db.query(RELEASE_ACTION_MODEL_UID).delete({
       where: {
         id: actionId,
-        release: releaseId
+        release: {
+          id: releaseId,
+          releasedAt: {
+            $null: true
+          }
+        }
       }
     });
     if (!deletedAction) {
       throw new errors.NotFoundError(
-        `Action with id ${actionId} not found in release with id ${releaseId}`
+        `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
       );
     }
     return deletedAction;
@@ -448,9 +588,48 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
         `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`
       );
     }
+  },
+  async validatePendingReleasesLimit() {
+    const maximumPendingReleases = (
+      // @ts-expect-error - options is not typed into features
+      EE.features.get("cms-content-releases")?.options?.maximumReleases || 3
+    );
+    const [, pendingReleasesCount] = await strapi2.db.query(RELEASE_MODEL_UID).findWithCount({
+      filters: {
+        releasedAt: {
+          $null: true
+        }
+      }
+    });
+    if (pendingReleasesCount >= maximumPendingReleases) {
+      throw new errors.ValidationError("You have reached the maximum number of pending releases");
+    }
   }
 });
-const services = { release: createReleaseService, "release-validation": createReleaseValidationService };
+const createEventManagerService = () => {
+  const state = {
+    destroyListenerCallbacks: []
+  };
+  return {
+    addDestroyListenerCallback(destroyListenerCallback) {
+      state.destroyListenerCallbacks.push(destroyListenerCallback);
+    },
+    destroyAllListeners() {
+      if (!state.destroyListenerCallbacks.length) {
+        return;
+      }
+      state.destroyListenerCallbacks.forEach((destroyListenerCallback) => {
+        destroyListenerCallback();
+      });
+    }
+  };
+};
+const services = {
+  release: createReleaseService,
+  "release-action": createReleaseActionService,
+  "release-validation": createReleaseValidationService,
+  "event-manager": createEventManagerService
+};
 const RELEASE_SCHEMA = yup.object().shape({
   name: yup.string().trim().required()
 }).required().noUnknown();
@@ -595,31 +774,13 @@ const releaseActionController = {
     });
     const query = await permissionsManager.sanitizeQuery(ctx.query);
     const releaseService = getService("release", { strapi });
-    const { results, pagination } = await releaseService.findActions(releaseId, query);
-    const allReleaseContentTypesDictionary = await releaseService.getContentTypesDataForActions(
-      releaseId
-    );
-    const allLocales = await strapi.plugin("i18n").service("locales").find();
-    const allLocalesDictionary = allLocales.reduce((acc, locale) => {
-      acc[locale.code] = { name: locale.name, code: locale.code };
-      return acc;
-    }, {});
-    const data = results.map((action) => {
-      const { mainField, displayName } = allReleaseContentTypesDictionary[action.contentType];
-      return {
-        ...action,
-        entry: {
-          id: action.entry.id,
-          contentType: {
-            displayName,
-            mainFieldValue: action.entry[mainField]
-          },
-          locale: allLocalesDictionary[action.entry.locale]
-        }
-      };
+    const { results, pagination } = await releaseService.findActions(releaseId, {
+      sort: query.groupBy === "action" ? "type" : query.groupBy,
+      ...query
     });
+    const groupedData = await releaseService.groupActions(results, query.groupBy);
     ctx.body = {
-      data,
+      data: groupedData,
       meta: {
         pagination
       }
@@ -643,10 +804,8 @@ const releaseActionController = {
   async delete(ctx) {
     const actionId = ctx.params.actionId;
     const releaseId = ctx.params.releaseId;
-    const deletedReleaseAction = await getService("release", { strapi }).deleteAction(
-      actionId,
-      releaseId
-    );
+    const releaseService = getService("release", { strapi });
+    const deletedReleaseAction = await releaseService.deleteAction(actionId, releaseId);
     ctx.body = {
       data: deletedReleaseAction
     };
@@ -832,10 +991,16 @@ const getPlugin = () => {
   if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
     return {
       register,
+      bootstrap,
       contentTypes,
       services,
       controllers,
-      routes
+      routes,
+      destroy() {
+        if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
+          getService("event-manager").destroyAllListeners();
+        }
+      }
     };
   }
   return {