transaction-groups.service.ts

import {
  BadRequestException,
  Injectable,
  Logger,
  UnauthorizedException,
} from '@nestjs/common';
import { InjectDataSource } from '@nestjs/typeorm';
import { DataSource, In } from 'typeorm';

import {
  emitTransactionStatusUpdate,
  ErrorCodes,
  getTransactionGroupItemsQuery,
  NatsPublisherService,
  SqlBuilderService,
  TransactionSnapshotService,
} from '@app/common';
import { Transaction, TransactionGroup, TransactionGroupItem, TransactionStatus, User, UserKey } from '@entities';

import { TransactionsService } from '../transactions.service';

import {
  CancelFailureCode,
  CancelGroupResultDto,
  CreateTransactionGroupDto,
} from '../dto';

@Injectable()
export class TransactionGroupsService {
  private readonly logger = new Logger(TransactionGroupsService.name);

  constructor(
    private readonly transactionsService: TransactionsService,
    @InjectDataSource() private dataSource: DataSource,
    private readonly notificationsPublisher: NatsPublisherService,
    private readonly sqlBuilder: SqlBuilderService,
    private readonly transactionSnapshotService: TransactionSnapshotService,
  ) {}

  async createTransactionGroup(
    user: User,
    dto: CreateTransactionGroupDto,
  ): Promise<TransactionGroup> {
    const group = this.dataSource.manager.create(TransactionGroup, dto);

    // Extract all transaction DTOs
    const transactionDtos = dto.groupItems.map(item => item.transaction);

    // Batch create all transactions
    const transactions = await this.transactionsService.createTransactions(
      transactionDtos,
      user,
    );

    try {
      await this.dataSource.transaction(async manager => {
        // Create group items with corresponding transactions
        const groupItems = transactions.map((transaction, index) => {
          const groupItemDto = dto.groupItems[index];
          const groupItem = manager.create(TransactionGroupItem, groupItemDto);
          groupItem.transaction = transaction;
          groupItem.group = group;
          return groupItem;
        });

        // Save everything
        await manager.save(TransactionGroup, group);
        await manager.save(TransactionGroupItem, groupItems);

        emitTransactionStatusUpdate(
          this.notificationsPublisher,
          transactions.map(tx => ({
            entityId: tx.id,
          })),
        );
      });
    } catch (error) {
      this.logger.error('Failed to save transaction group', (error as any)?.stack ?? (error as any)?.message ?? String(error));
      throw new BadRequestException(ErrorCodes.FSTG);
    }

    return group;
  }

  async getTransactionGroup(user: User, id: number, full?: boolean): Promise<TransactionGroup> {
    const group = await this.dataSource.manager.findOne(TransactionGroup, {
      where: { id },
    });

    if (!group) {
      throw new BadRequestException(ErrorCodes.TNF);
    }

    const query = getTransactionGroupItemsQuery(this.sqlBuilder, id, user);

    const rows = await this.dataSource.manager.query(
      query.text,
      query.values,
    );

    group.groupItems = rows.map(row => {
      const creator = this.dataSource.manager.create(User, {
        id: row.tx_creator_key_user_id,
        email: row.tx_creator_email,
      });

      const creatorKey = this.dataSource.manager.create(UserKey, {
        id: row.tx_creator_key_id,
        userId: row.tx_creator_key_user_id,
        user: creator,
      });

      const transaction = this.dataSource.manager.create(Transaction, {
        id: row.tx_id,
        name: row.tx_name,
        type: row.tx_type,
        description: row.tx_description,
        transactionId: row.sdk_transaction_id,
        transactionHash: row.tx_transaction_hash,
        transactionBytes: row.tx_transaction_bytes,
        unsignedTransactionBytes: row.tx_unsigned_transaction_bytes,
        status: row.tx_status,
        statusCode: row.tx_status_code,
        creatorKeyId: row.tx_creator_key_id,
        creatorKey,
        signature: row.tx_signature,
        validStart: row.tx_valid_start,
        mirrorNetwork: row.tx_mirror_network,
        isManual: row.tx_is_manual,
        cutoffAt: row.tx_cutoff_at,
        createdAt: row.tx_created_at,
        executedAt: row.tx_executed_at,
        updatedAt: row.tx_updated_at,
      });

      return this.dataSource.manager.create(TransactionGroupItem, {
        seq: row.gi_seq,
        groupId: id,
        transactionId: row.tx_id,
        transaction,
      });
    });

    if (group.groupItems.length === 0) {
      throw new UnauthorizedException("You don't have permission to view this group.");
    }

    if (!full) return group;

    const transactionIds = group.groupItems.map(item => item.transactionId);

    const [
      transactionSigners,
      transactionApprovers,
      transactionObservers,
    ] = await Promise.all([
      this.transactionsService.getTransactionSignersForTransactions(transactionIds),
      this.transactionsService.getTransactionApproversForTransactions(transactionIds),
      this.transactionsService.getTransactionObserversForTransactions(transactionIds),
    ]);

    const signerMap = this.groupBy(transactionSigners, s => s.transactionId);
    const approverMap = this.groupBy(transactionApprovers, a => a.transactionId);
    const observerMap = this.groupBy(transactionObservers, o => o.transactionId);

    for (const groupItem of group.groupItems) {
      const txId = groupItem.transactionId;

      groupItem.transaction.signers = signerMap.get(txId) ?? [];
      groupItem.transaction.approvers = approverMap.get(txId) ?? [];
      groupItem.transaction.observers = observerMap.get(txId) ?? [];
    }

    return group;
  }

