fix: replace TypeORM health check with Drizzle

package.json

@@ -31,7 +31,6 @@
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/schedule": "^6.1.3",
     "@nestjs/terminus": "^10.1.0",
-    "@nestjs/typeorm": "^10.0.0",
     "@stellar/stellar-sdk": "^12.0.0",
     "axios": "^1.6.0",
     "class-transformer": "^0.5.1",
@@ -47,7 +46,6 @@
     "prom-client": "^15.0.0",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.0",
-    "typeorm": "^0.3.17",
     "uuid": "^9.0.0",
     "zod": "^4.4.3"
   },

src/__tests__/app.smoke.spec.ts

@@ -1,26 +1,12 @@
 import { INestApplication } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
-import { TypeOrmHealthIndicator } from '@nestjs/terminus';
 import request from 'supertest';
 import { AppModule } from '../app.module';
 import { CorsOriginsCacheService } from '../middleware/cors-origins-cache.service';
+import { DrizzleHealthIndicator } from '../monitoring/drizzle-health.indicator';
 import { PaymentDetectorService } from '../payments/payment-detector.service';
 import { RedisService } from '../redis/redis.service';
 
-jest.mock('@nestjs/typeorm', () => {
-  const actual = jest.requireActual('@nestjs/typeorm');
-
-  return {
-    ...actual,
-    TypeOrmModule: {
-      ...actual.TypeOrmModule,
-      forRoot: jest.fn(() => ({
-        module: class MockTypeOrmModule {},
-      })),
-    },
-  };
-});
-
 describe('App smoke test', () => {
   let app: INestApplication;
 
@@ -37,7 +23,7 @@ describe('App smoke test', () => {
     const module: TestingModule = await Test.createTestingModule({
       imports: [AppModule],
     })
-      .overrideProvider(TypeOrmHealthIndicator)
+      .overrideProvider(DrizzleHealthIndicator)
       .useValue({
         pingCheck: jest.fn().mockResolvedValue({
           database: {

src/app.module.ts

@@ -1,5 +1,4 @@
 import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
 import { ScheduleModule } from '@nestjs/schedule';
 import { AuthModule } from './auth/auth.module';
 import { MerchantsModule } from './merchants/merchants.module';
@@ -19,12 +18,6 @@ import { SecurityHeadersMiddleware } from './middleware/security-headers.middlew
   imports: [
     ConfigModule,
     ScheduleModule.forRoot(),
-    TypeOrmModule.forRoot({
-      type: 'postgres',
-      url: process.env.DATABASE_URL,
-      autoLoadEntities: true,
-      synchronize: process.env.NODE_ENV !== 'production',
-    }),
     RedisModule,
     RateLimitModule,
     AuditModule,

src/monitoring/drizzle-health.indicator.spec.ts

@@ -0,0 +1,45 @@
+import { HealthCheckError } from '@nestjs/terminus';
+import { DrizzleHealthIndicator } from './drizzle-health.indicator';
+import { db } from '../db';
+
+jest.mock('../db', () => ({
+  db: {
+    execute: jest.fn(),
+  },
+}));
+
+describe('DrizzleHealthIndicator', () => {
+  const execute = db.execute as jest.Mock;
+
+  beforeEach(() => {
+    execute.mockReset();
+  });
+
+  it('returns an up status when the Drizzle database ping succeeds', async () => {
+    execute.mockResolvedValueOnce([{ one: 1 }]);
+
+    await expect(new DrizzleHealthIndicator().pingCheck('database')).resolves.toEqual({
+      database: {
+        status: 'up',
+      },
+    });
+    expect(execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws a health check error with a down status when the Drizzle database ping fails', async () => {
+    execute.mockRejectedValueOnce(new Error('database unavailable'));
+
+    const result = new DrizzleHealthIndicator().pingCheck('database');
+
+    await expect(result).rejects.toBeInstanceOf(HealthCheckError);
+    await expect(result).rejects.toMatchObject({
+      causes: {
+        database: {
+          status: 'down',
+          message: 'database unavailable',
+        },
+      },
+    });
+    expect(execute).toHaveBeenCalledTimes(1);
+  });
+});

src/monitoring/drizzle-health.indicator.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@nestjs/common';
+import { HealthCheckError, HealthIndicator, type HealthIndicatorResult } from '@nestjs/terminus';
+import { sql } from 'drizzle-orm';
+import { db } from '../db';
+
+@Injectable()
+export class DrizzleHealthIndicator extends HealthIndicator {
+  async pingCheck(key: string): Promise<HealthIndicatorResult> {
+    try {
+      await db.execute(sql`SELECT 1`);
+
+      return this.getStatus(key, true);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Database health check failed';
+
+      throw new HealthCheckError(
+        `${key} is not available`,
+        this.getStatus(key, false, { message }),
+      );
+    }
+  }
+}

src/monitoring/health.controller.ts

@@ -1,11 +1,12 @@
 import { Controller, Get } from '@nestjs/common';
-import { HealthCheck, HealthCheckService, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { HealthCheck, HealthCheckService } from '@nestjs/terminus';
+import { DrizzleHealthIndicator } from './drizzle-health.indicator';
 
 @Controller('health')
 export class HealthController {
   constructor(
     private health: HealthCheckService,
-    private db: TypeOrmHealthIndicator,
+    private db: DrizzleHealthIndicator,
   ) {}
 
   @Get()

src/monitoring/monitoring.module.ts

@@ -1,13 +1,14 @@
 import { Module } from '@nestjs/common';
 import { TerminusModule } from '@nestjs/terminus';
 import { HealthController } from './health.controller';
+import { DrizzleHealthIndicator } from './drizzle-health.indicator';
 import { MetricsController } from './metrics.controller';
 import { MetricsService } from './metrics.service';
 
 @Module({
   imports: [TerminusModule],
   controllers: [HealthController, MetricsController],
-  providers: [MetricsService],
+  providers: [MetricsService, DrizzleHealthIndicator],
   exports: [MetricsService],
 })
 export class MonitoringModule {}