@zeeshan60/event-processor 1.0.4 → 1.0.5

package/dist/GroupTransactionEventHandler.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupTransactionEventHandler = void 0;
+const _1 = require(".");
+const splitTypeUtils_1 = require("./utils/splitTypeUtils");
+const uuid_1 = require("uuid");
+class GroupTransactionEventHandler {
+    constructor(modelStore, eventStore, groupModelStore, transactionEventStore, transactionModelStore, activityEventHandler) {
+        this.modelStore = modelStore;
+        this.eventStore = eventStore;
+        this.groupModelStore = groupModelStore;
+        this.transactionEventStore = transactionEventStore;
+        this.transactionModelStore = transactionModelStore;
+        this.activityEventHandler = activityEventHandler;
+    }
+    async handleEvent(event) {
+        const validEventTypes = [
+            'GroupTransactionCreated',
+            'GroupTransactionSplitDetailsChanged',
+        ];
+        const eventType = event.constructor.name;
+        if (!validEventTypes.includes(eventType)) {
+            throw new Error(`Unknown group transaction event type: ${eventType}`);
+        }
+        switch (eventType) {
+            case 'GroupTransactionCreated':
+                return await this.handleGroupTransactionCreated(event);
+            case 'GroupTransactionSplitDetailsChanged':
+                return await this.handleGroupTransactionSplitDetailsChanged(event);
+            default:
+                throw new Error(`Unknown group transaction event type: ${eventType}`);
+        }
+    }
+    calculateNetBalances(members) {
+        const netBalances = new Map();
+        for (const member of members) {
+            const net = member.paid - member.owed;
+            netBalances.set(member.memberId, net);
+        }
+        return netBalances;
+    }
+    async createFriendTransactions(groupTransactionEvent) {
+        const netBalances = this.calculateNetBalances(groupTransactionEvent.originalTransaction.members);
+        const creditors = [];
+        const debtors = [];
+        for (const [memberId, net] of netBalances.entries()) {
+            if (net > 0) {
+                creditors.push({ memberId, amount: net });
+            }
+            else if (net < 0) {
+                debtors.push({ memberId, amount: Math.abs(net) });
+            }
+        }
+        for (const creditor of creditors) {
+            for (const debtor of debtors) {
+                if (creditor.amount > 0 && debtor.amount > 0) {
+                    const transactionAmount = Math.min(creditor.amount, debtor.amount);
+                    const creditorStreamId = `stream-${(0, uuid_1.v4)()}`;
+                    const creditorTransactionEvent = new _1.TransactionCreated({
+                        userId: creditor.memberId,
+                        recipientUserId: debtor.memberId,
+                        logicalTransactionId: groupTransactionEvent.transactionId,
+                        description: groupTransactionEvent.description ?? '',
+                        currency: groupTransactionEvent.currency,
+                        splitType: _1.SplitType.SpecificAmounts,
+                        totalAmount: transactionAmount,
+                        amount: transactionAmount,
+                        isOwed: false,
+                        transactionDate: groupTransactionEvent.transactionDate,
+                        groupId: groupTransactionEvent.groupId,
+                        groupTransactionId: groupTransactionEvent.transactionId,
+                        createdAt: new Date(),
+                        createdBy: groupTransactionEvent.createdBy,
+                        streamId: creditorStreamId,
+                        version: 1,
+                    });
+                    await this.transactionEventStore.addEvent(creditor.memberId, creditorTransactionEvent);
+                    const creditorModel = creditorTransactionEvent.apply(undefined);
+                    await this.transactionModelStore.save(creditorModel);
+                    const debtorStreamId = `stream-${(0, uuid_1.v4)()}`;
+                    const debtorTransactionEvent = new _1.TransactionCreated({
+                        userId: debtor.memberId,
+                        recipientUserId: creditor.memberId,
+                        logicalTransactionId: groupTransactionEvent.transactionId,
+                        description: groupTransactionEvent.description ?? '',
+                        currency: groupTransactionEvent.currency,
+                        splitType: _1.SplitType.SpecificAmounts,
+                        totalAmount: transactionAmount,
+                        amount: transactionAmount,
+                        isOwed: true,
+                        transactionDate: groupTransactionEvent.transactionDate,
+                        groupId: groupTransactionEvent.groupId,
+                        groupTransactionId: groupTransactionEvent.transactionId,
+                        createdAt: new Date(),
+                        createdBy: groupTransactionEvent.createdBy,
+                        streamId: debtorStreamId,
+                        version: 1,
+                    });
+                    await this.transactionEventStore.addEvent(debtor.memberId, debtorTransactionEvent);
+                    const debtorModel = debtorTransactionEvent.apply(undefined);
+                    await this.transactionModelStore.save(debtorModel);
+                    creditor.amount -= transactionAmount;
+                    debtor.amount -= transactionAmount;
+                }
+            }
+        }
+    }
+    async updateFriendTransactions(event, existingModel, _oldMembers, newMembers) {
+        await this.updateExistingFriendTransactions(event, existingModel, newMembers);
+    }
+    calculateRequiredTransactions(newMembers) {
+        const newNetBalances = this.calculateNetBalances(newMembers);
+        const requiredTransactions = new Map();
+        const creditors = [];
+        const debtors = [];
+        for (const [memberId, net] of newNetBalances.entries()) {
+            if (net > 0) {
+                creditors.push({ memberId, amount: net });
+            }
+            else if (net < 0) {
+                debtors.push({ memberId, amount: Math.abs(net) });
+            }
+        }
+        for (const creditor of creditors) {
+            for (const debtor of debtors) {
+                if (creditor.amount > 0 && debtor.amount > 0) {
+                    const transactionAmount = Math.min(creditor.amount, debtor.amount);
+                    const creditorKey = `${creditor.memberId}-${debtor.memberId}`;
+                    requiredTransactions.set(creditorKey, {
+                        recipientUserId: debtor.memberId,
+                        amount: transactionAmount,
+                        isOwed: false
+                    });
+                    const debtorKey = `${debtor.memberId}-${creditor.memberId}`;
+                    requiredTransactions.set(debtorKey, {
+                        recipientUserId: creditor.memberId,
+                        amount: transactionAmount,
+                        isOwed: true
+                    });
+                    creditor.amount -= transactionAmount;
+                    debtor.amount -= transactionAmount;
+                }
+            }
+        }
+        return requiredTransactions;
+    }
+    async updateExistingFriendTransactions(event, existingModel, newMembers) {
+        const requiredTransactions = this.calculateRequiredTransactions(newMembers);
+        const oldMemberIds = new Set(existingModel.originalTransaction.members.map(m => m.memberId));
+        const newMemberIds = new Set(newMembers.map(m => m.memberId));
+        const allMemberIds = new Set([...oldMemberIds, ...newMemberIds]);
+        for (const memberId of allMemberIds) {
+            const existingTransactions = await this.transactionModelStore.findByGroupTransactionId(memberId, existingModel.transactionId);
+            for (const existingTx of existingTransactions) {
+                const key = `${existingTx.userId}-${existingTx.recipientUserId}`;
+                const requiredTx = requiredTransactions.get(key);
+                if (requiredTx) {
+                    if (existingTx.amount !== requiredTx.amount ||
+                        existingTx.totalAmount !== requiredTx.amount ||
+                        existingTx.isOwed !== requiredTx.isOwed) {
+                        const updateEvent = new _1.TransactionDetailsChanged({
+                            totalAmount: requiredTx.amount,
+                            amount: requiredTx.amount,
+                            isOwed: requiredTx.isOwed,
+                            streamId: existingTx.streamId,
+                            version: existingTx.version + 1,
+                            createdAt: new Date(),
+                            createdBy: event.createdBy,
+                        });
+                        await this.transactionEventStore.addEvent(memberId, updateEvent);
+                        const updatedModel = updateEvent.apply(existingTx);
+                        await this.transactionModelStore.save(updatedModel);
+                    }
+                    requiredTransactions.delete(key);
+                }
+                else {
+                    const deleteEvent = new _1.TransactionDeleted({
+                        createdAt: new Date(),
+                        createdBy: event.createdBy,
+                        streamId: existingTx.streamId,
+                        version: existingTx.version + 1,
+                    });
+                    await this.transactionEventStore.addEvent(memberId, deleteEvent);
+                    const deletedModel = deleteEvent.apply(existingTx);
+                    await this.transactionModelStore.save(deletedModel);
+                }
+            }
+        }
+        for (const [key, txDetails] of requiredTransactions.entries()) {
+            const [userId, recipientUserId] = key.split('-');
+            const streamId = `stream-${(0, uuid_1.v4)()}`;
+            const createEvent = new _1.TransactionCreated({
+                userId: userId,
+                recipientUserId: recipientUserId,
+                logicalTransactionId: existingModel.transactionId,
+                description: existingModel.description ?? '',
+                currency: existingModel.currency,
+                splitType: _1.SplitType.SpecificAmounts,
+                totalAmount: txDetails.amount,
+                amount: txDetails.amount,
+                isOwed: txDetails.isOwed,
+                transactionDate: existingModel.transactionDate,
+                groupId: existingModel.groupId,
+                groupTransactionId: existingModel.transactionId,
+                createdAt: new Date(),
+                createdBy: event.createdBy,
+                streamId: streamId,
+                version: 1,
+            });
+            await this.transactionEventStore.addEvent(userId, createEvent);
+            const model = createEvent.apply(undefined);
+            await this.transactionModelStore.save(model);
+        }
+    }
+    async handleGroupTransactionCreated(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);
+        }
+        const allGroupPerspectives = await this.groupModelStore.findAllByGroupIdAndDeletedIsFalse(event.groupId);
+        for (const groupPerspective of allGroupPerspectives) {
+            if (groupPerspective.userId !== event.userId) {
+                const perspectiveStreamId = `stream-${(0, uuid_1.v4)()}`;
+                const perspectiveSplitType = (0, splitTypeUtils_1.reverseSplitType)(event.splitType);
+                const perspectiveEvent = new _1.GroupTransactionCreated({
+                    userId: groupPerspective.userId,
+                    groupId: event.groupId,
+                    transactionId: event.transactionId,
+                    description: event.description,
+                    notes: event.notes,
+                    totalAmount: event.totalAmount,
+                    currency: event.currency,
+                    splitType: perspectiveSplitType,
+                    transactionDate: event.transactionDate,
+                    originalTransaction: event.originalTransaction,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: perspectiveStreamId,
+                    version: 1,
+                });
+                await this.eventStore.addEvent(groupPerspective.userId, perspectiveEvent);
+                const perspectiveModel = perspectiveEvent.apply(undefined);
+                await this.modelStore.save(perspectiveModel);
+                if (this.activityEventHandler) {
+                    await this.activityEventHandler.createActivityLog(perspectiveEvent, undefined, perspectiveModel);
+                }
+            }
+        }
+        await this.createFriendTransactions(event);
+        return updatedModel;
+    }
+    async handleGroupTransactionSplitDetailsChanged(event) {
+        const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
+        if (!existingModel) {
+            throw new Error('GroupTransaction must exist to change split details');
+        }
+        const oldMembers = existingModel.originalTransaction.members;
+        const newMembers = event.originalTransaction.members;
+        const updatedModel = event.apply(existingModel);
+        await this.modelStore.save(updatedModel);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, updatedModel);
+        }
+        const allGroupPerspectives = await this.groupModelStore.findAllByGroupIdAndDeletedIsFalse(updatedModel.groupId);
+        for (const groupPerspective of allGroupPerspectives) {
+            if (groupPerspective.userId !== event.userId) {
+                const perspectiveStreamId = updatedModel.streamId;
+                const perspectiveSplitType = (0, splitTypeUtils_1.reverseSplitType)(event.splitType);
+                const perspectiveEvent = new _1.GroupTransactionSplitDetailsChanged({
+                    userId: groupPerspective.userId,
+                    totalAmount: event.totalAmount,
+                    splitType: perspectiveSplitType,
+                    originalTransaction: event.originalTransaction,
+                    createdAt: new Date(),
+                    createdBy: event.createdBy,
+                    streamId: perspectiveStreamId,
+                    version: updatedModel.version,
+                });
+                await this.eventStore.addEvent(groupPerspective.userId, perspectiveEvent);
+                const existingPerspectiveModel = await this.modelStore.findByUserIdAndTransactionId(groupPerspective.userId, updatedModel.transactionId);
+                if (existingPerspectiveModel) {
+                    const perspectiveModel = perspectiveEvent.apply(existingPerspectiveModel);
+                    await this.modelStore.save(perspectiveModel);
+                    if (this.activityEventHandler) {
+                        await this.activityEventHandler.createActivityLog(perspectiveEvent, existingPerspectiveModel, perspectiveModel);
+                    }
+                }
+            }
+        }
+        await this.updateFriendTransactions(event, existingModel, oldMembers, newMembers);
+        return updatedModel;
+    }
+}
+exports.GroupTransactionEventHandler = GroupTransactionEventHandler;

