feat(content-releases): Delete a Release

packages/core/content-releases/server/src/controllers/release.ts

@@ -8,6 +8,7 @@ import type {
   PublishRelease,
   GetRelease,
   Release,
+  DeleteRelease,
   GetContentTypeEntryReleases,
   GetReleases,
 } from '../../../shared/contracts/releases';
@@ -147,6 +148,17 @@ const releaseController = {
     };
   },
 
+  async delete(ctx: Koa.Context) {
+    const id: DeleteRelease.Request['params']['id'] = ctx.params.id;
+
+    const releaseService = getService('release', { strapi });
+    const release = await releaseService.delete(id);
+
+    ctx.body = {
+      data: release,
+    };
+  },
+
   async publish(ctx: Koa.Context) {
     const user: PublishRelease.Request['state']['user'] = ctx.state.user;
     const id: PublishRelease.Request['params']['id'] = ctx.params.id;

packages/core/content-releases/server/src/routes/release.ts

@@ -65,6 +65,22 @@ export default {
         ],
       },
     },
+    {
+      method: 'DELETE',
+      path: '/:id',
+      handler: 'release.delete',
+      config: {
+        policies: [
+          'admin::isAuthenticatedAdmin',
+          {
+            name: 'admin::hasPermissions',
+            config: {
+              actions: ['plugin::content-releases.delete'],
+            },
+          },
+        ],
+      },
+    },
     {
       method: 'POST',
       path: '/:id/publish',

packages/core/content-releases/server/src/services/__tests__/release.test.ts

@@ -175,4 +175,34 @@ describe('release service', () => {
       expect(releases).toEqual([{ name: 'test release', action: { type: 'publish' } }]);
     });
   });
+
+  describe('delete', () => {
+    it('throws an error if the release does not exist', () => {
+      const strapiMock = {
+        ...baseStrapiMock,
+        entityService: {
+          findOne: jest.fn().mockReturnValue(null),
+        },
+      };
+
+      // @ts-expect-error Ignore missing properties
+      const releaseService = createReleaseService({ strapi: strapiMock });
+
+      expect(() => releaseService.delete(1)).rejects.toThrow('No release found for id 1');
+    });
+
+    it('throws an error if the release is already published', () => {
+      const strapiMock = {
+        ...baseStrapiMock,
+        entityService: {
+          findOne: jest.fn().mockReturnValue({ releasedAt: new Date() }),
+        },
+      };
+
+      // @ts-expect-error Ignore missing properties
+      const releaseService = createReleaseService({ strapi: strapiMock });
+
+      expect(() => releaseService.delete(1)).rejects.toThrow('Release already published');
+    });
+  });
 });

packages/core/content-releases/server/src/services/release.ts

@@ -8,6 +8,7 @@ import type {
   PublishRelease,
   GetRelease,
   Release,
+  DeleteRelease,
   GetContentTypeEntryReleases,
 } from '../../../shared/contracts/releases';
 import type {
@@ -230,6 +231,34 @@ const createReleaseService = ({ strapi }: { strapi: LoadedStrapi }) => ({
 
     return contentTypesMeta;
   },
+  async delete(releaseId: DeleteRelease.Request['params']['id']) {
+    const release = await strapi.entityService.findOne(RELEASE_MODEL_UID, releaseId);
+
+    if (!release) {
+      throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+    }
+
+    if (release.releasedAt) {
+      throw new errors.ValidationError('Release already published');
+    }
+
+    const deletedRelease = (await strapi.entityService.delete(RELEASE_MODEL_UID, releaseId, {
+      populate: { actions: { fields: ['id'] } },
+    })) as unknown as Release;
+
+    // We delete each action related to the release
+    if (deletedRelease.actions) {
+      await strapi.db.query(RELEASE_ACTION_MODEL_UID).deleteMany({
+        where: {
+          id: {
+            $in: deletedRelease.actions.map(({ id }) => id),
+          },
+        },
+      });
+    }
+
+    return deletedRelease;
+  },
   async publish(releaseId: PublishRelease.Request['params']['id']) {
     // We need to pass the type because entityService.findOne is not returning the correct type
     const releaseWithPopulatedActionEntries = (await strapi.entityService.findOne(
@@ -301,7 +330,7 @@ const createReleaseService = ({ strapi }: { strapi: LoadedStrapi }) => ({
       }
     });
 
-		// When the transaction fails it throws an error, when it is successful proceed to updating the release
+    // When the transaction fails it throws an error, when it is successful proceed to updating the release
     const release = await strapi.entityService.update(RELEASE_MODEL_UID, releaseId, {
       data: {
         /*

packages/core/content-releases/shared/contracts/releases.ts

@@ -2,7 +2,6 @@ import type { Entity } from '../types';
 import type { ReleaseAction } from './release-actions';
 import type { UserInfo } from '../types';
 import { errors } from '@strapi/utils';
-import { UID } from '@strapi/types';
 
 export interface Release extends Entity {
   name: string;
@@ -126,6 +125,25 @@ export declare namespace UpdateRelease {
   }
 }
 
+/**
+ * DELETE /content-releases/:id - Delete a release
+ */
+export declare namespace DeleteRelease {
+  export interface Request {
+    state: {
+      user: UserInfo;
+    };
+    params: {
+      id: Release['id'];
+    };
+  }
+
+  export interface Response {
+    data: ReleaseDataResponse;
+    error?: errors.ApplicationError | errors.NotFoundError;
+  }
+}
+
 /**
  * POST /content-releases/:releaseId/publish - Publish a release
  */