Merge pull request #626 from charityagbenu12-cmd/somzilla_Issues

Implement somzilla_Issues: clean up duplicates, fix bugs, add balance…

Author: Jambox11

.gitignore

@@ -64,3 +64,4 @@ src/generated/prisma/
 
 # Personal notes
 vrickish.md
+somzilla.md

src/app.module.ts

@@ -23,8 +23,6 @@ import { KeyManagementModule } from './key-management/key-management.module';
 import { BalanceIndexerModule } from './balance-indexer/balance-indexer.module';
 import { WebhookModule } from './webhooks/webhook.module';
 import { TransactionsModule } from './transactions/transactions.module';
-import { HealthModule } from './health/health.module';
-
 import { DevelopersModule } from './developers/developers.module';
 import { ProjectsModule } from './projects/projects.module';
 import { HealthModule } from './health/health.module';

src/balance-indexer/balance-indexer.controller.ts

@@ -142,17 +142,17 @@ export class BalanceIndexerController {
     @Query(ValidationPipe) pagination: PaginationDto,
     @Query(ValidationPipe) filters: BalanceFilterDto,
   ) {
-    if (assetType) {
+    if (filters.assetType) {
       const asset: Asset = {
-        type: (assetType as AssetType) || AssetType.NATIVE,
-        code: assetCode,
-        issuer: assetIssuer,
+        type: filters.assetType,
+        code: filters.assetCode,
+        issuer: filters.assetIssuer,
       };
       const balance = await this.balanceIndexerService.getBalance(
         walletId,
         asset,
       );
-      return balance ?? { balance: '0', assetType, assetCode, assetIssuer };
+      return balance ?? { balance: '0', assetType: filters.assetType, assetCode: filters.assetCode, assetIssuer: filters.assetIssuer };
     }
 
     const balances = await this.balanceIndexerService.getAllBalances(walletId);
@@ -357,8 +357,7 @@ export class BalanceIndexerController {
    * - When a mismatch is found: updates the index, increments
    *   `reconciliationAttempts`, and emits a `balance.mismatch` webhook event.
    * - When balances match: clears any prior `mismatchDetectedAt` timestamp.
-    return await this.balanceIndexerService.syncWalletBalances(request);
-  }
+   */
 
   /**
    * Manually triggers a full balance sync across all active wallets.
@@ -469,8 +468,7 @@ export class BalanceIndexerController {
    * - Emits `balance.mismatch` events for every divergence found.
    * - Recommended: protect this endpoint with an admin-level API key scope
    *   in a future iteration.
-    return await this.balanceIndexerService.reconcileBalance(walletId, asset);
-  }
+   */
 
   /**
    * Reconciles all balances for all active wallets.

src/balance-indexer/balance-indexer.service.ts

@@ -1049,7 +1049,6 @@ export class BalanceIndexerService implements OnModuleInit, OnModuleDestroy {
   }
 
   private isBalanceStale(balance: WalletBalance): boolean {
-  private isBalanceStale(balance: any): boolean {
     if (!balance.lastSyncedAt) return true;
     return Date.now() - balance.lastSyncedAt.getTime() > this.staleThresholdMs;
   }
@@ -1060,12 +1059,6 @@ export class BalanceIndexerService implements OnModuleInit, OnModuleDestroy {
 
   private calculateDifference(a: string, b: string): string {
     return (parseFloat(a) - parseFloat(b)).toFixed(7);
-  private assetsMatch(asset1: Asset, asset2: Asset): boolean {
-    return (
-      asset1.type === asset2.type &&
-      asset1.code === asset2.code &&
-      asset1.issuer === asset2.issuer
-    );
   }
 
   private assetCompoundKey(walletId: string, asset: Asset) {
@@ -1077,10 +1070,6 @@ export class BalanceIndexerService implements OnModuleInit, OnModuleDestroy {
     } as any;
   }
 
-  private calculateDifference(balance1: string, balance2: string): string {
-    return (parseFloat(balance1) - parseFloat(balance2)).toFixed(7);
-  }
-
   private balanceEventKey(event: BalanceChangeEvent): string {
     const assetKey = [
       event.asset.type,

src/balance-indexer/dto/balance-filter.dto.ts

@@ -21,4 +21,13 @@ export class BalanceFilterDto {
   @IsString({ message: 'assetCode must be a string' })
   @IsOptional()
   assetCode?: string;
+
+  @ApiProperty({
+    example: 'GBUQWP3BOUZX34ZONKXRBTLNNDOWR5HLCVPL2B4XNCLJTLMUMLTSOGBM',
+    description: 'Filter by asset issuer',
+    required: false,
+  })
+  @IsString({ message: 'assetIssuer must be a string' })
+  @IsOptional()
+  assetIssuer?: string;
 }

src/balance-indexer/stellar-horizon.service.ts

@@ -81,7 +81,6 @@ export class StellarHorizonService {
       250,
     );
 
-    this.logger.log(`Initialized Stellar Horizon client: ${this.horizonUrl}`);
     this.server = new Server(horizonUrl, { allowHttp: false });
     this.circuitBreaker = new CircuitBreaker('stellar-horizon', {
       failureThreshold: this.configService.get<number>(
@@ -208,8 +207,6 @@ export class StellarHorizonService {
     const requestId = this.requestContext.getRequestId();
     const logPrefix = requestId ? `[${requestId}] ` : '';
     try {
-      await this.withRetry(
-        () => this.mockHorizonRequest(publicKey),
       await this.executeWithRetry(
         () => this.server.loadAccount(publicKey),
         `accountExists(${publicKey.substring(0, 8)}...)`,

src/webhooks/webhook.controller.ts

@@ -9,7 +9,6 @@ import {
   Query,
   HttpCode,
   HttpStatus,
-  BadRequestException,
   UseGuards,
 } from '@nestjs/common';
 import {
@@ -22,9 +21,6 @@ import {
 } from '@nestjs/swagger';
 import { WebhookService } from './webhook.service';
 import { WebhookDispatcherService } from './webhook-dispatcher.service';
-import { DeliveryStatus } from './domain/webhook-events';
-
-const MAX_DELIVERIES_LIMIT = 200;
 import { CreateWebhookEndpointDto } from './dto/create-webhook-endpoint.dto';
 import { UpdateWebhookEndpointDto } from './dto/update-webhook-endpoint.dto';
 import { FeatureFlagGuard } from '../common/feature-flags/feature-flag.guard';
@@ -402,16 +398,6 @@ export class WebhookController {
   @Get('endpoints/:id/deliveries')
   async getDeliveries(
     @Param('id') id: string,
-    @Query('limit') limit?: string,
-    @Query('status') status?: string,
-  ) {
-    const deliveryLimit = this.parseLimit(limit);
-    const deliveryStatus = this.parseStatus(status);
-
-    const deliveries = await this.webhookService.getDeliveries(
-      id,
-      deliveryLimit,
-      deliveryStatus,
     @Query('page') page?: string,
     @Query('limit') limit?: string,
   ) {
@@ -535,43 +521,4 @@ export class WebhookController {
     };
   }
 
-  /**
-   * Parses and validates the `limit` query param for delivery history
-   */
-  private parseLimit(limit?: string): number {
-    if (limit === undefined) {
-      return 50;
-    }
-
-    const parsed = Number(limit);
-
-    if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_DELIVERIES_LIMIT) {
-      throw new BadRequestException(
-        `limit must be an integer between 1 and ${MAX_DELIVERIES_LIMIT}`,
-      );
-    }
-
-    return parsed;
-  }
-
-  /**
-   * Parses and validates the `status` query param for delivery history
-   */
-  private parseStatus(status?: string): DeliveryStatus | undefined {
-    if (status === undefined) {
-      return undefined;
-    }
-
-    const normalized = status.toUpperCase();
-
-    if (
-      !Object.values(DeliveryStatus).includes(normalized as DeliveryStatus)
-    ) {
-      throw new BadRequestException(
-        `status must be one of: ${Object.values(DeliveryStatus).join(', ')}`,
-      );
-    }
-
-    return normalized as DeliveryStatus;
-  }
 }

