refactor: Extract delete logic endpoint

src/app/models/__tests__/form.server.model.spec.ts

@@ -14,6 +14,7 @@ import {
   IEncryptedForm,
   IFieldSchema,
   IFormSchema,
+  ILogicSchema,
   IPopulatedUser,
   Permission,
   ResponseMode,
@@ -384,7 +385,7 @@ describe('Form Model', () => {
         expect(actualSavedObject).toEqual(expectedObject)
 
         // Remove indeterministic id from actual permission list
-        const actualPermissionList = (saved.toObject() as IEncryptedForm).permissionList?.map(
+        const actualPermissionList = ((saved.toObject() as unknown) as IEncryptedForm).permissionList?.map(
           (permission) => omit(permission, '_id'),
         )
         expect(actualPermissionList).toEqual(permissionList)
@@ -1053,6 +1054,103 @@ describe('Form Model', () => {
         expect(actual).toEqual(expected)
       })
     })
+
+    describe('deleteFormLogic', () => {
+      const logicId = new ObjectId().toHexString()
+      const mockFormLogic = {
+        form_logics: [
+          {
+            _id: logicId,
+            id: logicId,
+          } as ILogicSchema,
+        ],
+      }
+
+      it('should return form upon successful delete', async () => {
+        // arrange
+        const formParams = merge({}, MOCK_EMAIL_FORM_PARAMS, {
+          admin: populatedAdmin,
+          status: Status.Public,
+          responseMode: ResponseMode.Email,
+          ...mockFormLogic,
+        })
+        const form = await Form.create(formParams)
+
+        // act
+        const modifiedForm = await Form.deleteFormLogic(form._id, logicId)
+
+        // assert
+        // Form should be returned
+        expect(modifiedForm).not.toBeNull()
+
+        // Form should have correct status, responsemode
+        expect(modifiedForm?.responseMode).not.toBeNull()
+        expect(modifiedForm?.responseMode).toEqual(ResponseMode.Email)
+        expect(modifiedForm?.status).not.toBeNull()
+        expect(modifiedForm?.status).toEqual(Status.Public)
+
+        // Check that form logic has been deleted
+        expect(modifiedForm?.form_logics).toBeEmpty()
+      })
+
+      it('should return form with remaining logic upon successful delete of one logic', async () => {
+        // arrange
+
+        const logicId2 = new ObjectId().toHexString()
+        const mockFormLogicMultiple = {
+          form_logics: [
+            {
+              _id: logicId,
+              id: logicId,
+            } as ILogicSchema,
+            {
+              _id: logicId2,
+              id: logicId2,
+            } as ILogicSchema,
+          ],
+        }
+
+        const formParams = merge({}, MOCK_EMAIL_FORM_PARAMS, {
+          admin: populatedAdmin,
+          status: Status.Public,
+          responseMode: ResponseMode.Email,
+          ...mockFormLogicMultiple,
+        })
+        const form = await Form.create(formParams)
+
+        // act
+        const modifiedForm = await Form.deleteFormLogic(form._id, logicId)
+
+        // assert
+        // Form should be returned
+        expect(modifiedForm).not.toBeNull()
+
+        // Form should have correct status, responsemode
+        expect(modifiedForm?.responseMode).not.toBeNull()
+        expect(modifiedForm?.responseMode).toEqual(ResponseMode.Email)
+        expect(modifiedForm?.status).not.toBeNull()
+        expect(modifiedForm?.status).toEqual(Status.Public)
+
+        // Check that correct form logic has been deleted
+        expect(modifiedForm?.form_logics).toBeDefined()
+        expect(modifiedForm?.form_logics).toHaveLength(1)
+        const logic = modifiedForm?.form_logics || ['some logic']
+        expect((logic[0] as any)['_id'].toString()).toEqual(logicId2)
+      })
+
+      it('should return null if formId is invalid', async () => {
+        // arrange
+
+        const invalidFormId = new ObjectId().toHexString()
+
+        // act
+        const modifiedForm = await Form.deleteFormLogic(invalidFormId, logicId)
+
+        // assert
+        // should return null
+        expect(modifiedForm).toBeNull()
+      })
+    })
   })
 
   describe('Methods', () => {

src/app/models/form.server.model.ts

@@ -613,6 +613,24 @@ const compileFormModel = (db: Mongoose): IFormModel => {
     )
   }
 
+  // Deletes specified form logic.
+  FormSchema.statics.deleteFormLogic = async function (
+    this: IFormModel,
+    formId: string,
+    logicId: string,
+  ): Promise<IFormSchema | null> {
+    return this.findByIdAndUpdate(
+      mongoose.Types.ObjectId(formId),
+      {
+        $pull: { form_logics: { _id: logicId } },
+      },
+      {
+        new: true,
+        runValidators: true,
+      },
+    ).exec()
+  }
+
   // Hooks
   FormSchema.pre<IFormSchema>('validate', function (next) {
     // Reject save if form document is too large

src/app/modules/form/admin-form/__tests__/admin-form.controller.spec.ts

@@ -49,6 +49,7 @@ import {
   IFieldSchema,
   IForm,
   IFormSchema,
+  ILogicSchema,
   IPopulatedEmailForm,
   IPopulatedEncryptedForm,
   IPopulatedForm,
@@ -76,6 +77,7 @@ import {
   ForbiddenFormError,
   FormDeletedError,
   FormNotFoundError,
+  LogicNotFoundError,
   PrivateFormError,
   TransferOwnershipError,
 } from '../../form.errors'
@@ -6777,6 +6779,7 @@ describe('admin-form.controller', () => {
       MockAuthService.getFormAfterPermissionChecks.mockReturnValue(
         okAsync(MOCK_FORM),
       )
+
       MockAdminFormService.updateFormField.mockReturnValue(
         okAsync(MOCK_UPDATED_FIELD as IFieldSchema),
       )
@@ -7017,6 +7020,7 @@ describe('admin-form.controller', () => {
       _id: MOCK_USER_ID,
       email: '[email protected]',
     } as IPopulatedUser
+
     const MOCK_FORM = {
       admin: MOCK_USER,
       _id: MOCK_FORM_ID,
@@ -7039,7 +7043,6 @@ describe('admin-form.controller', () => {
       },
       body: MOCK_CREATE_FIELD_BODY,
     })
-
     beforeEach(() => {
       MockUserService.getPopulatedUserById.mockReturnValue(okAsync(MOCK_USER))
       MockAuthService.getFormAfterPermissionChecks.mockReturnValue(
@@ -7296,4 +7299,201 @@ describe('admin-form.controller', () => {
       )
     })
   })
+
+  describe('handleDeleteLogic', () => {
+    const MOCK_USER_ID = new ObjectId().toHexString()
+    const MOCK_FORM_ID = new ObjectId().toHexString()
+    const MOCK_USER = {
+      _id: MOCK_USER_ID,
+      email: '[email protected]',
+    } as IPopulatedUser
+
+    const logicId = new ObjectId().toHexString()
+    const mockFormLogic = {
+      form_logics: [
+        {
+          _id: logicId,
+          id: logicId,
+        } as ILogicSchema,
+      ],
+    }
+
+    const MOCK_FORM = {
+      admin: MOCK_USER,
+      _id: MOCK_FORM_ID,
+      title: 'mock title',
+      ...mockFormLogic,
+    } as IPopulatedForm
+
+    const mockReq = expressHandler.mockRequest({
+      params: {
+        formId: MOCK_FORM_ID,
+        logicId,
+      },
+      session: {
+        user: {
+          _id: MOCK_USER_ID,
+        },
+      },
+    })
+    const mockRes = expressHandler.mockResponse()
+    beforeEach(() => {
+      MockUserService.getPopulatedUserById.mockReturnValue(okAsync(MOCK_USER))
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValue(
+        okAsync(MOCK_FORM),
+      )
+      MockAdminFormService.deleteFormLogic.mockReturnValue(okAsync(true))
+    })
+
+    it('should call all services correctly when request is valid', async () => {
+      await AdminFormController.handleDeleteLogic(mockReq, mockRes, jest.fn())
+
+      expect(MockUserService.getPopulatedUserById).toHaveBeenCalledWith(
+        MOCK_USER_ID,
+      )
+      expect(MockAuthService.getFormAfterPermissionChecks).toHaveBeenCalledWith(
+        {
+          user: MOCK_USER,
+          formId: MOCK_FORM_ID,
+          level: PermissionLevel.Write,
+        },
+      )
+      expect(MockAdminFormService.deleteFormLogic).toHaveBeenCalledWith(
+        MOCK_FORM,
+        logicId,
+      )
+
+      expect(mockRes.sendStatus).toHaveBeenCalledWith(200)
+    })
+
+    it('should return 403 when user does not have permissions to delete logic', async () => {
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValue(
+        errAsync(
+          new ForbiddenFormError('not authorized to perform write operation'),
+        ),
+      )
+
+      await AdminFormController.handleDeleteLogic(mockReq, mockRes, jest.fn())
+
+      expect(MockUserService.getPopulatedUserById).toHaveBeenCalledWith(
+        MOCK_USER_ID,
+      )
+      expect(MockAuthService.getFormAfterPermissionChecks).toHaveBeenCalledWith(
+        {
+          user: MOCK_USER,
+          formId: MOCK_FORM_ID,
+          level: PermissionLevel.Write,
+        },
+      )
+      expect(MockAdminFormService.deleteFormLogic).not.toHaveBeenCalled()
+
+      expect(mockRes.status).toHaveBeenCalledWith(403)
+
+      expect(mockRes.json).toHaveBeenCalledWith({
+        message: 'not authorized to perform write operation',
+      })
+    })
+
+    it('should return 404 when logicId cannot be found', async () => {
+      MockAdminFormService.deleteFormLogic.mockReturnValue(
+        errAsync(new LogicNotFoundError()),
+      )
+
+      await AdminFormController.handleDeleteLogic(mockReq, mockRes, jest.fn())
+
+      expect(MockUserService.getPopulatedUserById).toHaveBeenCalledWith(
+        MOCK_USER_ID,
+      )
+      expect(MockAuthService.getFormAfterPermissionChecks).toHaveBeenCalledWith(
+        {
+          user: MOCK_USER,
+          formId: MOCK_FORM_ID,
+          level: PermissionLevel.Write,
+        },
+      )
+
+      expect(MockAdminFormService.deleteFormLogic).toHaveBeenCalledWith(
+        MOCK_FORM,
+        logicId,
+      )
+
+      expect(mockRes.status).toHaveBeenCalledWith(404)
+
+      expect(mockRes.json).toHaveBeenCalledWith({
+        message: 'logicId does not exist on form',
+      })
+    })
+
+    it('should return 404 when form cannot be found', async () => {
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValue(
+        errAsync(new FormNotFoundError()),
+      )
+
+      await AdminFormController.handleDeleteLogic(mockReq, mockRes, jest.fn())
+
+      expect(MockUserService.getPopulatedUserById).toHaveBeenCalledWith(
+        MOCK_USER_ID,
+      )
+      expect(MockAuthService.getFormAfterPermissionChecks).toHaveBeenCalledWith(
+        {
+          user: MOCK_USER,
+          formId: MOCK_FORM_ID,
+          level: PermissionLevel.Write,
+        },
+      )
+      expect(MockAdminFormService.deleteFormLogic).not.toHaveBeenCalled()
+
+      expect(mockRes.status).toHaveBeenCalledWith(404)
+
+      expect(mockRes.json).toHaveBeenCalledWith({
+        message: 'Form not found',
+      })
+    })
+
+    it('should return 422 when user in session cannot be retrieved from the database', async () => {
+      MockUserService.getPopulatedUserById.mockReturnValue(
+        errAsync(new MissingUserError()),
+      )
+
+      await AdminFormController.handleDeleteLogic(mockReq, mockRes, jest.fn())
+
+      expect(MockUserService.getPopulatedUserById).toHaveBeenCalledWith(
+        MOCK_USER_ID,
+      )
+      expect(
+        MockAuthService.getFormAfterPermissionChecks,
+      ).not.toHaveBeenCalled()
+
+      expect(MockAdminFormService.deleteFormLogic).not.toHaveBeenCalled()
+
+      expect(mockRes.status).toHaveBeenCalledWith(422)
+
+      expect(mockRes.json).toHaveBeenCalledWith({
+        message: 'User not found',
+      })
+    })
+
+    it('should return 500 when database error occurs', async () => {
+      MockUserService.getPopulatedUserById.mockReturnValue(
+        errAsync(new DatabaseError()),
+      )
+
+      await AdminFormController.handleDeleteLogic(mockReq, mockRes, jest.fn())
+
+      expect(MockUserService.getPopulatedUserById).toHaveBeenCalledWith(
+        MOCK_USER_ID,
+      )
+      expect(
+        MockAuthService.getFormAfterPermissionChecks,
+      ).not.toHaveBeenCalled()
+
+      expect(MockAdminFormService.deleteFormLogic).not.toHaveBeenCalled()
+
+      expect(mockRes.status).toHaveBeenCalledWith(500)
+
+      expect(mockRes.json).toHaveBeenCalledWith({
+        message: 'Something went wrong. Please try again.',
+      })
+    })
+  })
 })