@zeeshan60/event-processor 1.0.4 → 1.0.5

package/dist/ActivityEventHandler.d.ts

@@ -0,0 +1,12 @@
+import { Event, Model } from '.';
+import { ActivityLogModelStore } from '.';
+import { ActivityLogEventStore } from '.';
+import { UserModelStore } from '.';
+export declare class ActivityEventHandler {
+    private activityLogModelStore;
+    private activityLogEventStore;
+    private userModelStore;
+    constructor(activityLogModelStore: ActivityLogModelStore, activityLogEventStore: ActivityLogEventStore, userModelStore: UserModelStore);
+    createActivityLog(event: Event, existingModel: Model | undefined, updatedModel: Model): Promise<void>;
+}
+//# sourceMappingURL=ActivityEventHandler.d.ts.map

package/dist/ActivityEventHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityEventHandler.d.ts","sourceRoot":"","sources":["../src/ActivityEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAE,KAAK,EAA8C,MAAM,GAAG,CAAC;AAC5E,OAAO,EAAC,qBAAqB,EAAC,MAAM,GAAG,CAAC;AACxC,OAAO,EAAC,qBAAqB,EAAC,MAAM,GAAG,CAAC;AACxC,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AAEjC,qBAAa,oBAAoB;IAEzB,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,cAAc;gBAFd,qBAAqB,EAAE,qBAAqB,EAC5C,qBAAqB,EAAE,qBAAqB,EAC5C,cAAc,EAAE,cAAc;IAGpC,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,GAAG,SAAS,EAAE,YAAY,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;CA2B9G"}

package/dist/ActivityEventHandler.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityEventHandler = void 0;
+const _1 = require(".");
+class ActivityEventHandler {
+    constructor(activityLogModelStore, activityLogEventStore, userModelStore) {
+        this.activityLogModelStore = activityLogModelStore;
+        this.activityLogEventStore = activityLogEventStore;
+        this.userModelStore = userModelStore;
+    }
+    async createActivityLog(event, existingModel, updatedModel) {
+        if (!event.activityLog) {
+            return;
+        }
+        let actorName;
+        if (event.createdBy !== updatedModel.userId) {
+            const actorUser = await this.userModelStore.getByStreamId(event.createdBy);
+            if (actorUser) {
+                actorName = actorUser.displayName;
+            }
+            else {
+                actorName = event.createdBy;
+            }
+        }
+        const activityLogProps = event.activityLog(existingModel, actorName);
+        if (!activityLogProps) {
+            return;
+        }
+        const activityLogEvent = new _1.ActivityLogCreated(activityLogProps);
+        const activityLogModel = activityLogEvent.apply();
+        await this.activityLogEventStore.addEvent(updatedModel.userId, activityLogEvent);
+        await this.activityLogModelStore.save(activityLogModel);
+    }
+}
+exports.ActivityEventHandler = ActivityEventHandler;

package/dist/FriendEventHandler.d.ts

@@ -0,0 +1,21 @@
+import { FriendCreated, FriendDeleted, FriendIdAdded, FriendIdRemoved, FriendModel, FriendUpdated, Event } from '.';
+import { FriendModelStore } from '.';
+import { UserModelStore } from '.';
+import { FriendEventStore } from '.';
+import { UserEventStore } from '.';
+import { ActivityEventHandler } from './ActivityEventHandler';
+export declare class FriendEventHandler {
+    private modelStore;
+    private userModelStore;
+    private friendEventStore;
+    private userEventStore;
+    private activityEventHandler?;
+    constructor(modelStore: FriendModelStore, userModelStore: UserModelStore, friendEventStore: FriendEventStore, userEventStore: UserEventStore, activityEventHandler?: ActivityEventHandler | undefined);
+    handleEvent(event: Event): Promise<FriendModel>;
+    handleFriendCreated(event: FriendCreated): Promise<FriendModel>;
+    handleFriendUpdated(event: FriendUpdated): Promise<FriendModel>;
+    handleFriendDeleted(event: FriendDeleted): Promise<FriendModel>;
+    handleFriendIdAdded(event: FriendIdAdded): Promise<FriendModel>;
+    handleFriendIdRemoved(event: FriendIdRemoved): Promise<FriendModel>;
+}
+//# sourceMappingURL=FriendEventHandler.d.ts.map

