@strapi/content-releases 0.0.0-experimental.f31889311d753b5f7d95198ae84d8fce1d156cd6 → 0.0.0-experimental.f74ae50eea1ce95176f088dba837e95b60fa2a4d

package/dist/server/index.mjs

@@ -906,7 +906,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
       });
@@ -914,6 +914,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 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 errors.NotFoundError(`No release found for id ${releaseId}`);
@@ -939,7 +947,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) {
@@ -1112,11 +1122,11 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
       throw new 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}`
       );
     }
   },
@@ -1283,7 +1293,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 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({
@@ -1385,43 +1403,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 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;
@@ -1514,22 +1539,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;
             }
@@ -1537,18 +1563,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({
@@ -1647,24 +1675,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",
@@ -1798,24 +1824,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",