feat(credit): persist credit lines in PostgreSQL

migrations/002_add_interest_rate_to_credit_lines.sql

@@ -0,0 +1,10 @@
+-- Add interest_rate_bps column to credit_lines table
+-- This field stores the interest rate in basis points (e.g., 500 = 5%)
+
+ALTER TABLE credit_lines 
+ADD COLUMN interest_rate_bps INTEGER NOT NULL DEFAULT 0;
+
+COMMENT ON COLUMN credit_lines.interest_rate_bps IS 'Interest rate in basis points (e.g., 500 = 5%)';
+
+-- Add index for queries filtering by interest rate
+CREATE INDEX credit_lines_interest_rate_bps_idx ON credit_lines (interest_rate_bps);

src/__test__/creditRoute.test.ts

@@ -17,7 +17,7 @@
 
 import creditRouter from "../routes/credit.js";
 import { adminAuth } from "../middleware/adminAuth.js";
-import { afterEach, beforeEach, vi } from "vitest";
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
 
 const mockAdminAuth = vi.mocked(adminAuth);
 
@@ -37,8 +37,8 @@
 }
 
 function denyAdmin() {
-  mockAdminAuth.mockImplementation((_req, res: any, _next) => {
+  mockAdminAuth.mockImplementation((_req, res: Response, _next) => {
     res.status(401).json({ error: "Unauthorized: valid X-Admin-Api-Key header is required." });
   });
 }
 

src/__test__/horizonListener.test.ts

@@ -14,7 +14,7 @@
 } from "../services/horizonListener.js";
 import { vi, type Mock } from "vitest";
 
 const baseConfig: HorizonListenerConfig = {
   horizonUrl: "https://horizon-testnet.stellar.org",
   contractIds: [],
   pollIntervalMs: 5000,
@@ -392,6 +392,13 @@
 // pollOnce()
 // ---------------------------------------------------------------------------
 
+const baseConfig: HorizonListenerConfig = {
+  horizonUrl: "https://horizon-testnet.stellar.org",
+  contractIds: [],
+  pollIntervalMs: 5000,
+  startLedger: "latest",
+};
+
 describe("pollOnce()", () => {
 
   it("completes without throwing when contractIds is empty", async () => {

src/__tests__/index.test.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import request from 'supertest';
+import type { Server } from 'http';
 
 // We need to test the actual index.ts file, so let's create a separate test
 describe('Main Application', () => {
-  let server: any;
+  let server: Server | undefined;
 
   afterEach(() => {
     if (server) {

src/container/Container.ts

@@ -4,6 +4,7 @@
 import { InMemoryCreditLineRepository } from "../repositories/memory/InMemoryCreditLineRepository.js";
 import { InMemoryRiskEvaluationRepository } from "../repositories/memory/InMemoryRiskEvaluationRepository.js";
 import { InMemoryTransactionRepository } from "../repositories/memory/InMemoryTransactionRepository.js";
+import { PostgresCreditLineRepository } from "../repositories/postgres/PostgresCreditLineRepository.js";
 import { CreditLineService } from "../services/CreditLineService.js";
 import { RiskEvaluationService } from "../services/RiskEvaluationService.js";
 import { ReconciliationService } from "../services/reconciliationService.js";
@@ -14,10 +15,13 @@
 export class Container {
   private static instance: Container;
 
+  // Database client
+  private _dbClient?: DbClient;
+
   // Repositories
-  private _creditLineRepository: CreditLineRepository;
-  private _riskEvaluationRepository: RiskEvaluationRepository;
-  private _transactionRepository: TransactionRepository;
+  private _creditLineRepository!: CreditLineRepository;
+  private _riskEvaluationRepository!: RiskEvaluationRepository;
+  private _transactionRepository!: TransactionRepository;
 
   // Services
   private _creditLineService: CreditLineService;
@@ -26,16 +30,14 @@
   private _reconciliationWorker: ReconciliationWorker;
 
   private constructor() {
-    // Initialize repositories (in-memory implementations for now)
-    this._creditLineRepository = new InMemoryCreditLineRepository();
-    this._riskEvaluationRepository = new InMemoryRiskEvaluationRepository();
-    this._transactionRepository = new InMemoryTransactionRepository();
+    // Initialize repositories based on environment
+    this.initializeRepositories();
 
     // Initialize services
     this._creditLineService = new CreditLineService(this._creditLineRepository);
     this._riskEvaluationService = new RiskEvaluationService(
       this._riskEvaluationRepository,
       createRiskProvider(),
     );
 
     // Initialize Soroban client and reconciliation services
@@ -52,6 +54,24 @@
     );
   }
 
+  private initializeRepositories(): void {
+    const useDatabase = process.env.DATABASE_URL && process.env.NODE_ENV !== 'test';
+
+    if (useDatabase) {
+      // Use PostgreSQL repositories
+      this._dbClient = getConnection();
+      this._creditLineRepository = new PostgresCreditLineRepository(this._dbClient);
+      // TODO: Implement PostgreSQL versions of other repositories
+      this._riskEvaluationRepository = new InMemoryRiskEvaluationRepository();
+      this._transactionRepository = new InMemoryTransactionRepository();
+    } else {
+      // Use in-memory repositories (for development/testing)
+      this._creditLineRepository = new InMemoryCreditLineRepository();
+      this._riskEvaluationRepository = new InMemoryRiskEvaluationRepository();
+      this._transactionRepository = new InMemoryTransactionRepository();
+    }
+  }
+
   public static getInstance(): Container {
     if (!Container.instance) {
       Container.instance = new Container();
@@ -106,7 +126,7 @@
       this._riskEvaluationRepository = repositories.riskEvaluationRepository;
       this._riskEvaluationService = new RiskEvaluationService(
         this._riskEvaluationRepository,
         createRiskProvider(),
       );
     }
 

src/container/__tests__/Container.postgres.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Container } from '../Container.js';
+import { InMemoryCreditLineRepository } from '../../repositories/memory/InMemoryCreditLineRepository.js';
+import { PostgresCreditLineRepository } from '../../repositories/postgres/PostgresCreditLineRepository.js';
+
+// Mock the database client
+vi.mock('../../db/client.js', () => ({
+  getConnection: vi.fn(() => ({
+    query: vi.fn().mockResolvedValue({ rows: [] }),
+    end: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+describe('Container - PostgreSQL Integration', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    // Reset the singleton instance
+    (Container as unknown as { instance: Container | undefined }).instance = undefined;
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should use in-memory repositories when DATABASE_URL is not set', () => {
+    delete process.env.DATABASE_URL;
+
+    const container = Container.getInstance();
+    const repository = container.creditLineRepository;
+
+    expect(repository).toBeInstanceOf(InMemoryCreditLineRepository);
+  });
+
+  it('should use in-memory repositories in test environment even with DATABASE_URL', () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    process.env.NODE_ENV = 'test';
+
+    const container = Container.getInstance();
+    const repository = container.creditLineRepository;
+
+    expect(repository).toBeInstanceOf(InMemoryCreditLineRepository);
+  });
+
+  it('should use PostgreSQL repositories when DATABASE_URL is set and not in test environment', () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    process.env.NODE_ENV = 'development';
+
+    const container = Container.getInstance();
+    const repository = container.creditLineRepository;
+
+    expect(repository).toBeInstanceOf(PostgresCreditLineRepository);
+  });
+
+  it('should use PostgreSQL repositories in production environment', () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    process.env.NODE_ENV = 'production';
+
+    const container = Container.getInstance();
+    const repository = container.creditLineRepository;
+
+    expect(repository).toBeInstanceOf(PostgresCreditLineRepository);
+  });
+
+  it('should properly shutdown database connections', async () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    process.env.NODE_ENV = 'development';
+
+    const container = Container.getInstance();
+
+    // Mock console.log to avoid test output noise
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await container.shutdown();
+
+    expect(consoleSpy).toHaveBeenCalledWith('[Container] Database connection closed.');
+    expect(consoleSpy).toHaveBeenCalledWith('[Container] All services shut down.');
+
+    consoleSpy.mockRestore();
+  });
+
+  it('should handle database connection close errors gracefully', async () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    process.env.NODE_ENV = 'development';
+
+    // Mock getConnection to return a client that throws on end()
+    const { getConnection } = await import('../../db/client.js');
+    vi.mocked(getConnection).mockReturnValue({
+      query: vi.fn().mockResolvedValue({ rows: [] }),
+      end: vi.fn().mockRejectedValue(new Error('Connection close failed')),
+    });
+
+    const container = Container.getInstance();
+
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await container.shutdown();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      '[Container] Error closing database connection:',
+      expect.any(Error)
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith('[Container] All services shut down.');
+
+    consoleSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+});

src/db/migrations.test.ts

@@ -82,7 +82,7 @@ describe('applyMigration', () => {
     await applyMigration(client, migrationsDir, '001_initial_schema.sql');
     expect(client.query).toHaveBeenCalled();
     const insertCall = vi.mocked(client.query).mock.calls.find(
-      (c) => typeof c[0] === 'string' && c[0].includes('INSERT INTO schema_migrations')
+      (c: any[]) => typeof c[0] === 'string' && c[0].includes('INSERT INTO schema_migrations')
     );
     expect(insertCall).toBeDefined();
     expect(insertCall![1]).toEqual(['001_initial_schema']);
@@ -94,7 +94,7 @@ describe('runPendingMigrations', () => {
     const client = createMockClient();
     vi.mocked(client.query)
       .mockResolvedValueOnce({ rows: [] })
-      .mockResolvedValueOnce({ rows: [{ version: '001_initial_schema' }] });
+      .mockResolvedValueOnce({ rows: [{ version: '001_initial_schema' }, { version: '002_add_interest_rate_to_credit_lines' }] });
     const migrationsDir = await import('path').then((p) =>
       p.join(process.cwd(), 'migrations')
     );
@@ -112,7 +112,21 @@ describe('runPendingMigrations', () => {
     );
     const run = await runPendingMigrations(client, migrationsDir);
     expect(run).toContain('001_initial_schema');
-    expect(run.length).toBeGreaterThanOrEqual(1);
+    expect(run).toContain('002_add_interest_rate_to_credit_lines');
+    expect(run.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('applies only new migrations when some are already applied', async () => {
+    const client = createMockClient();
+    vi.mocked(client.query)
+      .mockResolvedValueOnce({ rows: [] })
+      .mockResolvedValueOnce({ rows: [{ version: '001_initial_schema' }] });
+    const migrationsDir = await import('path').then((p) =>
+      p.join(process.cwd(), 'migrations')
+    );
+    const run = await runPendingMigrations(client, migrationsDir);
+    expect(run).toContain('002_add_interest_rate_to_credit_lines');
+    expect(run).not.toContain('001_initial_schema');
   });
 });