package/dist/FriendEventHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FriendEventHandler.d.ts","sourceRoot":"","sources":["../src/FriendEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EACb,aAAa,EACb,aAAa,EACb,eAAe,EACf,WAAW,EACX,aAAa,EAGb,KAAK,EACR,MAAM,GAAG,CAAC;AACX,OAAO,EAAC,gBAAgB,EAAC,MAAM,GAAG,CAAC;AACnC,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AACjC,OAAO,EAAC,gBAAgB,EAAC,MAAM,GAAG,CAAC;AACnC,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AACjC,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAG5D,qBAAa,kBAAkB;IAEvB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,oBAAoB,CAAC;gBAJrB,UAAU,EAAE,gBAAgB,EAC5B,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,gBAAgB,EAClC,cAAc,EAAE,cAAc,EAC9B,oBAAoB,CAAC,EAAE,oBAAoB,YAAA;IAGjD,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC;IA8B/C,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAwG/D,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAU/D,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAU/D,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAU/D,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;CAS5E"}

package/dist/FriendEventHandler.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FriendEventHandler = void 0;
+const _1 = require(".");
+const uuid_1 = require("uuid");
+class FriendEventHandler {
+    constructor(modelStore, userModelStore, friendEventStore, userEventStore, activityEventHandler) {
+        this.modelStore = modelStore;
+        this.userModelStore = userModelStore;
+        this.friendEventStore = friendEventStore;
+        this.userEventStore = userEventStore;
+        this.activityEventHandler = activityEventHandler;
+    }
+    async handleEvent(event) {
+        const validEventTypes = [
+            'FriendCreated',
+            'FriendUpdated',
+            'FriendDeleted',
+            'FriendIdAdded',
+            'FriendIdRemoved'
+        ];
+        const eventType = event.constructor.name;
+        if (!validEventTypes.includes(eventType)) {
+            throw new Error(`Unknown friend event type: ${eventType}`);
+        }
+        switch (eventType) {
+            case 'FriendCreated':
+                return await this.handleFriendCreated(event);
+            case 'FriendUpdated':
+                return await this.handleFriendUpdated(event);
+            case 'FriendDeleted':
+                return await this.handleFriendDeleted(event);
+            case 'FriendIdAdded':
+                return await this.handleFriendIdAdded(event);
+            case 'FriendIdRemoved':
+                return await this.handleFriendIdRemoved(event);
+            default:
+                throw new Error(`Unknown friend event type: ${eventType}`);
+        }
+    }
+    async handleFriendCreated(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        // Check if friend is already a user (try phone first, then email)
+        let friendUser = null;
+        if (event.friendPhoneNumber) {
+            friendUser = await this.userModelStore.findByPhone(event.friendPhoneNumber);
+        }
+        if (!friendUser && event.friendEmail) {
+            friendUser = await this.userModelStore.findByEmail(event.friendEmail);
+        }
+        // If friend is a user, link them and create reciprocal friendship
+        if (friendUser) {
+            // Create FriendIdAdded event for current user
+            const friendIdAddedEvent = new _1.FriendIdAdded({
+                userId: event.userId,
+                friendId: friendUser.userId,
+                createdAt: new Date(),
+                createdBy: event.userId,
+                streamId: event.streamId,
+                version: updatedModel.version + 1,
+            });
+            await this.friendEventStore.addEvent(event.userId, friendIdAddedEvent);
+            const modelWithFriendId = friendIdAddedEvent.apply(updatedModel);
+            await this.modelStore.save(modelWithFriendId);
+            const primaryUser = await this.userModelStore.getByStreamIdWhereDeletedIsFalse(event.userId);
+            if (primaryUser) {
+                const reciprocalFriendCreated = new _1.FriendCreated({
+                    userId: friendUser.userId,
+                    friendEmail: primaryUser.email,
+                    friendPhoneNumber: primaryUser.phoneNumber,
+                    friendDisplayName: primaryUser.displayName,
+                    friendId: event.userId,
+                    groupId: event.groupId,
+                    createdAt: new Date(),
+                    createdBy: friendUser.userId,
+                    streamId: `stream-${(0, uuid_1.v4)()}`,
+                    version: 1,
+                });
+                await this.friendEventStore.addEvent(friendUser.userId, reciprocalFriendCreated);
+                const reciprocalModel = reciprocalFriendCreated.apply(undefined);
+                await this.modelStore.save(reciprocalModel);
+            }
+            return modelWithFriendId;
+        }
+        else {
+            // Friend user not found - create placeholder user
+            const placeholderStreamId = `stream-${(0, uuid_1.v4)()}`;
+            const placeholderUserCreated = new _1.PlaceholderUserCreated({
+                userId: placeholderStreamId,
+                displayName: event.friendDisplayName,
+                phoneNumber: event.friendPhoneNumber,
+                email: event.friendEmail,
+                createdAt: new Date(),
+                createdBy: event.userId,
+                streamId: placeholderStreamId,
+                version: 1,
+            });
+            await this.userEventStore.addEvent(placeholderStreamId, placeholderUserCreated);
+            const placeholderUser = placeholderUserCreated.apply(undefined);
+            await this.userModelStore.save(placeholderUser);
+            // Link primary user to placeholder
+            const friendIdAddedEvent = new _1.FriendIdAdded({
+                userId: event.userId,
+                friendId: placeholderStreamId,
+                createdAt: new Date(),
+                createdBy: event.userId,
+                streamId: event.streamId,
+                version: updatedModel.version + 1,
+            });
+            await this.friendEventStore.addEvent(event.userId, friendIdAddedEvent);
+            const modelWithPlaceholderId = friendIdAddedEvent.apply(updatedModel);
+            await this.modelStore.save(modelWithPlaceholderId);
+            // Create reciprocal friendship for placeholder user
+            const primaryUser = await this.userModelStore.getByStreamIdWhereDeletedIsFalse(event.userId);
+            if (primaryUser) {
+                const primaryUserModel = primaryUser;
+                const reciprocalFriendCreated = new _1.FriendCreated({
+                    userId: placeholderStreamId,
+                    friendEmail: primaryUserModel.email,
+                    friendPhoneNumber: primaryUserModel.phoneNumber,
+                    friendDisplayName: primaryUserModel.displayName,
+                    friendId: event.userId,
+                    groupId: event.groupId,
+                    createdAt: new Date(),
+                    createdBy: placeholderStreamId,
+                    streamId: `stream-${(0, uuid_1.v4)()}`,
+                    version: 1,
+                });
+                await this.friendEventStore.addEvent(placeholderStreamId, reciprocalFriendCreated);
+                const reciprocalModel = reciprocalFriendCreated.apply(undefined);
+                await this.modelStore.save(reciprocalModel);
+            }
+            return modelWithPlaceholderId;
+        }
+    }
+    async handleFriendUpdated(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleFriendDeleted(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleFriendIdAdded(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleFriendIdRemoved(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+}
+exports.FriendEventHandler = FriendEventHandler;

package/dist/GroupEventHandler.d.ts

@@ -0,0 +1,25 @@
+import { GroupCreated, GroupNameChanged, GroupDescriptionChanged, GroupMembersAdded, GroupMembersRemoved, GroupDeleted, GroupModel, Event } from '.';
+import { GroupModelStore } from '.';
+import { FriendModelStore } from '.';
+import { UserModelStore } from '.';
+import { GroupEventStore } from '.';
+import { FriendEventStore } from '.';
+import { ActivityEventHandler } from './ActivityEventHandler';
+export declare class GroupEventHandler {
+    private modelStore;
+    private friendModelStore;
+    private userModelStore;
+    private groupEventStore;
+    private friendEventStore;
+    private activityEventHandler?;
+    constructor(modelStore: GroupModelStore, friendModelStore: FriendModelStore, userModelStore: UserModelStore, groupEventStore: GroupEventStore, friendEventStore: FriendEventStore, activityEventHandler?: ActivityEventHandler | undefined);
+    handleEvent(event: Event): Promise<GroupModel>;
+    private ensureBidirectionalFriendship;
+    handleGroupCreated(event: GroupCreated): Promise<GroupModel>;
+    handleGroupNameChanged(event: GroupNameChanged): Promise<GroupModel>;
+    handleGroupDescriptionChanged(event: GroupDescriptionChanged): Promise<GroupModel>;
+    handleGroupMembersAdded(event: GroupMembersAdded): Promise<GroupModel>;
+    handleGroupMembersRemoved(event: GroupMembersRemoved): Promise<GroupModel>;
+    handleGroupDeleted(event: GroupDeleted): Promise<GroupModel>;
+}
+//# sourceMappingURL=GroupEventHandler.d.ts.map

package/dist/GroupEventHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupEventHandler.d.ts","sourceRoot":"","sources":["../src/GroupEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,UAAU,EAEV,KAAK,EACR,MAAM,GAAG,CAAC;AACX,OAAO,EAAC,eAAe,EAAC,MAAM,GAAG,CAAC;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,GAAG,CAAC;AACnC,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AACjC,OAAO,EAAC,eAAe,EAAC,MAAM,GAAG,CAAC;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,GAAG,CAAC;AACnC,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAG5D,qBAAa,iBAAiB;IAEtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,oBAAoB,CAAC;gBALrB,UAAU,EAAE,eAAe,EAC3B,gBAAgB,EAAE,gBAAgB,EAClC,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,eAAe,EAChC,gBAAgB,EAAE,gBAAgB,EAClC,oBAAoB,CAAC,EAAE,oBAAoB,YAAA;IAGjD,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC;YAiCtC,6BAA6B;IA8DrC,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IA8C5D,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IA8BpE,6BAA6B,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC;IA8BlF,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAoEtE,yBAAyB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IA8B1E,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;CAWrE"}

package/dist/GroupEventHandler.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupEventHandler = void 0;
+const _1 = require(".");
+const uuid_1 = require("uuid");
+class GroupEventHandler {
+    constructor(modelStore, friendModelStore, userModelStore, groupEventStore, friendEventStore, activityEventHandler) {
+        this.modelStore = modelStore;
+        this.friendModelStore = friendModelStore;
+        this.userModelStore = userModelStore;
+        this.groupEventStore = groupEventStore;
+        this.friendEventStore = friendEventStore;
+        this.activityEventHandler = activityEventHandler;
+    }
+    async handleEvent(event) {
+        const validEventTypes = [
+            'GroupCreated',
+            'GroupNameChanged',
+            'GroupDescriptionChanged',
+            'GroupMembersAdded',
+            'GroupMembersRemoved',
+            'GroupDeleted'
+        ];
+        const eventType = event.constructor.name;
+        if (!validEventTypes.includes(eventType)) {
+            throw new Error(`Unknown group event type: ${eventType}`);
+        }
+        switch (eventType) {
+            case 'GroupCreated':
+                return await this.handleGroupCreated(event);
+            case 'GroupNameChanged':
+                return await this.handleGroupNameChanged(event);
+            case 'GroupDescriptionChanged':
+                return await this.handleGroupDescriptionChanged(event);
+            case 'GroupMembersAdded':
+                return await this.handleGroupMembersAdded(event);
+            case 'GroupMembersRemoved':
+                return await this.handleGroupMembersRemoved(event);
+            case 'GroupDeleted':
+                return await this.handleGroupDeleted(event);
+            default:
+                throw new Error(`Unknown group event type: ${eventType}`);
+        }
+    }
+    async ensureBidirectionalFriendship(userId1, userId2, groupId) {
+        const user1 = await this.userModelStore.getByStreamIdWhereDeletedIsFalse(userId1);
+        const user2 = await this.userModelStore.getByStreamIdWhereDeletedIsFalse(userId2);
+        if (!user1 || !user2) {
+            console.log(`Cannot create friendship: user ${userId1} or ${userId2} not found`);
+            return;
+        }
+        const existingFriend1to2 = await this.friendModelStore.findByUserIdAndFriendIdAndDeletedIsFalse(userId1, userId2);
+        if (!existingFriend1to2) {
+            const friendStreamId = `stream-${(0, uuid_1.v4)()}`;
+            const friendCreatedEvent = new _1.FriendCreated({
+                userId: userId1,
+                friendEmail: user2.email,
+                friendPhoneNumber: user2.phoneNumber,
+                friendDisplayName: user2.displayName,
+                friendId: userId2,
+                groupId: groupId,
+                createdAt: new Date(),
+                createdBy: userId1,
+                streamId: friendStreamId,
+                version: 1,
+            });
+            await this.friendEventStore.addEvent(userId1, friendCreatedEvent);
+            const friendModel = friendCreatedEvent.apply(undefined);
+            await this.friendModelStore.save(friendModel);
+        }
+        const existingFriend2to1 = await this.friendModelStore.findByUserIdAndFriendIdAndDeletedIsFalse(userId2, userId1);
+        if (!existingFriend2to1) {
+            const friendStreamId = `stream-${(0, uuid_1.v4)()}`;
+            const friendCreatedEvent = new _1.FriendCreated({
+                userId: userId2,
+                friendEmail: user1.email,
+                friendPhoneNumber: user1.phoneNumber,
+                friendDisplayName: user1.displayName,
+                friendId: userId1,
+                groupId: groupId,
+                createdAt: new Date(),
+                createdBy: userId2,
+                streamId: friendStreamId,
+                version: 1,
+            });
+            await this.friendEventStore.addEvent(userId2, friendCreatedEvent);
+            const friendModel = friendCreatedEvent.apply(undefined);
+            await this.friendModelStore.save(friendModel);
+        }
+    }
+    async handleGroupCreated(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        const allMemberIds = event.members ?? [];
+        const otherMembers = allMemberIds.filter(id => id !== event.userId);
+        for (const memberId of otherMembers) {
+            const memberUser = await this.userModelStore.getByStreamIdWhereDeletedIsFalse(memberId);
+            if (!memberUser) {
+                console.log(`Member ${memberId} not found, skipping`);
+                continue;
+            }
+            for (const otherMemberId of allMemberIds) {
+                if (memberId !== otherMemberId) {
+                    await this.ensureBidirectionalFriendship(memberId, otherMemberId, event.groupId);
+                }
+            }
+            const perspectiveGroupStreamId = `stream-${(0, uuid_1.v4)()}`;
+            const perspectiveGroupCreated = new _1.GroupCreated({
+                userId: memberId,
+                groupId: event.groupId,
+                name: event.name,
+                description: event.description,
+                members: event.members,
+                createdAt: new Date(),
+                createdBy: memberId,
+                streamId: perspectiveGroupStreamId,
+                version: 1,
+            });
+            await this.groupEventStore.addEvent(memberId, perspectiveGroupCreated);
+            const perspectiveModel = perspectiveGroupCreated.apply(undefined);
+            await this.modelStore.save(perspectiveModel);
+        }
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleGroupNameChanged(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        const allPerspectives = await this.modelStore.findAllByGroupIdAndDeletedIsFalse(updatedModel.groupId);
+        for (const perspective of allPerspectives) {
+            if (perspective.streamId !== event.streamId) {
+                const perspectiveEvent = new _1.GroupNameChanged({
+                    userId: perspective.userId,
+                    name: event.name,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: perspective.streamId,
+                    version: perspective.version + 1,
+                });
+                await this.groupEventStore.addEvent(perspective.userId, perspectiveEvent);
+                const updatedPerspective = perspectiveEvent.apply(perspective);
+                await this.modelStore.save(updatedPerspective);
+            }
+        }
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleGroupDescriptionChanged(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        const allPerspectives = await this.modelStore.findAllByGroupIdAndDeletedIsFalse(updatedModel.groupId);
+        for (const perspective of allPerspectives) {
+            if (perspective.streamId !== event.streamId) {
+                const perspectiveEvent = new _1.GroupDescriptionChanged({
+                    userId: perspective.userId,
+                    description: event.description,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: perspective.streamId,
+                    version: perspective.version + 1,
+                });
+                await this.groupEventStore.addEvent(perspective.userId, perspectiveEvent);
+                const updatedPerspective = perspectiveEvent.apply(perspective);
+                await this.modelStore.save(updatedPerspective);
+            }
+        }
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleGroupMembersAdded(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        if (!existingModel) {
+            throw new Error(`Group model not found for streamId ${event.streamId}`);
+        }
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        const allMemberIds = updatedModel.members ?? [];
+        for (const memberId of event.members) {
+            const memberUser = await this.userModelStore.getByStreamIdWhereDeletedIsFalse(memberId);
+            if (!memberUser) {
+                console.log(`Member ${memberId} not found, skipping`);
+                continue;
+            }
+            for (const otherMemberId of allMemberIds) {
+                if (memberId !== otherMemberId) {
+                    await this.ensureBidirectionalFriendship(memberId, otherMemberId, existingModel.groupId);
+                }
+            }
+            const perspectiveGroupStreamId = `stream-${(0, uuid_1.v4)()}`;
+            const perspectiveGroupCreated = new _1.GroupCreated({
+                userId: memberId,
+                groupId: existingModel.groupId,
+                name: existingModel.name,
+                description: existingModel.description,
+                members: updatedModel.members,
+                createdAt: new Date(),
+                createdBy: memberId,
+                streamId: perspectiveGroupStreamId,
+                version: 1,
+            });
+            await this.groupEventStore.addEvent(memberId, perspectiveGroupCreated);
+            const perspectiveModel = perspectiveGroupCreated.apply(undefined);
+            await this.modelStore.save(perspectiveModel);
+        }
+        const allPerspectives = await this.modelStore.findAllByGroupIdAndDeletedIsFalse(updatedModel.groupId);
+        for (const perspective of allPerspectives) {
+            if (perspective.streamId !== event.streamId && !event.members.includes(perspective.userId)) {
+                const perspectiveEvent = new _1.GroupMembersAdded({
+                    userId: perspective.userId,
+                    members: event.members,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: perspective.streamId,
+                    version: perspective.version + 1,
+                });
+                await this.groupEventStore.addEvent(perspective.userId, perspectiveEvent);
+                const updatedPerspective = perspectiveEvent.apply(perspective);
+                await this.modelStore.save(updatedPerspective);
+            }
+        }
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleGroupMembersRemoved(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        const allPerspectives = await this.modelStore.findAllByGroupIdAndDeletedIsFalse(updatedModel.groupId);
+        for (const perspective of allPerspectives) {
+            if (perspective.streamId !== event.streamId) {
+                const perspectiveEvent = new _1.GroupMembersRemoved({
+                    userId: perspective.userId,
+                    members: event.members,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: perspective.streamId,
+                    version: perspective.version + 1,
+                });
+                await this.groupEventStore.addEvent(perspective.userId, perspectiveEvent);
+                const updatedPerspective = perspectiveEvent.apply(perspective);
+                await this.modelStore.save(updatedPerspective);
+            }
+        }
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+    async handleGroupDeleted(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        return updatedModel;
+    }
+}
+exports.GroupEventHandler = GroupEventHandler;

package/dist/GroupTransactionEventHandler.d.ts

@@ -0,0 +1,25 @@
+import { GroupTransactionCreated, GroupTransactionSplitDetailsChanged, GroupTransactionModel, Event } from '.';
+import { GroupTransactionModelStore } from '.';
+import { GroupTransactionEventStore } from '.';
+import { GroupModelStore } from '.';
+import { TransactionEventStore } from '.';
+import { TransactionModelStore } from '.';
+import { ActivityEventHandler } from './ActivityEventHandler';
+export declare class GroupTransactionEventHandler {
+    private modelStore;
+    private eventStore;
+    private groupModelStore;
+    private transactionEventStore;
+    private transactionModelStore;
+    private activityEventHandler?;
+    constructor(modelStore: GroupTransactionModelStore, eventStore: GroupTransactionEventStore, groupModelStore: GroupModelStore, transactionEventStore: TransactionEventStore, transactionModelStore: TransactionModelStore, activityEventHandler?: ActivityEventHandler | undefined);
+    handleEvent(event: Event): Promise<GroupTransactionModel>;
+    private calculateNetBalances;
+    private createFriendTransactions;
+    private updateFriendTransactions;
+    private calculateRequiredTransactions;
+    private updateExistingFriendTransactions;
+    handleGroupTransactionCreated(event: GroupTransactionCreated): Promise<GroupTransactionModel>;
+    handleGroupTransactionSplitDetailsChanged(event: GroupTransactionSplitDetailsChanged): Promise<GroupTransactionModel>;
+}
+//# sourceMappingURL=GroupTransactionEventHandler.d.ts.map

package/dist/GroupTransactionEventHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupTransactionEventHandler.d.ts","sourceRoot":"","sources":["../src/GroupTransactionEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,mCAAmC,EACnC,qBAAqB,EAIrB,KAAK,EAGR,MAAM,GAAG,CAAC;AACX,OAAO,EAAC,0BAA0B,EAAC,MAAM,GAAG,CAAC;AAC7C,OAAO,EAAC,0BAA0B,EAAC,MAAM,GAAG,CAAC;AAC7C,OAAO,EAAC,eAAe,EAAC,MAAM,GAAG,CAAC;AAClC,OAAO,EAAC,qBAAqB,EAAC,MAAM,GAAG,CAAC;AACxC,OAAO,EAAC,qBAAqB,EAAC,MAAM,GAAG,CAAC;AACxC,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAI5D,qBAAa,4BAA4B;IAEjC,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,oBAAoB,CAAC;gBALrB,UAAU,EAAE,0BAA0B,EACtC,UAAU,EAAE,0BAA0B,EACtC,eAAe,EAAE,eAAe,EAChC,qBAAqB,EAAE,qBAAqB,EAC5C,qBAAqB,EAAE,qBAAqB,EAC5C,oBAAoB,CAAC,EAAE,oBAAoB,YAAA;IAGjD,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAqB/D,OAAO,CAAC,oBAAoB;YAWd,wBAAwB;YA0ExB,wBAAwB;IAStC,OAAO,CAAC,6BAA6B;YA6CvB,gCAAgC;IAiFxC,6BAA6B,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA8C7F,yCAAyC,CAAC,KAAK,EAAE,mCAAmC,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAoD9H"}