chore: remove unused DELETE /transaction-groups and DELETE /transactions endpoints

back-end/apps/api/src/transactions/groups/transaction-groups.controller.spec.ts

@@ -92,14 +92,6 @@ describe('TransactionGroupsController', () => {
     });
   });
 
-  describe('removeTransactionGroup', () => {
-    it('should return void', async () => {
-      transactionGroupsService.removeTransactionGroup.mockReturnValue(undefined);
-
-      expect(await controller.removeTransactionGroup(user, 1)).toBeUndefined();
-    });
-  });
-
   describe('cancelTransactionGroup', () => {
     const cancelResult: CancelGroupResultDto = {
       canceled: [1],

back-end/apps/api/src/transactions/groups/transaction-groups.controller.ts

@@ -1,7 +1,6 @@
 import {
   Body,
   Controller,
-  Delete,
   Get,
   Param,
   ParseBoolPipe,
@@ -87,21 +86,4 @@ export class TransactionGroupsController {
     return this.transactionGroupsService.cancelTransactionGroup(user, groupId);
   }
 
-  /* Delete a transaction group */
-  @ApiOperation({
-    summary: 'Remove a transaction group',
-    description:
-      'Remove the transaction group, group items, and transactions for the provided transaction group id.',
-  })
-  @ApiResponse({
-    status: 200,
-    type: Boolean,
-  })
-  @Delete('/:id')
-  removeTransactionGroup(
-    @GetUser() user: User,
-    @Param('id', ParseIntPipe) groupId: number,
-  ): Promise<boolean> {
-    return this.transactionGroupsService.removeTransactionGroup(user, groupId);
-  }
 }

back-end/apps/api/src/transactions/groups/transaction-groups.service.spec.ts

@@ -4,7 +4,7 @@ import { DataSource } from 'typeorm';
 import { mock, mockDeep } from 'jest-mock-extended';
 
 import { ErrorCodes, TransactionSnapshotService } from '@app/common';
-import { emitTransactionStatusUpdate, emitTransactionUpdate } from '@app/common/utils';
+import { emitTransactionStatusUpdate } from '@app/common/utils';
 import { Transaction, TransactionGroup, TransactionStatus, User, UserStatus } from '@entities';
 
 import { CancelFailureCode, CreateTransactionGroupDto } from '../dto';
@@ -317,49 +317,6 @@ describe('TransactionGroupsService', () => {
     });
   });
 
-  describe('removeTransactionGroup', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
-    it('should throw an error if the group is not found', async () => {
-      dataSource.manager.findOneBy.mockResolvedValue(undefined);
-      await expect(service.removeTransactionGroup(user as User, 1)).rejects.toThrow(
-        'group not found',
-      );
-    });
-
-    it('should remove all group items and the group itself', async () => {
-      const mockGroup = { id: 1 };
-      const mockGroupItems = [
-        { id: 1, transactionId: 101 },
-        { id: 2, transactionId: 102 },
-      ];
-
-      dataSource.manager.findOneBy.mockResolvedValue(mockGroup);
-      dataSource.manager.find.mockResolvedValue(mockGroupItems);
-      dataSource.manager.remove
-        //@ts-expect-error - typings
-        .mockResolvedValueOnce(mockGroupItems[0])
-        //@ts-expect-error - typings
-        .mockResolvedValueOnce(mockGroupItems[1])
-        //@ts-expect-error - typings
-        .mockResolvedValueOnce(mockGroup);
-
-      await service.removeTransactionGroup(user as User, 1);
-
-      expect(dataSource.manager.remove).toHaveBeenCalledTimes(3); // Twice for group items, once for the group
-      expect(transactionsService.removeTransaction).toHaveBeenCalledTimes(mockGroupItems.length);
-      expect(emitTransactionUpdate).toHaveBeenCalledWith(
-        notificationsPublisher,
-        expect.arrayContaining([
-          expect.objectContaining({ entityId: 101 }),
-          expect.objectContaining({ entityId: 102 }),
-        ]),
-      );
-    });
-  });
-
   describe('cancelTransactionGroup', () => {
     beforeEach(() => {
       jest.resetAllMocks();

back-end/apps/api/src/transactions/groups/transaction-groups.service.ts

@@ -9,7 +9,6 @@ import { DataSource, In } from 'typeorm';
 
 import {
   emitTransactionStatusUpdate,
-  emitTransactionUpdate,
   ErrorCodes,
   getTransactionGroupItemsQuery,
   NatsPublisherService,
@@ -175,34 +174,6 @@ export class TransactionGroupsService {
     return group;
   }
 
-  async removeTransactionGroup(user: User, id: number): Promise<boolean> {
-    const group = await this.dataSource.manager.findOneBy(TransactionGroup, { id });
-    if (!group) {
-      throw new Error('group not found');
-    }
-    const groupItems = await this.dataSource.manager.find(TransactionGroupItem, {
-      relations: {
-        group: true,
-      },
-      where: {
-        group: {
-          id: group.id,
-        },
-      },
-    });
-    for (const groupItem of groupItems) {
-      const transactionId = groupItem.transactionId;
-      await this.dataSource.manager.remove(TransactionGroupItem, groupItem);
-      await this.transactionsService.removeTransaction(transactionId, user, false);
-    }
-
-    await this.dataSource.manager.remove(TransactionGroup, group);
-
-    emitTransactionUpdate(this.notificationsPublisher, groupItems.map(gi => ({ entityId: gi.transactionId })));
-
-    return true;
-  }
-
   async cancelTransactionGroup(
     user: User,
     groupId: number,

back-end/apps/api/src/transactions/transactions.controller.spec.ts

@@ -399,24 +399,6 @@ describe('TransactionsController', () => {
     });
   });
 
-  describe('deleteTransaction', () => {
-    it('should return a boolean indicating if the transaction was deleted successfully', async () => {
-      const result = true;
-
-      transactionService.removeTransaction.mockResolvedValue(result);
-
-      expect(await controller.deleteTransaction(user, 1)).toBe(result);
-    });
-
-    it('should throw an error if the transaction cannot be deleted', async () => {
-      jest
-        .spyOn(controller, 'deleteTransaction')
-        .mockRejectedValue(new BadRequestException('Transaction not found'));
-
-      await expect(controller.deleteTransaction(user, 1)).rejects.toThrow('Transaction not found');
-    });
-  });
-
   describe('cancelTransaction', () => {
     it('should return a boolean indicating if the transaction has been canceled', async () => {
       const result = true;

back-end/apps/api/src/transactions/transactions.controller.ts

@@ -1,7 +1,6 @@
 import {
   Body,
   Controller,
-  Delete,
   Get,
   Headers,
   HttpCode,
@@ -306,16 +305,4 @@ export class TransactionsController {
     return this.transactionsService.getTransactionWithVerifiedAccess(id, user);
   }
 
-  @ApiOperation({
-    summary: 'Deletes a transaction',
-    description: 'Deletes the transaction for the given transaction id.',
-  })
-  @ApiResponse({
-    status: 200,
-    type: Boolean,
-  })
-  @Delete('/:id')
-  deleteTransaction(@GetUser() user, @Param('id', ParseIntPipe) id: number): Promise<boolean> {
-    return this.transactionsService.removeTransaction(id, user, true);
-  }
 }

back-end/apps/api/src/transactions/transactions.service.spec.ts

@@ -2360,53 +2360,6 @@ describe('TransactionsService', () => {
     });
   });
 
-  describe('removeTransaction', () => {
-    const transaction = {
-      id: 123,
-      transactionId: '0.0.12345@1232351234.0123',
-      creatorKey: {
-        userId: user.id
-      },
-      mirrorNetwork: 'testnet',
-    };
-
-    beforeEach(() => {
-      jest.resetAllMocks();
-      jest
-        .spyOn(service, 'getTransactionForCreator')
-        .mockResolvedValueOnce(transaction as Transaction);
-    });
-
-    afterEach(() => {
-      expect(emitTransactionStatusUpdate).toHaveBeenCalledWith(
-        notificationsPublisher,
-        [{
-          entityId: transaction.id,
-          additionalData: {
-            transactionId: expect.any(String),
-            network: transaction.mirrorNetwork,
-          },
-        }],
-      );
-    });
-
-    it('should soft remove the transaction', async () => {
-      await service.removeTransaction(123, user as User, true);
-      expect(transactionsRepo.update).toHaveBeenCalledWith(
-        transaction.id,
-        expect.objectContaining({ status: TransactionStatus.CANCELED, executedAt: expect.any(Date) }),
-      );
-      expect(transactionsRepo.softRemove).toHaveBeenCalledWith(transaction);
-      expect(transactionSnapshotService.captureForTransaction).toHaveBeenCalledWith(transaction.id, expect.any(Date));
-    });
-
-    it('should hard remove the transaction', async () => {
-      await service.removeTransaction(123, user as User, false);
-      expect(transactionsRepo.remove).toHaveBeenCalledWith(transaction);
-      expect(transactionSnapshotService.captureForTransaction).not.toHaveBeenCalled();
-    });
-  });
-
   describe('cancelTransaction', () => {
     const mockCancelUpdateQueryBuilder = (affected: number = 1) => {
       const queryBuilder = {

back-end/apps/api/src/transactions/transactions.service.ts

@@ -881,32 +881,6 @@ export class TransactionsService {
     return Array.from(results.values());
   }
 
-  async removeTransaction(id: number, user: User, softRemove: boolean = true): Promise<boolean> {
-    const transaction = await this.getTransactionForCreator(id, user);
-
-    if (softRemove) {
-      const executedAt = new Date();
-      await this.repo.update(transaction.id, { status: TransactionStatus.CANCELED, executedAt });
-      await this.transactionSnapshotService.captureForTransaction(transaction.id, executedAt);
-      await this.repo.softRemove(transaction);
-    } else {
-      await this.repo.remove(transaction);
-    }
-
-    emitTransactionStatusUpdate(
-      this.notificationsPublisher,
-      [{
-        entityId: transaction.id,
-        additionalData: {
-          transactionId: transaction.transactionId,
-          network: transaction.mirrorNetwork,
-        },
-      }],
-    );
-
-    return true;
-  }
-
   /* Cancel the transaction if the valid start has not come yet. */
   async cancelTransaction(id: number, user: User): Promise<boolean> {
     await this.cancelTransactionWithOutcome(id, user);