@zeeshan60/event-processor 1.0.48 → 1.0.50

package/dist/utils/GroupUtil.js

@@ -0,0 +1,762 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processGroupEventForPerspectives = processGroupEventForPerspectives;
+exports.generateFriendEventsForMissingFriendships = generateFriendEventsForMissingFriendships;
+exports.generateGroupPerspectiveEvents = generateGroupPerspectiveEvents;
+exports.processGroupTransactionEventForPerspectives = processGroupTransactionEventForPerspectives;
+exports.calculateDebtsForMember = calculateDebtsForMember;
+exports.generatePerspectiveEvents = generatePerspectiveEvents;
+exports.generateTransactionEventsForGroupTransactionModel = generateTransactionEventsForGroupTransactionModel;
+exports.buildYouPaidSplitEquallyEvent = buildYouPaidSplitEquallyEvent;
+exports.buildTheyPaidSplitEquallyEvent = buildTheyPaidSplitEquallyEvent;
+exports.buildSpecificAmountsEvent = buildSpecificAmountsEvent;
+exports.toGroupTransactionResponse = toGroupTransactionResponse;
+const __1 = require("..");
+const EventTypes_1 = require("../common/EventTypes");
+const uuid_1 = require("uuid");
+const splitTypeUtils_1 = require("./splitTypeUtils");
+function processGroupEventForPerspectives(event, existingGroupModels, friendModelsByUserId, existingUsersInGroup) {
+    console.log(`[Debug] processGroupEventForPerspectives: eventType=${event.eventType}, userId=${event.userId}, streamId=${event.streamId}`);
+    console.log(`[Debug] processGroupEventForPerspectives: existingGroupModels.size=${existingGroupModels.size}, existingUsersInGroup.length=${existingUsersInGroup.length}`);
+    console.log(`[Debug] processGroupEventForPerspectives: existingGroupModels keys=${JSON.stringify([...existingGroupModels.keys()])}`);
+    const groupEventsToSave = [];
+    const friendEventsToSave = [];
+    const groupModelsToSave = [];
+    const friendModelsToSave = [];
+    const perspectiveEvents = generateGroupPerspectiveEvents(event, existingGroupModels);
+    console.log(`[Debug] processGroupEventForPerspectives: generated ${perspectiveEvents.length} perspective events`);
+    for (const perspectiveEvent of perspectiveEvents) {
+        const existingPerspective = existingGroupModels.get(perspectiveEvent.userId);
+        const perspectiveModel = perspectiveEvent.apply(existingPerspective);
+        groupModelsToSave.push(perspectiveModel);
+        groupEventsToSave.push(perspectiveEvent);
+        const friendModels = friendModelsByUserId[perspectiveModel.userId] ?? [];
+        const friendModelsByStreamId = new Map(friendModels.map((f) => [f.streamId, f]));
+        const friendEvents = generateFriendEventsForMissingFriendships(perspectiveModel, friendModels, existingUsersInGroup);
+        for (const friendEvent of friendEvents) {
+            const existingFriendModel = friendModelsByStreamId.get(friendEvent.streamId);
+            const friendModel = friendEvent.apply(existingFriendModel);
+            friendModelsToSave.push(friendModel);
+            friendEventsToSave.push(friendEvent);
+        }
+    }
+    console.log(`[Debug] processGroupEventForPerspectives: returning groupEventsToSave.length=${groupEventsToSave.length}, friendEventsToSave.length=${friendEventsToSave.length}`);
+    console.log(`[Debug] processGroupEventForPerspectives: returning groupModelsToSave.length=${groupModelsToSave.length}, friendModelsToSave.length=${friendModelsToSave.length}`);
+    return {
+        groupEventsToSave,
+        friendEventsToSave,
+        groupModelsToSave,
+        friendModelsToSave,
+    };
+}
+function generateFriendEventsForMissingFriendships(groupModel, friendModels, existingUsersInGroup) {
+    console.log(`[Debug] generateFriendEventsForMissingFriendships: groupModel.userId=${groupModel.userId}, groupModel.groupId=${groupModel.groupId}`);
+    console.log(`[Debug] generateFriendEventsForMissingFriendships: friendModels.length=${friendModels.length}, existingUsersInGroup.length=${existingUsersInGroup.length}`);
+    console.log(`[Debug] generateFriendEventsForMissingFriendships: groupModel.members=${JSON.stringify(groupModel.members)}`);
+    const events = [];
+    const memberIds = groupModel.members ?? [];
+    // Separate active and deleted friend models by friendId
+    const activeFriendIds = new Set();
+    const deletedFriendsByFriendId = new Map();
+    for (const friendModel of friendModels) {
+        if (!friendModel.friendId)
+            continue;
+        if (friendModel.deleted) {
+            deletedFriendsByFriendId.set(friendModel.friendId, friendModel);
+        }
+        else {
+            activeFriendIds.add(friendModel.friendId);
+        }
+    }
+    // Create a map of user data by userId for quick lookup
+    const userDataMap = new Map();
+    for (const user of existingUsersInGroup) {
+        userDataMap.set(user.userId, user);
+    }
+    // Generate friend events for members not already active friends (excluding current user)
+    for (const memberId of memberIds) {
+        if (memberId === groupModel.userId) {
+            continue;
+        }
+        if (activeFriendIds.has(memberId)) {
+            continue;
+        }
+        const userData = userDataMap.get(memberId);
+        if (!userData) {
+            console.warn(`[generateFriendEventsForMissingFriendships] User data not found for memberId: ${memberId}`);
+            continue;
+        }
+        const deletedFriend = deletedFriendsByFriendId.get(memberId);
+        if (deletedFriend) {
+            // Restore deleted friend with FriendUnDeleted
+            events.push(new __1.FriendUnDeleted({
+                eventId: (0, uuid_1.v4)(),
+                userId: groupModel.userId,
+                friendEmail: userData.email,
+                friendPhoneNumber: userData.phoneNumber,
+                friendDisplayName: userData.displayName,
+                photoUrl: userData.photoUrl,
+                createdAt: new Date(),
+                createdBy: groupModel.userId,
+                streamId: deletedFriend.streamId,
+                version: deletedFriend.version + 1,
+                systemGenerated: true,
+            }));
+        }
+        else {
+            // Create new friend with FriendCreated
+            events.push(new __1.FriendCreated({
+                eventId: (0, uuid_1.v4)(),
+                userId: groupModel.userId,
+                friendId: memberId,
+                friendEmail: userData.email,
+                friendPhoneNumber: userData.phoneNumber,
+                friendDisplayName: userData.displayName,
+                photoUrl: userData.photoUrl,
+                groupId: groupModel.groupId,
+                createdAt: new Date(),
+                createdBy: groupModel.userId,
+                streamId: (0, uuid_1.v4)(),
+                version: 1,
+                systemGenerated: true,
+            }));
+        }
+    }
+    console.log(`[Debug] generateFriendEventsForMissingFriendships: returning ${events.length} friend events`);
+    return events;
+}
+function generateGroupPerspectiveEvents(clientEvent, existingGroupModels) {
+    console.log(`[Debug] generateGroupPerspectiveEvents: eventType=${clientEvent.eventType}, userId=${clientEvent.userId}, streamId=${clientEvent.streamId}`);
+    console.log(`[Debug] generateGroupPerspectiveEvents: existingGroupModels provided=${!!existingGroupModels}, size=${existingGroupModels?.size ?? 0}`);
+    const events = [];
+    switch (clientEvent.eventType) {
+        case EventTypes_1.EventType.GROUP_CREATED: {
+            const event = clientEvent;
+            const otherMembers = (event.members ?? []).filter((id) => id !== event.userId);
+            console.log(`[Debug] generateGroupPerspectiveEvents GROUP_CREATED: members=${JSON.stringify(event.members)}, otherMembers=${JSON.stringify(otherMembers)}`);
+            for (const memberId of otherMembers) {
+                events.push(new __1.GroupCreated({
+                    eventId: (0, uuid_1.v4)(),
+                    userId: memberId,
+                    groupId: event.groupId,
+                    name: event.name,
+                    description: event.description,
+                    members: event.members,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: (0, uuid_1.v4)(),
+                    version: 1,
+                    systemGenerated: true,
+                }));
+            }
+            break;
+        }
+        case EventTypes_1.EventType.GROUP_UPDATED: {
+            const event = clientEvent;
+            if (!existingGroupModels) {
+                console.warn(`[generateGroupPerspectiveEvents] existingGroupModels is required for GROUP_UPDATED but was not provided. streamId: ${event.streamId}`);
+                break;
+            }
+            for (const [userId, model] of existingGroupModels) {
+                if (model.streamId !== event.streamId) {
+                    events.push(new __1.GroupUpdated({
+                        eventId: (0, uuid_1.v4)(),
+                        userId: userId,
+                        name: event.name,
+                        description: event.description,
+                        createdAt: new Date(),
+                        createdBy: event.createdBy,
+                        streamId: model.streamId,
+                        version: model.version + 1,
+                        systemGenerated: true,
+                    }));
+                }
+            }
+            break;
+        }
+        case EventTypes_1.EventType.GROUP_MEMBERS_ADDED: {
+            const event = clientEvent;
+            if (!existingGroupModels) {
+                console.warn(`[generateGroupPerspectiveEvents] existingGroupModels is required for GROUP_MEMBERS_ADDED but was not provided. streamId: ${event.streamId}`);
+                break;
+            }
+            const triggerModel = existingGroupModels.get(event.userId);
+            if (!triggerModel) {
+                console.warn(`[generateGroupPerspectiveEvents] triggerModel not found for GROUP_MEMBERS_ADDED. userId: ${event.userId}, streamId: ${event.streamId}`);
+                break;
+            }
+            // Include both existing and new members
+            const existingMembers = triggerModel.members ?? [];
+            const existingMembersSet = new Set(existingMembers);
+            const allMemberIds = [...new Set([...existingMembers, ...event.members])];
+            // GroupCreated for newly added members (skip if already in group)
+            for (const newMemberId of event.members) {
+                if (existingMembersSet.has(newMemberId)) {
+                    continue;
+                }
+                events.push(new __1.GroupCreated({
+                    eventId: (0, uuid_1.v4)(),
+                    userId: newMemberId,
+                    groupId: triggerModel.groupId,
+                    name: triggerModel.name,
+                    description: triggerModel.description,
+                    members: allMemberIds,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: (0, uuid_1.v4)(),
+                    version: 1,
+                    systemGenerated: true,
+                }));
+            }
+            // GroupMembersAdded for existing members (excluding trigger user and new members)
+            for (const [userId, model] of existingGroupModels) {
+                if (model.streamId !== event.streamId &&
+                    !event.members.includes(userId)) {
+                    events.push(new __1.GroupMembersAdded({
+                        eventId: (0, uuid_1.v4)(),
+                        userId: userId,
+                        members: event.members,
+                        createdAt: new Date(),
+                        createdBy: event.createdBy,
+                        streamId: model.streamId,
+                        version: model.version + 1,
+                        systemGenerated: true,
+                    }));
+                }
+            }
+            break;
+        }
+        case EventTypes_1.EventType.GROUP_MEMBERS_REMOVED: {
+            const event = clientEvent;
+            if (!existingGroupModels) {
+                console.warn(`[generateGroupPerspectiveEvents] existingGroupModels is required for GROUP_MEMBERS_REMOVED but was not provided. streamId: ${event.streamId}`);
+                break;
+            }
+            // GroupDeleted for removed members
+            for (const removedMemberId of event.members) {
+                const removedModel = existingGroupModels.get(removedMemberId);
+                if (removedModel) {
+                    events.push(new __1.GroupDeleted({
+                        eventId: (0, uuid_1.v4)(),
+                        userId: removedMemberId,
+                        createdAt: new Date(),
+                        createdBy: event.createdBy,
+                        streamId: removedModel.streamId,
+                        version: removedModel.version + 1,
+                        systemGenerated: true,
+                    }));
+                }
+            }
+            // GroupMembersRemoved for remaining members (excluding trigger user and removed members)
+            for (const [userId, model] of existingGroupModels) {
+                if (model.streamId !== event.streamId &&
+                    !event.members.includes(userId)) {
+                    events.push(new __1.GroupMembersRemoved({
+                        eventId: (0, uuid_1.v4)(),
+                        userId: userId,
+                        members: event.members,
+                        createdAt: new Date(),
+                        createdBy: event.createdBy,
+                        streamId: model.streamId,
+                        version: model.version + 1,
+                        systemGenerated: true,
+                    }));
+                }
+            }
+            break;
+        }
+        case EventTypes_1.EventType.GROUP_DELETED: {
+            const event = clientEvent;
+            if (!existingGroupModels) {
+                console.warn(`[generateGroupPerspectiveEvents] existingGroupModels is required for GROUP_DELETED but was not provided. streamId: ${event.streamId}`);
+                break;
+            }
+            for (const [userId, model] of existingGroupModels) {
+                if (model.streamId !== event.streamId) {
+                    events.push(new __1.GroupDeleted({
+                        eventId: (0, uuid_1.v4)(),
+                        userId: userId,
+                        createdAt: new Date(),
+                        createdBy: event.createdBy,
+                        streamId: model.streamId,
+                        version: model.version + 1,
+                        systemGenerated: true,
+                    }));
+                }
+            }
+            break;
+        }
+    }
+    console.log(`[Debug] generateGroupPerspectiveEvents: returning ${events.length} events`);
+    return events;
+}
+function processGroupTransactionEventForPerspectives(event, updatedModel, existingPerspectiveModels, existingTransactionModels) {
+    console.log(`[Debug] processGroupTransactionEventForPerspectives: eventType=${event.eventType}, userId=${event.userId}, streamId=${event.streamId}`);
+    console.log(`[Debug] processGroupTransactionEventForPerspectives: existingPerspectiveModels.size=${existingPerspectiveModels.size}, existingTransactionModels.length=${existingTransactionModels.length}`);
+    const groupTransactionEventsToSave = [];
+    const groupTransactionModelsToSave = [];
+    const transactionModelsToSave = [];
+    const perspectiveEvents = generatePerspectiveEvents(event, updatedModel, existingPerspectiveModels);
+    console.log(`[Debug] processGroupTransactionEventForPerspectives: generated ${perspectiveEvents.length} perspective events`);
+    for (const perspectiveEvent of perspectiveEvents) {
+        const existingPerspective = existingPerspectiveModels.get(perspectiveEvent.userId);
+        const perspectiveModel = perspectiveEvent.apply(existingPerspective);
+        groupTransactionModelsToSave.push(perspectiveModel);
+        groupTransactionEventsToSave.push(perspectiveEvent);
+    }
+    const transactionEvents = generateTransactionEventsForGroupTransactionModel(existingTransactionModels, updatedModel);
+    for (const transactionEvent of transactionEvents) {
+        const existingTx = existingTransactionModels.find((tx) => tx.streamId === transactionEvent.streamId);
+        const transactionModel = transactionEvent.apply(existingTx);
+        transactionModelsToSave.push(transactionModel);
+    }
+    console.log(`[Debug] processGroupTransactionEventForPerspectives: returning groupTransactionEventsToSave.length=${groupTransactionEventsToSave.length}, transactionEvents.length=${transactionEvents.length}`);
+    return {
+        groupTransactionEventsToSave,
+        groupTransactionModelsToSave,
+        transactionEventsToSave: transactionEvents,
+        transactionModelsToSave,
+    };
+}
+function calculateDebtsForMember(originalTransaction, memberId) {
+    const members = originalTransaction.members;
+    const whoYouOwe = [];
+    const whoOweYou = [];
+    const balances = members.map((m) => ({
+        memberId: m.memberId,
+        balance: m.paid - m.owed,
+    }));
+    const creditors = balances
+        .filter((b) => b.balance > 0)
+        .map((b) => ({ ...b, remaining: b.balance }));
+    const debtors = balances
+        .filter((b) => b.balance < 0)
+        .map((b) => ({ ...b, remaining: -b.balance }));
+    for (const debtor of debtors) {
+        for (const creditor of creditors) {
+            if (debtor.remaining <= 0 || creditor.remaining <= 0)
+                continue;
+            const amount = Math.min(debtor.remaining, creditor.remaining);
+            debtor.remaining -= amount;
+            creditor.remaining -= amount;
+            if (debtor.memberId === memberId) {
+                whoYouOwe.push({ memberId: creditor.memberId, amount });
+            }
+            if (creditor.memberId === memberId) {
+                whoOweYou.push({ memberId: debtor.memberId, amount });
+            }
+        }
+    }
+    return { whoYouOwe, whoOweYou };
+}
+function generatePerspectiveEvents(clientEvent, updatedModel, existingPerspectiveModels) {
+    console.log(`[Debug] generatePerspectiveEvents: eventType=${clientEvent.eventType}, userId=${clientEvent.userId}`);
+    console.log(`[Debug] generatePerspectiveEvents: existingPerspectiveModels provided=${!!existingPerspectiveModels}, size=${existingPerspectiveModels?.size ?? 0}`);
+    const perspectiveEvents = [];
+    const eventType = clientEvent.eventType;
+    const memberIds = updatedModel.originalTransaction.members.map((m) => m.memberId);
+    console.log(`[Debug] generatePerspectiveEvents: memberIds=${JSON.stringify(memberIds)}`);
+    for (const memberId of memberIds) {
+        if (memberId === clientEvent.userId) {
+            console.log(`[Debug] generatePerspectiveEvents: skipping clientEvent.userId=${clientEvent.userId}`);
+            continue;
+        }
+        const existingModel = existingPerspectiveModels?.get(memberId);
+        const streamId = existingModel?.streamId ?? (0, uuid_1.v4)();
+        const version = existingModel ? existingModel.version + 1 : 1;
+        if (eventType === EventTypes_1.EventType.GROUP_TRANSACTION_CREATED) {
+            const createdEvent = clientEvent;
+            let perspectiveSplitType = createdEvent.splitType;
+            if (perspectiveSplitType !== __1.SplitTypeEnum.SpecificAmounts) {
+                perspectiveSplitType = (0, splitTypeUtils_1.reverseSplitType)(perspectiveSplitType);
+            }
+            const { whoYouOwe, whoOweYou } = calculateDebtsForMember(createdEvent.originalTransaction, memberId);
+            perspectiveEvents.push(new __1.GroupTransactionCreated({
+                eventId: (0, uuid_1.v4)(),
+                userId: memberId,
+                groupId: createdEvent.groupId,
+                transactionId: createdEvent.transactionId,
+                description: createdEvent.description,
+                notes: createdEvent.notes,
+                totalAmount: createdEvent.totalAmount,
+                currency: createdEvent.currency,
+                splitType: perspectiveSplitType,
+                transactionDate: createdEvent.transactionDate,
+                originalTransaction: createdEvent.originalTransaction,
+                whoYouOwe,
+                whoOweYou,
+                createdAt: createdEvent.createdAt,
+                createdBy: createdEvent.createdBy,
+                streamId,
+                version,
+                systemGenerated: true,
+            }));
+        }
+        else if (eventType === EventTypes_1.EventType.GROUP_TRANSACTION_UPDATED) {
+            const updatedEvent = clientEvent;
+            let perspectiveSplitType = updatedEvent.splitType;
+            if (perspectiveSplitType !== undefined &&
+                perspectiveSplitType !== __1.SplitTypeEnum.SpecificAmounts) {
+                perspectiveSplitType = (0, splitTypeUtils_1.reverseSplitType)(perspectiveSplitType);
+            }
+            let whoYouOwe = updatedEvent.whoYouOwe;
+            let whoOweYou = updatedEvent.whoOweYou;
+            if (updatedEvent.originalTransaction) {
+                const debts = calculateDebtsForMember(updatedEvent.originalTransaction, memberId);
+                whoYouOwe = debts.whoYouOwe;
+                whoOweYou = debts.whoOweYou;
+            }
+            perspectiveEvents.push(new __1.GroupTransactionUpdated({
+                eventId: (0, uuid_1.v4)(),
+                userId: memberId,
+                description: updatedEvent.description,
+                notes: updatedEvent.notes,
+                totalAmount: updatedEvent.totalAmount,
+                currency: updatedEvent.currency,
+                splitType: perspectiveSplitType,
+                transactionDate: updatedEvent.transactionDate,
+                originalTransaction: updatedEvent.originalTransaction,
+                whoYouOwe,
+                whoOweYou,
+                createdAt: updatedEvent.createdAt,
+                createdBy: updatedEvent.createdBy,
+                streamId,
+                version,
+                systemGenerated: true,
+            }));
+        }
+        else if (eventType === EventTypes_1.EventType.GROUP_TRANSACTION_DELETED) {
+            const deletedEvent = clientEvent;
+            perspectiveEvents.push(new __1.GroupTransactionDeleted({
+                eventId: (0, uuid_1.v4)(),
+                userId: memberId,
+                createdAt: new Date(),
+                createdBy: deletedEvent.createdBy,
+                streamId,
+                version,
+                systemGenerated: true,
+            }));
+        }
+    }
+    console.log(`[Debug] generatePerspectiveEvents: returning ${perspectiveEvents.length} perspective events`);
+    return perspectiveEvents;
+}
+function generateTransactionEventsForGroupTransactionModel(existingGroupTransactions, updatedModel) {
+    console.log(`[Debug] generateTransactionEventsForGroupTransactionModel: updatedModel.userId=${updatedModel.userId}, transactionId=${updatedModel.transactionId}`);
+    console.log(`[Debug] generateTransactionEventsForGroupTransactionModel: existingGroupTransactions.length=${existingGroupTransactions.length}`);
+    console.log(`[Debug] generateTransactionEventsForGroupTransactionModel: whoYouOwe=${JSON.stringify(updatedModel.whoYouOwe)}, whoOweYou=${JSON.stringify(updatedModel.whoOweYou)}`);
+    const events = [];
+    const now = new Date();
+    const processedRecipientIds = new Set();
+    const existingByRecipient = new Map();
+    for (const tx of existingGroupTransactions) {
+        existingByRecipient.set(tx.recipientUserId, tx);
+    }
+    for (const debt of updatedModel.whoYouOwe) {
+        processedRecipientIds.add(debt.memberId);
+        const existing = existingByRecipient.get(debt.memberId);
+        if (existing) {
+            events.push(new __1.TransactionUpdated({
+                eventId: (0, uuid_1.v4)(),
+                userId: updatedModel.userId,
+                description: updatedModel.description ?? "",
+                currency: updatedModel.currency,
+                splitType: __1.SplitTypeEnum.SpecificAmounts,
+                totalAmount: updatedModel.totalAmount,
+                amount: debt.amount,
+                isOwed: true,
+                transactionDate: updatedModel.transactionDate,
+                createdAt: now,
+                createdBy: updatedModel.updatedBy,
+                streamId: existing.streamId,
+                version: existing.version + 1,
+                systemGenerated: true,
+            }));
+        }
+        else {
+            events.push(new __1.TransactionCreated({
+                eventId: (0, uuid_1.v4)(),
+                userId: updatedModel.userId,
+                recipientUserId: debt.memberId,
+                logicalTransactionId: updatedModel.transactionId,
+                description: updatedModel.description ?? "",
+                currency: updatedModel.currency,
+                splitType: __1.SplitTypeEnum.SpecificAmounts,
+                totalAmount: updatedModel.totalAmount,
+                amount: debt.amount,
+                isOwed: true,
+                transactionDate: updatedModel.transactionDate,
+                groupId: updatedModel.groupId,
+                groupTransactionId: updatedModel.transactionId,
+                createdAt: now,
+                createdBy: updatedModel.updatedBy,
+                streamId: (0, uuid_1.v4)(),
+                version: 1,
+                systemGenerated: true,
+            }));
+        }
+    }
+    for (const credit of updatedModel.whoOweYou) {
+        processedRecipientIds.add(credit.memberId);
+        const existing = existingByRecipient.get(credit.memberId);
+        if (existing) {
+            events.push(new __1.TransactionUpdated({
+                eventId: (0, uuid_1.v4)(),
+                userId: updatedModel.userId,
+                description: updatedModel.description ?? "",
+                currency: updatedModel.currency,
+                splitType: __1.SplitTypeEnum.SpecificAmounts,
+                totalAmount: updatedModel.totalAmount,
+                amount: credit.amount,
+                isOwed: false,
+                transactionDate: updatedModel.transactionDate,
+                createdAt: now,
+                createdBy: updatedModel.updatedBy,
+                streamId: existing.streamId,
+                version: existing.version + 1,
+                systemGenerated: true,
+            }));
+        }
+        else {
+            events.push(new __1.TransactionCreated({
+                eventId: (0, uuid_1.v4)(),
+                userId: updatedModel.userId,
+                recipientUserId: credit.memberId,
+                logicalTransactionId: updatedModel.transactionId,
+                description: updatedModel.description ?? "",
+                currency: updatedModel.currency,
+                splitType: __1.SplitTypeEnum.SpecificAmounts,
+                totalAmount: updatedModel.totalAmount,
+                amount: credit.amount,
+                isOwed: false,
+                transactionDate: updatedModel.transactionDate,
+                groupId: updatedModel.groupId,
+                groupTransactionId: updatedModel.transactionId,
+                createdAt: now,
+                createdBy: updatedModel.updatedBy,
+                streamId: (0, uuid_1.v4)(),
+                version: 1,
+                systemGenerated: true,
+            }));
+        }
+    }
+    for (const existing of existingGroupTransactions) {
+        if (!processedRecipientIds.has(existing.recipientUserId)) {
+            events.push(new __1.TransactionDeleted({
+                eventId: (0, uuid_1.v4)(),
+                userId: updatedModel.userId,
+                streamId: existing.streamId,
+                version: existing.version + 1,
+                createdAt: now,
+                createdBy: updatedModel.updatedBy,
+                systemGenerated: true,
+            }));
+        }
+    }
+    console.log(`[Debug] generateTransactionEventsForGroupTransactionModel: returning ${events.length} transaction events`);
+    return events;
+}
+function buildYouPaidSplitEquallyEvent(userId, groupId, request, existingModel) {
+    const transactionDate = new Date(request.transactionDate);
+    const allMemberIds = [userId, ...request.memberIds];
+    const memberCount = allMemberIds.length;
+    const amountPerMember = request.totalAmount / memberCount;
+    const members = allMemberIds.map((memberId) => ({
+        memberId,
+        paid: memberId === userId ? request.totalAmount : 0,
+        owed: amountPerMember,
+    }));
+    const originalTransaction = { members };
+    const { whoYouOwe, whoOweYou } = calculateDebtsForMember(originalTransaction, userId);
+    const commonFields = {
+        eventId: (0, uuid_1.v4)(),
+        userId,
+        description: request.description.trim(),
+        totalAmount: request.totalAmount,
+        currency: request.currency,
+        splitType: __1.SplitTypeEnum.YouPaidSplitEqually,
+        transactionDate,
+        originalTransaction,
+        whoYouOwe,
+        whoOweYou,
+        createdAt: new Date(),
+        createdBy: userId,
+        systemGenerated: false,
+    };
+    if (existingModel) {
+        return new __1.GroupTransactionUpdated({
+            ...commonFields,
+            streamId: existingModel.streamId,
+            version: existingModel.version + 1,
+        });
+    }
+    return new __1.GroupTransactionCreated({
+        ...commonFields,
+        groupId,
+        transactionId: request.transactionId ?? (0, uuid_1.v4)(),
+        streamId: (0, uuid_1.v4)(),
+        version: 1,
+    });
+}
+function buildTheyPaidSplitEquallyEvent(userId, groupId, request, existingModel) {
+    const transactionDate = new Date(request.transactionDate);
+    const allMemberIds = [
+        request.paidByMemberId,
+        ...request.memberIds.filter((id) => id !== request.paidByMemberId),
+    ];
+    if (!allMemberIds.includes(userId)) {
+        allMemberIds.push(userId);
+    }
+    const memberCount = allMemberIds.length;
+    const amountPerMember = request.totalAmount / memberCount;
+    const members = allMemberIds.map((memberId) => ({
+        memberId,
+        paid: memberId === request.paidByMemberId ? request.totalAmount : 0,
+        owed: amountPerMember,
+    }));
+    const originalTransaction = { members };
+    const { whoYouOwe, whoOweYou } = calculateDebtsForMember(originalTransaction, userId);
+    const commonFields = {
+        eventId: (0, uuid_1.v4)(),
+        userId,
+        description: request.description.trim(),
+        totalAmount: request.totalAmount,
+        currency: request.currency,
+        splitType: __1.SplitTypeEnum.TheyPaidSplitEqually,
+        transactionDate,
+        originalTransaction,
+        whoYouOwe,
+        whoOweYou,
+        createdAt: new Date(),
+        createdBy: userId,
+        systemGenerated: false,
+    };
+    if (existingModel) {
+        return new __1.GroupTransactionUpdated({
+            ...commonFields,
+            streamId: existingModel.streamId,
+            version: existingModel.version + 1,
+        });
+    }
+    return new __1.GroupTransactionCreated({
+        ...commonFields,
+        groupId,
+        transactionId: request.transactionId ?? (0, uuid_1.v4)(),
+        streamId: (0, uuid_1.v4)(),
+        version: 1,
+    });
+}
+function buildSpecificAmountsEvent(userId, groupId, request, existingModel) {
+    const transactionDate = new Date(request.transactionDate);
+    const members = request.memberAmounts.map((ma) => ({
+        memberId: ma.memberId,
+        paid: ma.amountPaid,
+        owed: ma.amountSpent,
+    }));
+    const originalTransaction = { members };
+    const { whoYouOwe, whoOweYou } = calculateDebtsForMember(originalTransaction, userId);
+    const commonFields = {
+        eventId: (0, uuid_1.v4)(),
+        userId,
+        description: request.description.trim(),
+        totalAmount: request.totalAmount,
+        currency: request.currency,
+        splitType: __1.SplitTypeEnum.SpecificAmounts,
+        transactionDate,
+        originalTransaction,
+        whoYouOwe,
+        whoOweYou,
+        createdAt: new Date(),
+        createdBy: userId,
+        systemGenerated: false,
+    };
+    if (existingModel) {
+        return new __1.GroupTransactionUpdated({
+            ...commonFields,
+            streamId: existingModel.streamId,
+            version: existingModel.version + 1,
+        });
+    }
+    return new __1.GroupTransactionCreated({
+        ...commonFields,
+        groupId,
+        transactionId: request.transactionId ?? (0, uuid_1.v4)(),
+        streamId: (0, uuid_1.v4)(),
+        version: 1,
+    });
+}
+function convertCurrency(amount, fromCurrency, toCurrency, rates) {
+    if (fromCurrency === toCurrency) {
+        return amount;
+    }
+    const fromRate = rates[fromCurrency] ?? 1;
+    const toRate = rates[toCurrency] ?? 1;
+    return (amount / fromRate) * toRate;
+}
+function toGroupTransactionResponse(model, toCurrency, rates) {
+    const whoOweYouConverted = model.whoOweYou.map((m) => ({
+        memberId: m.memberId,
+        amount: m.amount,
+        amountInDefaultCurrency: convertCurrency(m.amount, model.currency, toCurrency, rates),
+    }));
+    const whoYouOweConverted = model.whoYouOwe.map((m) => ({
+        memberId: m.memberId,
+        amount: m.amount,
+        amountInDefaultCurrency: convertCurrency(m.amount, model.currency, toCurrency, rates),
+    }));
+    const totalOwedToYou = model.whoOweYou.reduce((sum, m) => sum + m.amount, 0);
+    const totalYouOwe = model.whoYouOwe.reduce((sum, m) => sum + m.amount, 0);
+    const netAmount = totalOwedToYou - totalYouOwe;
+    const whoOweWho = {
+        amount: Math.abs(netAmount),
+        isOwed: netAmount > 0,
+        amountInDefaultCurrency: convertCurrency(Math.abs(netAmount), model.currency, toCurrency, rates),
+        defaultCurrency: toCurrency,
+        whoOweYou: whoOweYouConverted,
+        whoYouOwe: whoYouOweConverted,
+    };
+    return {
+        id: model.transactionId,
+        date: model.transactionDate.toISOString(),
+        description: model.description,
+        notes: model.notes,
+        totalAmount: model.totalAmount,
+        currency: model.currency,
+        splitType: model.splitType,
+        whoOweWho,
+        originalTransaction: mapOriginalTransaction(model),
+        deleted: model.deleted,
+        createdAt: model.createdAt.toISOString(),
+        createdBy: model.createdBy,
+    };
+}
+function mapOriginalTransaction(model) {
+    if (model.splitType === __1.SplitTypeEnum.YouPaidSplitEqually) {
+        return {
+            type: "YouPaidSplitEqually",
+            memberIds: model.originalTransaction.members.map((m) => m.memberId),
+            whoPaidWhoResponse: () => [],
+        };
+    }
+    else if (model.splitType === __1.SplitTypeEnum.TheyPaidSplitEqually) {
+        const payer = model.originalTransaction.members.find((m) => m.paid > 0 && m.paid === model.totalAmount);
+        return {
+            type: "TheyPaidSplitEqually",
+            memberWhoPaid: payer?.memberId ?? "",
+            memberIds: model.originalTransaction.members.map((m) => m.memberId),
+            whoPaidWhoResponse: () => [],
+        };
+    }
+    else {
+        return {
+            type: "SpecificAmounts",
+            members: model.originalTransaction.members.map((m) => ({
+                memberId: m.memberId,
+                amountPaid: m.paid,
+                amountSpent: m.owed,
+            })),
+            whoPaidWhoResponse: () => [],
+        };
+    }
+}
+//# sourceMappingURL=GroupUtil.js.map