  async cancelTransactionGroup(
    user: User,
    groupId: number,
  ): Promise<CancelGroupResultDto> {
    const group = await this.getTransactionGroup(user, groupId, false);

    // Verify the user is the creator of all transactions in the group
    const allOwnedByUser = group.groupItems.every(
      item => item.transaction?.creatorKey?.userId === user.id,
    );
    if (!allOwnedByUser) {
      throw new UnauthorizedException('Only the creator can cancel all transactions in a group.');
    }

    const cancelableStatuses = [
      TransactionStatus.NEW,
      TransactionStatus.WAITING_FOR_SIGNATURES,
      TransactionStatus.WAITING_FOR_EXECUTION,
    ];

    // Classify transactions in-memory from already-loaded group data
    const canceled: number[] = [];
    const alreadyCanceled: number[] = [];
    const failed: { id: number; code: CancelFailureCode; message: string }[] = [];
    const cancelableIds: number[] = [];

    for (const item of group.groupItems) {
      const tx = item.transaction;
      if (tx.status === TransactionStatus.CANCELED) {
        alreadyCanceled.push(item.transactionId);
      } else if (cancelableStatuses.includes(tx.status)) {
        cancelableIds.push(item.transactionId);
      } else {
        failed.push({
          id: item.transactionId,
          code: CancelFailureCode.NOT_CANCELABLE,
          message: 'Transaction cannot be canceled in its current state.',
        });
      }
    }

    // Bulk UPDATE in a single query
    if (cancelableIds.length > 0) {
      const executedAt = new Date();
      const updateResult = await this.dataSource.getRepository(Transaction)
        .createQueryBuilder()
        .update(Transaction)
        .set({ status: TransactionStatus.CANCELED, executedAt })
        .where('id IN (:...ids)', { ids: cancelableIds })
        .andWhere('status IN (:...statuses)', { statuses: cancelableStatuses })
        .execute();

      if (updateResult.affected === cancelableIds.length) {
        // All updated successfully
        canceled.push(...cancelableIds);
      } else {
        // Race condition: some transactions changed status between classify and update.
        // Re-query only those IDs to find out what happened.
        const latestStatuses = await this.dataSource.getRepository(Transaction).find({
          where: { id: In(cancelableIds) },
          select: { id: true, status: true },
        });

        const latestMap = new Map(latestStatuses.map(t => [t.id, t.status]));
        for (const id of cancelableIds) {
          const currentStatus = latestMap.get(id);
          if (currentStatus === TransactionStatus.CANCELED) {
            canceled.push(id);
          } else if (cancelableStatuses.includes(currentStatus)) {
            // Still cancelable but wasn't affected — treat as conflict
            failed.push({
              id,
              code: CancelFailureCode.CONFLICT,
              message: 'Transaction state changed during cancellation. Please retry.',
            });
          } else {
            failed.push({
              id,
              code: CancelFailureCode.NOT_CANCELABLE,
              message: 'Transaction cannot be canceled in its current state.',
            });
          }
        }
      }

      // Batch notification — one publish for all canceled transactions
      if (canceled.length > 0) {
        emitTransactionStatusUpdate(
          this.notificationsPublisher,
          canceled.map(id => ({ entityId: id })),
        );
        await Promise.all(
          canceled.map(id => this.transactionSnapshotService.captureForTransaction(id, executedAt)),
        );
      }
    }

    return {
      canceled,
      alreadyCanceled,
      failed,
      summary: {
        processedCount: group.groupItems.length,
        canceled: canceled.length,
        alreadyCanceled: alreadyCanceled.length,
        failed: failed.length,
      },
    };
  }

  private groupBy<T>(
    items: T[],
    key: (item: T) => string | number,
  ) {
    const map = new Map<string | number, T[]>();

    for (const item of items) {
      const k = key(item);
      if (!map.has(k)) {
        map.set(k, []);
      }
      map.get(k)!.push(item);
    }

    return map;
  }

}