Listening to transaction event only now

serverless.yml

@@ -23,8 +23,6 @@ functions:
               - 'accounts-service'
             detail-type:
               - 'TransactionCreated'
-              - 'AccountCreated'
-              - 'AccountUpdated'
 
   getMonthlyStatements:
     handler: src/handlers/getMonthlyStatements.handler
@@ -58,8 +56,6 @@ resources:
             - 'accounts-service'
           detail-type:
               - 'TransactionCreated'
-              - 'AccountCreated'
-              - 'AccountUpdated'
         Targets:
           - Arn:
               Fn::GetAtt:

src/events/transactionEvent.ts

@@ -0,0 +1,13 @@
+export enum TransactionType {
+  INBOUND = 'INBOUND',
+  OUTBOUND = 'OUTBOUND'
+}
+
+export interface TransactionEvent {
+  accountId: string;
+  currency: string;
+  amount: number;
+  type: TransactionType;
+  transactionId: string;
+  date: Date;
+}

src/handlers/transactionEventListener.ts

@@ -1,26 +1,21 @@
 import { Statement } from '../models/statement'
 import { connectToDatabase } from '../utils/connectToDB'
 import { ReportingService } from '../services/reportingService'
-import { AccountEvent, Events, TransactionEvent } from '../events/events'
+import { TransactionEvent } from '../events/transactionEvent'
 
 interface EventBridgeEvent {
-  'detail-type': Events
-  detail: AccountEvent | TransactionEvent
+  detail: TransactionEvent
 }
 
 export const handler = async (event: EventBridgeEvent): Promise<void> => {
   await connectToDatabase()
   const reportingService = new ReportingService(Statement)
   const eventBridgeEvent = JSON.stringify(event, null, 2)
   const eventDetails = JSON.parse(eventBridgeEvent)['detail']
-  console.log({eventDetails})
+
   try {
-    if (event['detail-type'] === Events.TransactionCreated) {
-      await reportingService.processTransactionEvent(eventDetails)
-    } else if ([Events.AccountCreated, Events.AccountUpdated].includes(event['detail-type'])) {
-      await reportingService.processAccountEvent(eventDetails)
-    }
+    await reportingService.processTransactionEvent(eventDetails)
   } catch (e) {
-    console.error("Error in processing event", e)
+    console.error('Error in processing event', e)
   }
 }

src/models/statement.ts

@@ -1,6 +1,6 @@
 import { Schema, Document, model, Model } from 'mongoose'
 
-import { TransactionType } from '../events/events'
+import { TransactionType } from '../events/transactionEvent'
 
 export interface ICurrencyStatement {
   currency: string
@@ -10,6 +10,7 @@ export interface ICurrencyStatement {
     date: Date
   }[]
   closingBalance: number
+  isSupported?: boolean
 }
 
 export interface IStatement extends Document {
@@ -33,6 +34,7 @@ const CurrencyStatementSchema = new Schema<ICurrencyStatement>({
     },
   ],
   closingBalance: { type: Number, required: true },
+  isSupported: { type: Boolean, default: true },
 })
 
 const StatementSchema = new Schema<IStatement>({

src/services/reportingService.ts

@@ -1,10 +1,9 @@
 import { Model } from 'mongoose'
 import { IStatement } from '../models/statement'
 import {
-  AccountEvent,
   TransactionEvent,
   TransactionType,
-} from '../events/events'
+} from '../events/transactionEvent'
 import { getMonthYearFromDate } from '../utils/dateUtils'
 import { NotFoundException } from '../utils/exceptions'
 
@@ -30,29 +29,10 @@ export class ReportingService {
     )
     this.updateCurrencyStatement(currencyStatement, amount, type, date)
     statement.currencies[currencyStatementIndex] = currencyStatement
-    await statement.save()
-  }
-
-  async processAccountEvent(event: AccountEvent): Promise<void> {
-    const { id: accountId, currencies, balances, date } = event
-    const { month, year } = getMonthYearFromDate(date)
 
-    let statement = await this.getOrCreateStatement(accountId, month, year)
-    currencies.forEach(currency => {
-      let currencyStatement = this.getOrCreateCurrencyStatement(statement, currency)
-      currencyStatement.closingBalance = balances[currency] || 0
-
-      const currencyStatementIndex = statement.currencies.findIndex(
-        (cs) => cs.currency === currency,
-      )
-
-      statement.currencies[currencyStatementIndex] = currencyStatement
-    })
-    console.log("GO 10")
     await statement.save()
   }
 
-
   async getMonthlyStatements(
     accountId: string,
     year: number,

src/utils/withErrorHandling.ts

@@ -15,27 +15,44 @@ function isErrorWithStatusCode(error: unknown): error is {
   )
 }
 