package/dist/TransactionEventHandler.d.ts

@@ -1,11 +1,15 @@
-import { Event } from './common/Event';
-import { EventStore } from './common/EventStore';
-import { ModelStore } from './common/ModelStore';
-import { TransactionModel } from './TransactionEvents';
+import { TransactionModel, Event } from '.';
+import { TransactionModelStore } from '.';
+import { TransactionEventStore } from '.';
+import { UserModelStore } from '.';
+import { ActivityEventHandler } from './ActivityEventHandler';
 export declare class TransactionEventHandler {
-    private eventStore;
     private modelStore;
-    constructor(eventStore: EventStore, modelStore: ModelStore);
-    handle(event: Event): Promise<TransactionModel>;
+    private eventStore;
+    private txUserModelStore;
+    private activityEventHandler?;
+    constructor(modelStore: TransactionModelStore, eventStore: TransactionEventStore, txUserModelStore: UserModelStore, activityEventHandler?: ActivityEventHandler | undefined);
+    handleEvent(event: Event): Promise<TransactionModel>;
+    private createMirrorEvent;
 }
 //# sourceMappingURL=TransactionEventHandler.d.ts.map

package/dist/TransactionEventHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransactionEventHandler.d.ts","sourceRoot":"","sources":["../src/TransactionEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,UAAU;gBADV,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU;IAI5B,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAiBxD"}
+{"version":3,"file":"TransactionEventHandler.d.ts","sourceRoot":"","sources":["../src/TransactionEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAQH,gBAAgB,EAChB,KAAK,EACR,MAAM,GAAG,CAAC;AACX,OAAO,EAAC,qBAAqB,EAAC,MAAM,GAAG,CAAC;AACxC,OAAO,EAAC,qBAAqB,EAAC,MAAM,GAAG,CAAC;AACxC,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AACjC,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAK5D,qBAAa,uBAAuB;IAE5B,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,oBAAoB,CAAC;gBAHrB,UAAU,EAAE,qBAAqB,EACjC,UAAU,EAAE,qBAAqB,EACjC,gBAAgB,EAAE,cAAc,EAChC,oBAAoB,CAAC,EAAE,oBAAoB,YAAA;IAGjD,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,gBAAgB,CAAC;YA2B5C,iBAAiB;CA4IlC"}

package/dist/TransactionEventHandler.js

@@ -1,21 +1,150 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionEventHandler = void 0;
+const _1 = require(".");
+const splitTypeUtils_1 = require("./utils/splitTypeUtils");
+const userPathUtils_1 = require("./utils/userPathUtils");
+const uuid_1 = require("uuid");
 class TransactionEventHandler {
-    constructor(eventStore, modelStore) {
-        this.eventStore = eventStore;
+    constructor(modelStore, eventStore, txUserModelStore, activityEventHandler) {
         this.modelStore = modelStore;
+        this.eventStore = eventStore;
+        this.txUserModelStore = txUserModelStore;
+        this.activityEventHandler = activityEventHandler;
     }
-    async handle(event) {
-        // Store the event
-        await this.eventStore.addEvent(event);
-        // Get existing model if it exists
+    async handleEvent(event) {
+        const validEventTypes = [
+            'TransactionCreated',
+            'TransactionDeleted',
+            'DescriptionChanged',
+            'TotalAmountChanged',
+            'SplitTypeChanged',
+            'CurrencyChanged',
+            'TransactionDateChanged'
+        ];
+        const eventType = event.constructor.name;
+        if (!validEventTypes.includes(eventType)) {
+            throw new Error(`Unknown transaction event type: ${eventType}`);
+        }
         const existingModel = await this.modelStore.getByStreamIdWhereDeletedIsFalse(event.streamId);
-        // Apply the event to create/update the model
-        const updatedModel = event.apply(existingModel);
-        // Store the updated model
+        const model = event.apply(existingModel);
+        await this.modelStore.save(model);
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(event, existingModel, model);
+        }
+        await this.createMirrorEvent(event, model);
+        return model;
+    }
+    async createMirrorEvent(originalEvent, transactionModel) {
+        const eventType = originalEvent.constructor.name;
+        const recipientUserModel = await this.txUserModelStore.getByStreamId(transactionModel.recipientUserId);
+        const recipientPath = (0, userPathUtils_1.getUserEventPath)(recipientUserModel, transactionModel.recipientUserId);
+        const existingMirrorModel = await this.modelStore.findByUserAndLogicalTransactionId(transactionModel.recipientUserId, transactionModel.userId, transactionModel.logicalTransactionId);
+        const mirrorStreamId = existingMirrorModel ? existingMirrorModel.streamId : (0, uuid_1.v4)();
+        const mirrorVersion = existingMirrorModel ? existingMirrorModel.version + 1 : 1;
+        let mirrorEvent;
+        switch (eventType) {
+            case 'TransactionCreated': {
+                const txEvent = originalEvent;
+                const { amount, isOwed } = (0, splitTypeUtils_1.calculateMirrorAmountAndIsOwed)(txEvent.totalAmount, txEvent.amount, txEvent.splitType, txEvent.isOwed);
+                mirrorEvent = new _1.TransactionCreated({
+                    userId: transactionModel.recipientUserId,
+                    recipientUserId: transactionModel.userId,
+                    logicalTransactionId: txEvent.logicalTransactionId,
+                    description: txEvent.description,
+                    currency: txEvent.currency,
+                    splitType: (0, splitTypeUtils_1.reverseSplitType)(txEvent.splitType),
+                    totalAmount: txEvent.totalAmount,
+                    amount,
+                    isOwed,
+                    transactionDate: txEvent.transactionDate,
+                    groupId: txEvent.groupId,
+                    groupTransactionId: txEvent.groupTransactionId,
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            case 'TransactionDeleted': {
+                const txEvent = originalEvent;
+                mirrorEvent = new _1.TransactionDeleted({
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            case 'DescriptionChanged': {
+                const txEvent = originalEvent;
+                mirrorEvent = new _1.DescriptionChanged({
+                    description: txEvent.description,
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            case 'TotalAmountChanged': {
+                const txEvent = originalEvent;
+                mirrorEvent = new _1.TotalAmountChanged({
+                    totalAmount: txEvent.totalAmount,
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            case 'SplitTypeChanged': {
+                const txEvent = originalEvent;
+                const { amount, isOwed } = (0, splitTypeUtils_1.calculateMirrorAmountAndIsOwed)(txEvent.totalAmount, txEvent.amount, txEvent.splitType, txEvent.isOwed);
+                mirrorEvent = new _1.SplitTypeChanged({
+                    splitType: (0, splitTypeUtils_1.reverseSplitType)(txEvent.splitType),
+                    totalAmount: txEvent.totalAmount,
+                    amount,
+                    isOwed,
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            case 'CurrencyChanged': {
+                const txEvent = originalEvent;
+                mirrorEvent = new _1.CurrencyChanged({
+                    currency: txEvent.currency,
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            case 'TransactionDateChanged': {
+                const txEvent = originalEvent;
+                mirrorEvent = new _1.TransactionDateChanged({
+                    transactionDate: txEvent.transactionDate,
+                    createdAt: txEvent.createdAt,
+                    createdBy: txEvent.createdBy,
+                    streamId: mirrorStreamId,
+                    version: mirrorVersion,
+                });
+                break;
+            }
+            default:
+                return;
+        }
+        await this.eventStore.addEvent(recipientPath.userId, mirrorEvent);
+        const updatedModel = mirrorEvent.apply(existingMirrorModel);
         await this.modelStore.save(updatedModel);
-        return updatedModel;
+        if (this.activityEventHandler) {
+            await this.activityEventHandler.createActivityLog(mirrorEvent, existingMirrorModel, updatedModel);
+        }
     }
 }
 exports.TransactionEventHandler = TransactionEventHandler;

package/dist/UserEventHandler.d.ts

@@ -0,0 +1,17 @@
+import { UserCreated, PlaceholderUserCreated, UserCurrencyChanged, UserPhoneNumberChanged, UserDisplayNameChanged, UserDeleted, PlaceholderUserMerged, UserConvertedToPlaceholder, UserModel } from '.';
+import { UserModelStore } from '.';
+import { ActivityEventHandler } from './ActivityEventHandler';
+export declare class UserEventHandler {
+    private modelStore;
+    private activityEventHandler?;
+    constructor(modelStore: UserModelStore, activityEventHandler?: ActivityEventHandler | undefined);
+    handleUserCreated(event: UserCreated): Promise<UserModel>;
+    handlePlaceholderUserCreated(event: PlaceholderUserCreated): Promise<UserModel>;
+    handleUserCurrencyChanged(event: UserCurrencyChanged): Promise<UserModel>;
+    handleUserPhoneNumberChanged(event: UserPhoneNumberChanged): Promise<UserModel>;
+    handleUserDisplayNameChanged(event: UserDisplayNameChanged): Promise<UserModel>;
+    handleUserDeleted(event: UserDeleted): Promise<UserModel>;
+    handlePlaceholderUserMerged(event: PlaceholderUserMerged): Promise<UserModel>;
+    handleUserConvertedToPlaceholder(event: UserConvertedToPlaceholder): Promise<UserModel>;
+}
+//# sourceMappingURL=UserEventHandler.d.ts.map

package/dist/UserEventHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserEventHandler.d.ts","sourceRoot":"","sources":["../src/UserEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EACX,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,EACtB,WAAW,EACX,qBAAqB,EACrB,0BAA0B,EAC1B,SAAS,EACZ,MAAM,GAAG,CAAC;AACX,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AACjC,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAE5D,qBAAa,gBAAgB;IAErB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,oBAAoB,CAAC;gBADrB,UAAU,EAAE,cAAc,EAC1B,oBAAoB,CAAC,EAAE,oBAAoB,YAAA;IAGjD,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IAUzD,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,SAAS,CAAC;IAU/E,yBAAyB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC;IAUzE,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,SAAS,CAAC;IAU/E,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,SAAS,CAAC;IAU/E,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IAUzD,2BAA2B,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC;IAU7E,gCAAgC,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,SAAS,CAAC;CAShG"}

package/dist/UserEventHandler.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserEventHandler = void 0;
+class UserEventHandler {
+    constructor(modelStore, activityEventHandler) {
+        this.modelStore = modelStore;
+        this.activityEventHandler = activityEventHandler;
+    }
+    async handleUserCreated(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 handlePlaceholderUserCreated(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 handleUserCurrencyChanged(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 handleUserPhoneNumberChanged(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 handleUserDisplayNameChanged(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 handleUserDeleted(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 handlePlaceholderUserMerged(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 handleUserConvertedToPlaceholder(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.UserEventHandler = UserEventHandler;

package/dist/events.d.ts

@@ -0,0 +1,30 @@
+export * from './TransactionEvents';
+export * from './UserEvents';
+export * from './FriendEvents';
+export * from './GroupEvents';
+export * from './GroupTransactionEvents';
+export * from './ActivityLogEvents';
+export * from './common/Event';
+export * from './common/Model';
+export * from './store/ModelStore';
+export * from './store/TransactionEventStore';
+export * from './store/TransactionModelStore';
+export * from './store/UserEventStore';
+export * from './store/UserModelStore';
+export * from './store/FriendEventStore';
+export * from './store/FriendModelStore';
+export * from './store/GroupEventStore';
+export * from './store/GroupModelStore';
+export * from './store/GroupTransactionEventStore';
+export * from './store/GroupTransactionModelStore';
+export * from './store/ActivityLogEventStore';
+export * from './store/ActivityLogModelStore';
+export { TransactionEventHandler } from './TransactionEventHandler';
+export { UserEventHandler } from './UserEventHandler';
+export { FriendEventHandler } from './FriendEventHandler';
+export { GroupEventHandler } from './GroupEventHandler';
+export { GroupTransactionEventHandler } from './GroupTransactionEventHandler';
+export { ActivityEventHandler } from './ActivityEventHandler';
+export { reverseSplitType, calculateMirrorAmountAndIsOwed } from './utils/splitTypeUtils';
+export { getUserEventPath } from './utils/userPathUtils';
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAG/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAG9C,OAAO,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAC,4BAA4B,EAAC,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EAAC,gBAAgB,EAAE,8BAA8B,EAAC,MAAM,wBAAwB,CAAC;AACxF,OAAO,EAAC,gBAAgB,EAAC,MAAM,uBAAuB,CAAC"}