src/webhooks/webhook.service.spec.ts

@@ -2,10 +2,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { NotFoundException } from '@nestjs/common';
 import { WebhookService } from './webhook.service';
 import { PrismaService } from '../prisma/prisma.service';
-import { CacheService } from '../common/cache/cache.service';
-import { RequestContextService } from '../common/request-context/request-context.service';
 import { EndpointStatus } from './domain/webhook-events';
-import { WEBHOOK_ENDPOINT_CACHE_PREFIX } from './webhook.service';
 
 const PROJECT_ID = 'project-1';
 const ENDPOINT_ID = 'endpoint-1';
@@ -52,14 +49,11 @@ describe('WebhookService', () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         WebhookService,
-        CacheService,
-        RequestContextService,
         { provide: PrismaService, useValue: mockPrisma },
       ],
     }).compile();
 
     service = module.get<WebhookService>(WebhookService);
-    cache = module.get<CacheService>(CacheService);
   });
 
   it('should be defined', () => {
@@ -188,25 +182,13 @@ describe('WebhookService', () => {
       expect(result.id).toBe(ENDPOINT_ID);
     });
 
-    it('returns cached endpoint on second call without hitting the database', async () => {
+    it('hits the database each time', async () => {
       mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
 
       await service.getEndpoint(ENDPOINT_ID);
       await service.getEndpoint(ENDPOINT_ID);
 
-      expect(mockPrisma.webhookEndpoint.findUnique).toHaveBeenCalledTimes(1);
-      expect(
-        cache.get(`${WEBHOOK_ENDPOINT_CACHE_PREFIX}${ENDPOINT_ID}`),
-      ).toBeTruthy();
-    });
-
-    it('falls through to database on cache miss', async () => {
-      mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
-
-      expect(cache.get(`${WEBHOOK_ENDPOINT_CACHE_PREFIX}${ENDPOINT_ID}`)).toBeNull();
-      await service.getEndpoint(ENDPOINT_ID);
-
-      expect(mockPrisma.webhookEndpoint.findUnique).toHaveBeenCalledTimes(1);
+      expect(mockPrisma.webhookEndpoint.findUnique).toHaveBeenCalledTimes(2);
     });
 
     it('throws NotFoundException when endpoint not found', async () => {
@@ -231,22 +213,6 @@ describe('WebhookService', () => {
 
       expect(result.url).toBe('https://new.example.com/hook');
     });
-
-    it('invalidates cache after update', async () => {
-      mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
-      mockPrisma.webhookEndpoint.update.mockResolvedValue(mockEndpoint);
-
-      await service.getEndpoint(ENDPOINT_ID);
-      expect(
-        cache.get(`${WEBHOOK_ENDPOINT_CACHE_PREFIX}${ENDPOINT_ID}`),
-      ).toBeTruthy();
-
-      await service.updateEndpoint(ENDPOINT_ID, { description: 'updated' });
-
-      expect(
-        cache.get(`${WEBHOOK_ENDPOINT_CACHE_PREFIX}${ENDPOINT_ID}`),
-      ).toBeNull();
-    });
   });
 
   // ─── deleteEndpoint ──────────────────────────────────────────────────────────
@@ -261,18 +227,6 @@ describe('WebhookService', () => {
         where: { id: ENDPOINT_ID },
       });
     });
-
-    it('invalidates cache after delete', async () => {
-      mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
-      mockPrisma.webhookEndpoint.delete.mockResolvedValue(mockEndpoint);
-
-      await service.getEndpoint(ENDPOINT_ID);
-      await service.deleteEndpoint(ENDPOINT_ID);
-
-      expect(
-        cache.get(`${WEBHOOK_ENDPOINT_CACHE_PREFIX}${ENDPOINT_ID}`),
-      ).toBeNull();
-    });
   });
 
   // ─── rotateSecret ─────────────────────────────────────────────────────────────