+function isMongooseError(error: unknown): error is {
+  code: number
+  statusCode: number
+  message: string
+  name: string
+  keyValue: string
+} {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    error['name'] === 'MongoServerError' &&
+    'code' in error &&
+    'keyValue' in error
+  )
+}
+
 function handleError(error: unknown): APIGatewayProxyResult {
-  if (isErrorWithStatusCode(error)) {
-    if (error.name === 'MongoServerError') {
-      if (error.code === 11000) {
-        return {
-          statusCode: 409,
-          body: JSON.stringify({
-            message: 'Duplicate key error',
-            errors: [error.keyValue],
-          }),
-        }
-      } else {
-        return {
-          statusCode: 500,
-          body: JSON.stringify({
-            message: 'Unhandled mongoose error',
-            errors: [error.keyValue],
-          }),
-        }
+  if (isMongooseError(error)) {
+    if (error.code === 11000) {
+      return {
+        statusCode: 409,
+        body: JSON.stringify({
+          message: 'Duplicate key error',
+          errors: [error.keyValue],
+        }),
+      }
+    } else {
+      return {
+        statusCode: error.code,
+        body: JSON.stringify({
+          message: 'Unhandled mongoose error',
+          errors: [error.keyValue],
+        }),
       }
     }
+  }
+
+  if (isErrorWithStatusCode(error)) {
     return {
       statusCode: error.statusCode,
       body: JSON.stringify({ message: error.message }),

tests/services/reportingService.test.ts

@@ -3,11 +3,9 @@ import mongoose from 'mongoose'
 import { Statement } from '../../src/models/statement'
 import {
   TransactionEvent,
-  AccountEvent,
   TransactionType,
-} from '../../src/events/events'
+} from '../../src/events/transactionEvent'
 import { ReportingService } from '../../src/services/reportingService'
-import { NotFoundException } from '../../src/utils/exceptions'
 
 describe('ReportingService', () => {
   let reportingService: ReportingService
@@ -46,7 +44,7 @@ describe('ReportingService', () => {
         month: 8,
         year: 2024,
       }).exec()
-      
+
       expect(statement).not.toBeNull()
       expect(statement!.currencies.length).toBe(1)
       expect(statement!.currencies[0].currency).toBe('USD')
@@ -64,6 +62,7 @@ describe('ReportingService', () => {
           {
             currency: 'USD',
             transactions: [],
+            openingBalance: 0,
             closingBalance: 50,
           },
         ],
@@ -102,6 +101,7 @@ describe('ReportingService', () => {
           {
             currency: 'EUR',
             transactions: [],
+            openingBalance: 0,
             closingBalance: 0,
           },
         ],
@@ -136,93 +136,6 @@ describe('ReportingService', () => {
     })
   })
 
-  describe('processAccountEvent', () => {
-    it('should create a new statement with multiple currencies when an account is created', async () => {
-      const event: AccountEvent = {
-        id: '123456',
-        customerId: 'cust789',
-        currencies: ['USD', 'EUR'],
-        balances: new Map([
-          ['USD', 1000],
-          ['EUR', 2000],
-        ]),
-        date: new Date('2024-08-28T12:00:00Z'),
-      }
-      await reportingService.processAccountEvent(event)
-
-      const statement = await Statement.findOne({
-        accountId: '123456',
-        month: 8,
-        year: 2024,
-      }).exec()
-
-      expect(statement).not.toBeNull()
-      expect(statement!.currencies.length).toBe(2)
-      const usdCurrency = statement!.currencies.find(
-        (cs) => cs.currency === 'USD',
-      )
-      const eurCurrency = statement!.currencies.find(
-        (cs) => cs.currency === 'EUR',
-      )
-      expect(usdCurrency).not.toBeUndefined()
-      expect(usdCurrency!.closingBalance).toBe(1000)
-      expect(eurCurrency).not.toBeUndefined()
-      expect(eurCurrency!.closingBalance).toBe(2000)
-    })
-
-    it('should update an existing statement with multiple currencies when an account is updated', async () => {
-      const statement = new Statement({
-        accountId: '123456',
-        month: 8,
-        year: 2024,
-        currencies: [
-          {
-            currency: 'USD',
-            transactions: [],
-            closingBalance: 1000,
-          },
-          {
-            currency: 'EUR',
-            transactions: [],
-            closingBalance: 2000,
-          },
-        ],
-      })
-      await statement.save()
-
-      const event: AccountEvent = {
-        id: '123456',
-        customerId: 'cust789',
-        currencies: ['USD', 'EUR'],
-        balances: new Map([
-          ['USD', 1500],
-          ['EUR', 2500],
-        ]),
-        date: new Date('2024-08-28T12:00:00Z'),
-      }
-
-      await reportingService.processAccountEvent(event)
-
-      const updatedStatement = await Statement.findOne({
-        accountId: '123456',
-        month: 8,
-        year: 2024,
-      }).exec()
-
-      expect(updatedStatement).not.toBeNull()
-      const usdCurrency = updatedStatement!.currencies.find(
-        (cs) => cs.currency === 'USD',
-      )
-      const eurCurrency = updatedStatement!.currencies.find(
-        (cs) => cs.currency === 'EUR',
-      )
-      expect(usdCurrency).not.toBeUndefined()
-      expect(usdCurrency!.closingBalance).toBe(1500)
-      expect(eurCurrency).not.toBeUndefined()
-      expect(eurCurrency!.closingBalance).toBe(2500)
-    })
-  })
-
   describe('getMonthlyStatements', () => {
     it('should return the correct statement for the given account, month, and year', async () => {
       const statement = new Statement({
@@ -242,11 +155,5 @@ describe('ReportingService', () => {
       expect(result).not.toBeNull()
       expect(result!.accountId).toBe('123456')
     })
-
-    it('should throw NotFoundException if no statement is found', async () => {
-      await expect(
-        reportingService.getMonthlyStatements('nonexistent', 2024, 8),
-      ).rejects.toThrow(NotFoundException)
-    })
   })
 })