@strapi/content-releases 0.0.0-experimental.edc24aaa3bb5a90fa5fd4fee208167dd4e2e38d4 → 0.0.0-experimental.f0a0bc26f5ef0693aaea2a616bc6b816cfee54b6

package/dist/server/index.js

@@ -111,6 +111,13 @@ const isEntryValid = async (contentTypeUid, entry, { strapi: strapi2 }) => {
       // @ts-expect-error - FIXME: entity here is unnecessary
       entry
     );
+    const workflowsService = strapi2.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;
@@ -124,7 +131,11 @@ const getEntry = async ({
   status = "draft"
 }, { strapi: strapi2 }) => {
   if (documentId) {
-    return strapi2.documents(contentType).findOne({ documentId, locale, populate, status });
+    const entry = await strapi2.documents(contentType).findOne({ documentId, locale, populate, status });
+    if (status === "published" && !entry) {
+      return strapi2.documents(contentType).findOne({ documentId, locale, populate, status: "draft" });
+    }
+    return entry;
   }
   return strapi2.documents(contentType).findFirst({ locale, populate, status });
 };
@@ -329,6 +340,10 @@ async function enableContentTypeLocalized({ oldContentTypes, contentTypes: conte
 const addEntryDocumentToReleaseActions = {
   name: "content-releases::5.0.0-add-entry-document-id-to-release-actions",
   async up(trx, db) {
+    const hasTable = await trx.schema.hasTable("strapi_release_actions");
+    if (!hasTable) {
+      return;
+    }
     const hasPolymorphicColumn = await trx.schema.hasColumn("strapi_release_actions", "target_id");
     if (hasPolymorphicColumn) {
       const hasEntryDocumentIdColumn = await trx.schema.hasColumn(
@@ -370,6 +385,7 @@ const register = async ({ strapi: strapi2 }) => {
 const updateActionsStatusAndUpdateReleaseStatus = async (contentType, entry) => {
   const releases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
     where: {
+      releasedAt: null,
       actions: {
         contentType,
         entryDocumentId: entry.documentId,
@@ -378,7 +394,7 @@ const updateActionsStatusAndUpdateReleaseStatus = async (contentType, entry) =>
     }
   });
   const entryStatus = await isEntryValid(contentType, entry, { strapi });
-  await strapi.db.query(RELEASE_ACTION_MODEL_UID).update({
+  await strapi.db.query(RELEASE_ACTION_MODEL_UID).updateMany({
     where: {
       contentType,
       entryDocumentId: entry.documentId,
@@ -482,8 +498,8 @@ const bootstrap = async ({ strapi: strapi2 }) => {
             const { where } = event.params;
             deleteReleasesActionsAndUpdateReleaseStatus({
               contentType: model.uid,
-              locale: where.locale ?? null,
-              ...where.documentId && { entryDocumentId: where.documentId }
+              locale: where?.locale ?? null,
+              ...where?.documentId && { entryDocumentId: where.documentId }
             });
           }
         } catch (error) {
@@ -929,7 +945,7 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
     return contentTypesData;
   };
   return {
-    async create(releaseId, action) {
+    async create(releaseId, action, { disableUpdateReleaseStatus = false } = {}) {
       const { validateEntryData, validateUniqueEntry } = getService("release-validation", {
         strapi: strapi2
       });
@@ -937,6 +953,14 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
         validateEntryData(action.contentType, action.entryDocumentId),
         validateUniqueEntry(releaseId, action)
       ]);
+      const model = strapi2.contentType(action.contentType);
+      if (model.kind === "singleType") {
+        const document = await strapi2.db.query(model.uid).findOne({ select: ["documentId"] });
+        if (!document) {
+          throw new utils.errors.NotFoundError(`No entry found for contentType ${action.contentType}`);
+        }
+        action.entryDocumentId = document.documentId;
+      }
       const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: releaseId } });
       if (!release2) {
         throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
@@ -962,7 +986,9 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
         },
         populate: { release: { select: ["id"] } }
       });
-      getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
+      if (!disableUpdateReleaseStatus) {
+        getService("release", { strapi: strapi2 }).updateReleaseStatus(release2.id);
+      }
       return releaseAction2;
     },
     async findPage(releaseId, query) {
@@ -1028,16 +1054,26 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
       const groupName = getGroupName(groupBy);
       return ___default.default.groupBy(groupName)(formattedData);
     },
-    getContentTypeModelsFromActions(actions) {
+    async 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);
+      const workflowsService = strapi2.plugin("review-workflows").service("workflows");
+      const contentTypeModelsMap = await utils.async.reduce(contentTypeUids)(
+        async (accPromise, contentTypeUid) => {
+          const acc = await accPromise;
+          const contentTypeModel = strapi2.getModel(contentTypeUid);
+          const workflow = await workflowsService.getAssignedWorkflow(contentTypeUid, {
+            populate: "stageRequiredToPublish"
+          });
+          acc[contentTypeUid] = {
+            ...contentTypeModel,
+            hasReviewWorkflow: !!workflow,
+            stageRequiredToPublish: workflow?.stageRequiredToPublish
+          };
           return acc;
         },
         {}
@@ -1065,7 +1101,7 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
           `Action with id ${actionId} not found in release with id ${releaseId} or it is already published`
         );
       }
-      const actionStatus = update.type === "publish" ? getDraftEntryValidStatus(
+      const actionStatus = update.type === "publish" ? await getDraftEntryValidStatus(
         {
           contentType: action.contentType,
           documentId: action.entryDocumentId,
@@ -1112,6 +1148,54 @@ const createReleaseActionService = ({ strapi: strapi2 }) => {
       }
       getService("release", { strapi: strapi2 }).updateReleaseStatus(releaseId);
       return deletedAction;
+    },
+    async validateActionsByContentTypes(contentTypeUids) {
+      const actions = await strapi2.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 utils.async.map(actions, async (action) => {
+        const isValid = await getDraftEntryValidStatus(
+          {
+            contentType: action.contentType,
+            documentId: action.entryDocumentId,
+            locale: action.locale
+          },
+          { strapi: strapi2 }
+        );
+        await strapi2.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 utils.async.map(releasesUpdated, async (releaseId) => {
+          await getService("release", { strapi: strapi2 }).updateReleaseStatus(releaseId);
+        });
+      }
     }
   };
 };
@@ -1135,11 +1219,11 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
       throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
     }
     const isEntryInRelease = release2.actions.some(
-      (action) => Number(action.entryDocumentId) === Number(releaseActionArgs.entryDocumentId) && action.contentType === releaseActionArgs.contentType && action.locale === releaseActionArgs.locale
+      (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}`
+        `Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ""} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`
       );
     }
   },
@@ -1306,7 +1390,15 @@ const releaseController = {
     const releaseService = getService("release", { strapi });
     const query = await permissionsManager.sanitizeQuery(ctx.query);
     await validatefindByDocumentAttachedParams(query);
-    const { contentType, entryDocumentId, hasEntryAttached, locale } = 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 utils.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({
@@ -1320,7 +1412,12 @@ const releaseController = {
         },
         populate: {
           actions: {
-            fields: ["type"]
+            fields: ["type"],
+            filters: {
+              contentType,
+              entryDocumentId: entryDocumentId ?? null,
+              locale: locale ?? null
+            }
           }
         }
       });
@@ -1408,43 +1505,50 @@ const releaseController = {
     };
     ctx.body = { data };
   },
-  /* @TODO: Migrate to new api 
-    async mapEntriesToReleases(ctx: Koa.Context) {
-      const { contentTypeUid, entriesIds } = ctx.query;
-  
-      if (!contentTypeUid || !entriesIds) {
-        throw new errors.ValidationError('Missing required query parameters');
+  async mapEntriesToReleases(ctx) {
+    const { contentTypeUid, documentIds, locale } = ctx.query;
+    if (!contentTypeUid || !documentIds) {
+      throw new utils.errors.ValidationError("Missing required query parameters");
+    }
+    const releaseService = getService("release", { strapi });
+    const releasesWithActions = await releaseService.findMany({
+      where: {
+        releasedAt: null,
+        actions: {
+          contentType: contentTypeUid,
+          entryDocumentId: {
+            $in: documentIds
+          },
+          locale
+        }
+      },
+      populate: {
+        actions: true
       }
-  
-      const releaseService = getService('release', { strapi });
-  
-      const releasesWithActions = await releaseService.findMany(
-        contentTypeUid,
-        entriesIds
-      );
-  
-      const mappedEntriesInReleases = releasesWithActions.reduce(
-        // TODO: Fix for v5 removed mappedEntriedToRelease
-        (acc: MapEntriesToReleases.Response['data'], release: Release) => {
-          release.actions.forEach((action) => {
-            if (!acc[action.entry.id]) {
-              acc[action.entry.id] = [{ id: release.id, name: release.name }];
-            } else {
-              acc[action.entry.id].push({ id: release.id, name: release.name });
-            }
-          });
-  
-          return acc;
-        },
-        // TODO: Fix for v5 removed mappedEntriedToRelease
-        {} as MapEntriesToReleases.Response['data']
-      );
-  
-      ctx.body = {
-        data: mappedEntriesInReleases,
-      };
-    },
-    */
+    });
+    const mappedEntriesInReleases = releasesWithActions.reduce(
+      (acc, release2) => {
+        release2.actions.forEach((action) => {
+          if (action.contentType !== contentTypeUid) {
+            return;
+          }
+          if (locale && action.locale !== locale) {
+            return;
+          }
+          if (!acc[action.entryDocumentId]) {
+            acc[action.entryDocumentId] = [{ id: release2.id, name: release2.name }];
+          } else {
+            acc[action.entryDocumentId].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;
@@ -1537,22 +1641,23 @@ const releaseActionController = {
       data: releaseAction2
     });
   },
-  /*
-  async createMany(ctx: Koa.Context) {
-    const releaseId: CreateManyReleaseActions.Request['params']['releaseId'] = ctx.params.releaseId;
-    const releaseActionsArgs = ctx.request.body as CreateManyReleaseActions.Request['body'];
+  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 releaseActionService = getService("release-action", { strapi });
+    const releaseService = getService("release", { strapi });
     const releaseActions = await strapi.db.transaction(async () => {
-      const releaseActions = await Promise.all(
+      const releaseActions2 = await Promise.all(
         releaseActionsArgs.map(async (releaseActionArgs) => {
           try {
-            const action = await releaseActionService.create(releaseId, releaseActionArgs);
+            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;
             }
@@ -1560,18 +1665,20 @@ const releaseActionController = {
           }
         })
       );
-      return releaseActions;
+      return releaseActions2;
     });
     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,
-      },
+        totalEntries: releaseActions.length
+      }
     });
   },
-  */
   async findMany(ctx) {
     const releaseId = ctx.params.releaseId;
     const permissionsManager = strapi.service("admin::permission").createPermissionsManager({
@@ -1607,7 +1714,7 @@ const releaseActionController = {
       entry: action.entry ? await contentTypeOutputSanitizers[action.contentType](action.entry) : {}
     }));
     const groupedData = await releaseActionService.groupActions(sanitizedResults, query.sort);
-    const contentTypes2 = releaseActionService.getContentTypeModelsFromActions(results);
+    const contentTypes2 = await releaseActionService.getContentTypeModelsFromActions(results);
     const releaseService = getService("release", { strapi });
     const components = await releaseService.getAllComponents();
     ctx.body = {
@@ -1670,24 +1777,22 @@ const controllers = {
 const release = {
   type: "admin",
   routes: [
-    /*
     {
-      method: 'GET',
-      path: '/mapEntriesToReleases',
-      handler: 'release.mapEntriesToReleases',
+      method: "GET",
+      path: "/mapEntriesToReleases",
+      handler: "release.mapEntriesToReleases",
       config: {
         policies: [
-          'admin::isAuthenticatedAdmin',
+          "admin::isAuthenticatedAdmin",
           {
-            name: 'admin::hasPermissions',
+            name: "admin::hasPermissions",
             config: {
-              actions: ['plugin::content-releases.read'],
-            },
-          },
-        ],
-      },
+              actions: ["plugin::content-releases.read"]
+            }
+          }
+        ]
+      }
     },
-    */
     {
       method: "GET",
       path: "/getByDocumentAttached",
@@ -1821,24 +1926,22 @@ const releaseAction = {
         ]
       }
     },
-    /*
     {
-      method: 'POST',
-      path: '/:releaseId/actions/bulk',
-      handler: 'release-action.createMany',
+      method: "POST",
+      path: "/:releaseId/actions/bulk",
+      handler: "release-action.createMany",
       config: {
         policies: [
-          'admin::isAuthenticatedAdmin',
+          "admin::isAuthenticatedAdmin",
           {
-            name: 'admin::hasPermissions',
+            name: "admin::hasPermissions",
             config: {
-              actions: ['plugin::content-releases.create-action'],
-            },
-          },
-        ],
-      },
+              actions: ["plugin::content-releases.create-action"]
+            }
+          }
+        ]
+      }
     },
-    */
     {
       method: "GET",
       path: "/:releaseId/actions",