@strapi/content-releases 0.0.0-next.56199ab7a5f3320e0debcbe4a24fe0b8cd599e21 → 0.0.0-next.6a58621932ad3d83bf9d6928c1871e7906adcd59

package/dist/server/index.mjs

@@ -1,4 +1,5 @@
-import { setCreatorFields, errors, validateYupSchema, yup as yup$1, mapAsync } from "@strapi/utils";
+import { contentTypes as contentTypes$1, mapAsync, setCreatorFields, errors, validateYupSchema, yup as yup$1 } from "@strapi/utils";
+import { difference, keys } from "lodash";
 import _ from "lodash/fp";
 import EE from "@strapi/strapi/dist/utils/ee";
 import * as yup from "yup";
@@ -48,40 +49,47 @@ const ACTIONS = [
     pluginName: "content-releases"
   }
 ];
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.plugin("content-releases").service(name);
-};
+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 (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: 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();
+    });
+  }
+}
 const { features: features$2 } = require("@strapi/strapi/dist/utils/ee");
 const register = async ({ strapi: strapi2 }) => {
-  if (features$2.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
+  if (features$2.isEnabled("cms-content-releases")) {
     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);
+    strapi2.hook("strapi::content-types.beforeSync").register(deleteActionsOnDisableDraftAndPublish);
+    strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType);
   }
 };
 const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
 const bootstrap = async ({ strapi: strapi2 }) => {
-  if (features$1.isEnabled("cms-content-releases") && strapi2.features.future.isEnabled("contentReleases")) {
+  if (features$1.isEnabled("cms-content-releases")) {
     strapi2.db.lifecycles.subscribe({
       afterDelete(event) {
         const { model, result } = event;
-        if (model.kind === "collectionType" && model.options.draftAndPublish) {
+        if (model.kind === "collectionType" && model.options?.draftAndPublish) {
           const { id } = result;
           strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
             where: {
@@ -97,7 +105,7 @@ const bootstrap = async ({ strapi: strapi2 }) => {
        */
       async beforeDeleteMany(event) {
         const { model, params } = event;
-        if (model.kind === "collectionType" && model.options.draftAndPublish) {
+        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;
@@ -212,15 +220,9 @@ const contentTypes = {
   release: release$1,
   "release-action": releaseAction$1
 };
-const createReleaseActionService = ({ strapi: strapi2 }) => ({
-  async deleteManyForContentType(contentTypeUid) {
-    return strapi2.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
-      where: {
-        target_type: contentTypeUid
-      }
-    });
-  }
-});
+const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  return strapi2.plugin("content-releases").service(name);
+};
 const getGroupName = (queryValue) => {
   switch (queryValue) {
     case "contentType":
@@ -236,7 +238,14 @@ const getGroupName = (queryValue) => {
 const createReleaseService = ({ strapi: strapi2 }) => ({
   async create(releaseData, { user }) {
     const releaseWithCreatorFields = await setCreatorFields({ user })(releaseData);
-    await getService("release-validation", { strapi: strapi2 }).validatePendingReleasesLimit();
+    const { validatePendingReleasesLimit, validateUniqueNameForPendingRelease } = getService(
+      "release-validation",
+      { strapi: strapi2 }
+    );
+    await Promise.all([
+      validatePendingReleasesLimit(),
+      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name)
+    ]);
     return strapi2.entityService.create(RELEASE_MODEL_UID, {
       data: releaseWithCreatorFields
     });
@@ -258,51 +267,66 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       }
     });
   },
-  async findManyForContentTypeEntry(contentTypeUid, entryId, {
-    hasEntryAttached
-  } = {
-    hasEntryAttached: false
-  }) {
-    const whereActions = hasEntryAttached ? {
-      // Find all Releases where the content type entry is present
-      actions: {
-        target_type: contentTypeUid,
-        target_id: entryId
-      }
-    } : {
-      // Find all Releases where the content type entry is not present
-      $or: [
-        {
-          $not: {
-            actions: {
-              target_type: contentTypeUid,
-              target_id: entryId
-            }
-          }
+  async findManyWithContentTypeEntryAttached(contentTypeUid, entryId) {
+    const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+      where: {
+        actions: {
+          target_type: contentTypeUid,
+          target_id: entryId
         },
-        {
-          actions: null
+        releasedAt: {
+          $null: true
         }
-      ]
-    };
-    const populateAttachedAction = hasEntryAttached ? {
-      // Filter the action to get only the content type entry
-      actions: {
-        where: {
+      },
+      populate: {
+        // Filter the action to get only the content type entry
+        actions: {
+          where: {
+            target_type: contentTypeUid,
+            target_id: entryId
+          }
+        }
+      }
+    });
+    return releases.map((release2) => {
+      if (release2.actions?.length) {
+        const [actionForEntry] = release2.actions;
+        delete release2.actions;
+        return {
+          ...release2,
+          action: actionForEntry
+        };
+      }
+      return release2;
+    });
+  },
+  async findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId) {
+    const releasesRelated = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+      where: {
+        releasedAt: {
+          $null: true
+        },
+        actions: {
           target_type: contentTypeUid,
           target_id: entryId
         }
       }
-    } : {};
+    });
     const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
       where: {
-        ...whereActions,
+        $or: [
+          {
+            id: {
+              $notIn: releasesRelated.map((release2) => release2.id)
+            }
+          },
+          {
+            actions: null
+          }
+        ],
         releasedAt: {
           $null: true
         }
-      },
-      populate: {
-        ...populateAttachedAction
       }
     });
     return releases.map((release2) => {
@@ -501,7 +525,9 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
         populate: {
           actions: {
             populate: {
-              entry: true
+              entry: {
+                fields: ["id"]
+              }
             }
           }
         }
@@ -521,25 +547,49 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       const contentTypeUid = action.contentType;
       if (!actions[contentTypeUid]) {
         actions[contentTypeUid] = {
-          publish: [],
-          unpublish: []
+          entriestoPublishIds: [],
+          entriesToUnpublishIds: []
         };
       }
       if (action.type === "publish") {
-        actions[contentTypeUid].publish.push(action.entry);
+        actions[contentTypeUid].entriestoPublishIds.push(action.entry.id);
       } else {
-        actions[contentTypeUid].unpublish.push(action.entry);
+        actions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
       }
     }
     const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
+    const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
     await strapi2.db.transaction(async () => {
       for (const contentTypeUid of Object.keys(actions)) {
-        const { publish, unpublish } = actions[contentTypeUid];
-        if (publish.length > 0) {
-          await entityManagerService.publishMany(publish, contentTypeUid);
+        const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
+        const { entriestoPublishIds, entriesToUnpublishIds } = actions[contentTypeUid];
+        const entriesToPublish = await strapi2.entityService.findMany(
+          contentTypeUid,
+          {
+            filters: {
+              id: {
+                $in: entriestoPublishIds
+              }
+            },
+            populate
+          }
+        );
+        const entriesToUnpublish = await strapi2.entityService.findMany(
+          contentTypeUid,
+          {
+            filters: {
+              id: {
+                $in: entriesToUnpublishIds
+              }
+            },
+            populate
+          }
+        );
+        if (entriesToPublish.length > 0) {
+          await entityManagerService.publishMany(entriesToPublish, contentTypeUid);
         }
-        if (unpublish.length > 0) {
-          await entityManagerService.unpublishMany(unpublish, contentTypeUid);
+        if (entriesToUnpublish.length > 0) {
+          await entityManagerService.unpublishMany(entriesToUnpublish, contentTypeUid);
         }
       }
     });
@@ -637,31 +687,25 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
     if (pendingReleasesCount >= maximumPendingReleases) {
       throw new errors.ValidationError("You have reached the maximum number of pending releases");
     }
-  }
-});
-const createEventManagerService = () => {
-  const state = {
-    destroyListenerCallbacks: []
-  };
-  return {
-    addDestroyListenerCallback(destroyListenerCallback) {
-      state.destroyListenerCallbacks.push(destroyListenerCallback);
-    },
-    destroyAllListeners() {
-      if (!state.destroyListenerCallbacks.length) {
-        return;
+  },
+  async validateUniqueNameForPendingRelease(name) {
+    const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
+      filters: {
+        releasedAt: {
+          $null: true
+        },
+        name
       }
-      state.destroyListenerCallbacks.forEach((destroyListenerCallback) => {
-        destroyListenerCallback();
-      });
+    });
+    const isNameUnique = pendingReleases.length === 0;
+    if (!isNameUnique) {
+      throw new errors.ValidationError(`Release with name ${name} already exists`);
     }
-  };
-};
+  }
+});
 const services = {
   release: createReleaseService,
-  "release-action": createReleaseActionService,
-  "release-validation": createReleaseValidationService,
-  "event-manager": createEventManagerService
+  "release-validation": createReleaseValidationService
 };
 const RELEASE_SCHEMA = yup.object().shape({
   name: yup.string().trim().required()
@@ -681,9 +725,7 @@ const releaseController = {
       const contentTypeUid = query.contentTypeUid;
       const entryId = query.entryId;
       const hasEntryAttached = typeof query.hasEntryAttached === "string" ? JSON.parse(query.hasEntryAttached) : false;
-      const data = await releaseService.findManyForContentTypeEntry(contentTypeUid, entryId, {
-        hasEntryAttached
-      });
+      const data = hasEntryAttached ? await releaseService.findManyWithContentTypeEntryAttached(contentTypeUid, entryId) : await releaseService.findManyWithoutContentTypeEntryAttached(contentTypeUid, entryId);
       ctx.body = { data };
     } else {
       const query = await permissionsManager.sanitizeQuery(ctx.query);
@@ -1040,19 +1082,14 @@ const routes = {
 };
 const { features } = require("@strapi/strapi/dist/utils/ee");
 const getPlugin = () => {
-  if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
+  if (features.isEnabled("cms-content-releases")) {
     return {
       register,
       bootstrap,
       contentTypes,
       services,
       controllers,
-      routes,
-      destroy() {
-        if (features.isEnabled("cms-content-releases") && strapi.features.future.isEnabled("contentReleases")) {
-          getService("event-manager").destroyAllListeners();
-        }
-      }
+      routes
     };
   }
   return {