@@ -296,20 +250,22 @@ describe('WebhookService', () => {
 
   describe('getDeliveries', () => {
     it('returns paginated deliveries with default page and limit', async () => {
+      mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
       mockPrisma.webhookDelivery.findMany.mockResolvedValue([]);
       mockPrisma.webhookDelivery.count.mockResolvedValue(0);
 
       const result = await service.getDeliveries(ENDPOINT_ID);
 
       expect(mockPrisma.webhookDelivery.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({ skip: 0, take: 20 }),
+        expect.objectContaining({ skip: 0, take: 50 }),
       );
       expect(result.page).toBe(1);
-      expect(result.limit).toBe(20);
+      expect(result.limit).toBe(50);
       expect(result.total).toBe(0);
     });
 
     it('respects custom page and limit', async () => {
+      mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
       mockPrisma.webhookDelivery.findMany.mockResolvedValue([]);
       mockPrisma.webhookDelivery.count.mockResolvedValue(50);
 
@@ -324,6 +280,7 @@ describe('WebhookService', () => {
     });
 
     it('returns deliveries in the response', async () => {
+      mockPrisma.webhookEndpoint.findUnique.mockResolvedValue(mockEndpoint);
       const delivery = {
         id: 'delivery-1',
         endpointId: ENDPOINT_ID,