@stamhoofd/backend 2.83.4 → 2.84.0

package/src/helpers/AdminPermissionChecker.ts

@@ -1,7 +1,7 @@
 import { AutoEncoderPatchType, PatchMap } from '@simonbackx/simple-encoding';
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, CachedBalance, Document, EmailTemplate, Event, EventNotification, Group, Member, MemberPlatformMembership, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from '@stamhoofd/models';
-import { AccessRight, EventPermissionChecker, FinancialSupportSettings, GroupCategory, GroupStatus, GroupType, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordSettings, ResourcePermissions } from '@stamhoofd/structures';
+import { AccessRight, EmailTemplate as EmailTemplateStruct, EventPermissionChecker, FinancialSupportSettings, GroupCategory, GroupStatus, GroupType, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordSettings, ResourcePermissions } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { MemberRecordStore } from '../services/MemberRecordStore';
 import { addTemporaryMemberAccess, hasTemporaryMemberAccess } from './TemporaryMemberAccess';
@@ -20,7 +20,7 @@ export class AdminPermissionChecker {
     platform: PlatformStruct;
 
     organizationCache: Map<string, Organization | Promise<Organization | undefined>> = new Map();
-    organizationGroupsCache: Map<string, Group[] | Promise<Group[]>> = new Map();
+    groupsCache: Map<string, Group | null | Promise<Group | null>> = new Map();
 
     constructor(user: User, platform: PlatformStruct, organization?: Organization) {
         this.user = user;
@@ -64,17 +64,30 @@ export class AdminPermissionChecker {
         return id;
     }
 
-    async getOrganizationGroups(id: string) {
-        const c = this.organizationGroupsCache.get(id);
-        if (c) {
-            return await c;
+    async getGroup(groupId: string): Promise<Group | null> {
+        const cache = this.groupsCache.get(groupId);
+        if (cache !== undefined) {
+            return await cache;
+        }
+
+        const promise = Group.select()
+            .where('id', groupId)
+            .first(false);
+
+        this.groupsCache.set(groupId, promise);
+        const group = await promise;
+        this.groupsCache.set(groupId, group);
+        return group;
+    }
+
+    cacheGroup(group: Group) {
+        this.groupsCache.set(group.id, group);
+    }
+
+    cacheGroups(groups: Group[]) {
+        for (const group of groups) {
+            this.cacheGroup(group);
         }
-        const organization = await this.getOrganization(id);
-        const promise = Group.getAll(id, organization.periodId, true);
-        this.organizationGroupsCache.set(id, promise);
-        const result = await promise;
-        this.organizationGroupsCache.set(id, result);
-        return result;
     }
 
     async getOrganizationCurrentPeriod(id: string | Organization): Promise<OrganizationRegistrationPeriod> {
@@ -82,11 +95,14 @@ export class AdminPermissionChecker {
         return await organization.getPeriod();
     }
 
-    error(message?: string): SimpleError {
+    error(humanOrData?: string | { message: string; human?: string }): SimpleError {
+        const human = typeof humanOrData === 'string' ? humanOrData : (humanOrData?.human ?? $t(`ab071f11-e05b-4bd9-9370-cd4f220c1b54`));
+        const message = typeof humanOrData === 'string' ? humanOrData : (humanOrData?.message ?? 'You do not have permissions for this action');
+
         return new SimpleError({
             code: 'permission_denied',
-            message: 'You do not have permissions for this action',
-            human: message ?? $t(`ab071f11-e05b-4bd9-9370-cd4f220c1b54`),
+            message,
+            human,
             statusCode: 403,
         });
     }
@@ -205,6 +221,19 @@ export class AdminPermissionChecker {
             }
         }
 
+        if (group.type === GroupType.WaitingList) {
+            // Check if this is a waiting list for an event
+            const parentGroup = await Group.select()
+                .where('type', GroupType.EventRegistration)
+                .where('organizationId', group.organizationId)
+                .where('waitingListId', group.id)
+                .first(false);
+
+            if (parentGroup) {
+                return await this.canAccessGroup(parentGroup, permissionLevel);
+            }
+        }
+
         return false;
     }
 
@@ -360,8 +389,7 @@ export class AdminPermissionChecker {
             return true;
         }
 
-        const allGroups = await this.getOrganizationGroups(registration.organizationId);
-        const group = allGroups.find(g => g.id === registration.groupId);
+        const group = await this.getGroup(registration.groupId);
         if (!group || group.deletedAt) {
             return false;
         }
@@ -649,13 +677,19 @@ export class AdminPermissionChecker {
         return this.canEditUserName(user);
     }
 
-    async canAccessEmailTemplate(template: EmailTemplate, level: PermissionLevel = PermissionLevel.Read) {
-        if (level === PermissionLevel.Read) {
+    async canAccessEmailTemplate(template: EmailTemplate, level: PermissionLevel = PermissionLevel.Read): Promise<boolean> {
+        if (level === PermissionLevel.Read && !EmailTemplateStruct.isSavedEmail(template.type)) {
             if (template.organizationId === null) {
                 // Public templates
-                return true;
+
+                return EmailTemplateStruct.allowPlatformLevel(template.type);
             }
-            return this.canReadEmailTemplates(template.organizationId);
+
+            if (!await this.canReadEmailTemplates(template.organizationId)) {
+                return false;
+            }
+
+            return EmailTemplateStruct.allowOrganizationLevel(template.type);
         }
 
         // Note: if the template has an organizationId of null, everyone can access it, but only for reading
@@ -806,13 +840,11 @@ export class AdminPermissionChecker {
     }
 
     async canReadEmailTemplates(organizationId: string) {
-        const organizationPermissions = await this.getOrganizationPermissions(organizationId);
-
-        if (!organizationPermissions) {
+        if (!await this.hasSomeAccess(organizationId) && !this.hasSomePlatformAccess()) {
             return false;
         }
 
-        return !!this.user.permissions;
+        return true;
     }
 
     async canCreateGroupInCategory(organizationId: string, category: GroupCategory) {
@@ -1114,20 +1146,16 @@ export class AdminPermissionChecker {
         };
     }
 
-    async getAccessibleGroups(organizationId: string, level: PermissionLevel = PermissionLevel.Read): Promise<string[] | 'all'> {
-        if (await this.hasFullAccess(organizationId, level)) {
-            return 'all';
+    /**
+     * Performance helper
+     */
+    async canAccessAllMembers(organizationId: string, level: PermissionLevel = PermissionLevel.Read): Promise<boolean> {
+        const permissions = await this.getOrganizationPermissions(organizationId);
+        if (!permissions) {
+            return false;
         }
 
-        const groups = await this.getOrganizationGroups(organizationId);
-        const accessibleGroups: string[] = [];
-
-        for (const group of groups) {
-            if (await this.canAccessGroup(group, level)) {
-                accessibleGroups.push(group.id);
-            }
-        }
-        return accessibleGroups;
+        return permissions.hasResourceAccess(PermissionsResourceType.Groups, '', level);
     }
 
     /**

package/src/helpers/AuthenticatedStructures.ts

@@ -1,11 +1,12 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { AuditLog, BalanceItem, CachedBalance, Document, Event, EventNotification, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, RegistrationPeriod, Ticket, User, Webshop } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLog as AuditLogStruct, DetailedReceivableBalance, Document as DocumentStruct, EventNotification as EventNotificationStruct, Event as EventStruct, GenericBalance, Group as GroupStruct, GroupType, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, NamedObject, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, Platform, PrivateOrder, PrivateWebshop, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, TicketPrivate, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLog as AuditLogStruct, DetailedReceivableBalance, Document as DocumentStruct, EventNotification as EventNotificationStruct, Event as EventStruct, GenericBalance, Group as GroupStruct, GroupType, MemberPlatformMembership as MemberPlatformMembershipStruct, MembersBlob, MemberWithRegistrationsBlob, NamedObject, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, Platform, PrivateOrder, PrivateWebshop, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, RegistrationsBlob, RegistrationWithMemberBlob, TicketPrivate, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 import { Sorter } from '@stamhoofd/utility';
 
 import { SQL } from '@stamhoofd/sql';
 import { Formatter } from '@stamhoofd/utility';
 import { Context } from './Context';
+import { BalanceItemService } from '../services/BalanceItemService';
 
 /**
  * Builds authenticated structures for the current user
@@ -101,7 +102,7 @@ export class AuthenticatedStructures {
         return structs;
     }
 
-    static async organizationRegistrationPeriods(organizationRegistrationPeriods: OrganizationRegistrationPeriod[], periods?: RegistrationPeriod[]) {
+    static async organizationRegistrationPeriods(organizationRegistrationPeriods: OrganizationRegistrationPeriod[], periods?: RegistrationPeriod[], options?: { forceGroupIds?: string[] }) {
         if (organizationRegistrationPeriods.length === 0) {
             return [];
         }
@@ -114,7 +115,10 @@ export class AuthenticatedStructures {
 
         const organizationIds = Formatter.uniqueArray(organizationRegistrationPeriods.map(r => r.organizationId));
 
-        const groupIds = Formatter.uniqueArray(organizationRegistrationPeriods.flatMap(p => p.settings.categories.flatMap(c => c.groupIds)));
+        const groupIds = Formatter.uniqueArray([
+            ...organizationRegistrationPeriods.flatMap(p => p.settings.categories.flatMap(c => c.groupIds)),
+            ...(options?.forceGroupIds ?? []),
+        ]);
 
         let groups: Group[] = [];
 
@@ -391,6 +395,10 @@ export class AuthenticatedStructures {
         const organizations = new Map<string, Organization>();
 
         const registrationIds = Formatter.uniqueArray(members.flatMap(m => m.registrations.map(r => r.id)));
+
+        if (Context.organization) {
+            await BalanceItemService.flushCaches(Context.organization.id);
+        }
         const balances = await CachedBalance.getForObjects(registrationIds, null);
 
         if (includeUser) {
@@ -550,6 +558,38 @@ export class AuthenticatedStructures {
         return (await this.eventNotifications([eventNotification]))[0];
     }
 
+    static async registrationsBlob(registrationData: {
+        memberId: string;
+        id: string;
+    }[], members: MemberWithRegistrations[], includeContextOrganization = false, includeUser?: User): Promise<RegistrationsBlob> {
+        const membersBlob = await this.membersBlob(members, includeContextOrganization, includeUser);
+
+        const memberBlobs = membersBlob.members;
+
+        const registrationWithMemberBlobs = registrationData.map(({ id, memberId }) => {
+            const memberBlob = memberBlobs.find(m => m.id === memberId);
+            if (!memberBlob) {
+                throw new Error('Member not found');
+            }
+
+            const registration = memberBlob.registrations.find(r => r.id === id);
+            if (!registration) {
+                throw new Error('Registration not found');
+            }
+
+            return RegistrationWithMemberBlob.create({
+                ...registration,
+                balances: memberBlob.registrations.find(r => r.id === registration.id)?.balances ?? [],
+                member: memberBlob,
+            });
+        });
+
+        return RegistrationsBlob.create({
+            registrations: registrationWithMemberBlobs,
+            organizations: membersBlob.organizations,
+        });
+    }
+
     static async eventNotifications(eventNotifications: EventNotification[]): Promise<EventNotificationStruct[]> {
         if (eventNotifications.length === 0) {
             return [];

package/src/helpers/Context.ts

@@ -106,8 +106,17 @@ export class ContextInstance {
         });
     }
 
-    static async start<T>(request: Request, handler: () => Promise<T>): Promise<T> {
+    static getContextFromRequest(request: Request): ContextInstance {
+        if ((request as any)._context) {
+            return (request as any)._context as ContextInstance;
+        }
         const context = new ContextInstance(request);
+        (request as any)._context = context;
+        return context;
+    }
+
+    static async start<T>(request: Request, handler: () => Promise<T>): Promise<T> {
+        const context = this.getContextFromRequest(request);
 
         return await this.asyncLocalStorage.run(context, async () => {
             return await handler();
@@ -223,6 +232,11 @@ export class ContextInstance {
         const token = await Token.getByAccessToken(accessToken, true);
 
         if (!token || (this.organization && token.user.organizationId !== null && token.user.organizationId !== this.organization.id) || (!this.organization && token.user.organizationId)) {
+            if (token?.user) {
+                console.log(
+                    'Failed auth: ' + token?.user.email + ' (' + token?.user.id + ')',
+                );
+            }
             throw new SimpleError({
                 code: 'invalid_access_token',
                 message: 'The access token is invalid',
@@ -232,6 +246,11 @@ export class ContextInstance {
         }
 
         if (token.isAccessTokenExpired()) {
+            if (token?.user) {
+                console.log(
+                    'Failed auth: ' + token?.user.email + ' (' + token?.user.id + ')',
+                );
+            }
             throw new SimpleError({
                 code: 'expired_access_token',
                 message: 'The access token is expired',
@@ -241,6 +260,11 @@ export class ContextInstance {
         }
 
         if (!token.user.hasAccount() && !allowWithoutAccount) {
+            if (token?.user) {
+                console.log(
+                    'Failed auth: ' + token?.user.email + ' (' + token?.user.id + ')',
+                );
+            }
             throw new SimpleError({
                 code: 'not_activated',
                 message: 'This user is not yet activated',
@@ -257,6 +281,10 @@ export class ContextInstance {
         const user = token.user;
         this.user = user;
 
+        console.log(
+            'Auth: ' + user.email + ' (' + user.id + ')',
+        );
+
         // Load member of user
         // todo
 

package/src/helpers/GlobalHelper.ts

@@ -1,7 +1,8 @@
 import { I18n } from '@stamhoofd/backend-i18n';
+import { BalanceItemService } from '../services/BalanceItemService';
 import { FileSignService } from '../services/FileSignService';
-import { Context, ContextInstance } from './Context';
 import { MemberRecordStore } from '../services/MemberRecordStore';
+import { ContextInstance } from './Context';
 
 export class GlobalHelper {
     static async load() {
@@ -9,6 +10,7 @@ export class GlobalHelper {
         this.loadGlobalTranslateFunction();
         await FileSignService.load();
         MemberRecordStore.init();
+        BalanceItemService.listen();
     }
 
     private static loadGlobalTranslateFunction() {

package/src/helpers/GroupedThrottledQueue.test.ts

@@ -0,0 +1,219 @@
+import { GroupedThrottledQueue } from './GroupedThrottledQueue';
+
+describe('GroupedThrottledQueue', () => {
+    // Mock timers for controlling setTimeout
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    afterAll(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should create an instance with the provided handler', () => {
+        const handler = jest.fn();
+        const queue = new GroupedThrottledQueue(handler);
+
+        expect(queue.handler).toBe(handler);
+        expect(queue.queues.size).toBe(0);
+    });
+
+    it('should call handler when processing items from a group', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('group1', 1);
+        await queue.flushAndWait();
+
+        expect(handler).toHaveBeenCalledWith('group1', [1]);
+    });
+
+    it('should process items from different groups separately', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('group1', 1);
+        queue.addItem('group2', 2);
+
+        await queue.flushAndWait();
+
+        expect(handler).toHaveBeenCalledWith('group1', [1]);
+        expect(handler).toHaveBeenCalledWith('group2', [2]);
+        expect(handler).toHaveBeenCalledTimes(2);
+    });
+
+    it('should batch items from the same group', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItems('group1', [1, 2, 3]);
+
+        await queue.flushAndWait();
+
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledWith('group1', [1, 2, 3]);
+    });
+
+    it('should flush only the specified group', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('group1', 1);
+        queue.addItem('group2', 2);
+
+        await queue.flushGroupAndWait('group1');
+
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledWith('group1', [1]);
+
+        // Flush the remaining group
+        await queue.flushGroupAndWait('group2');
+        expect(handler).toHaveBeenCalledTimes(2);
+        expect(handler).toHaveBeenCalledWith('group2', [2]);
+    });
+
+    it('should remove the group when all items are processed', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('group1', 1);
+
+        expect(queue.queues.size).toBe(1);
+        expect(queue.queues.has('group1')).toBe(true);
+
+        await queue.flushAndWait();
+
+        // Group should be removed because the queue is empty
+        expect(queue.queues.size).toBe(0);
+        expect(queue.queues.has('group1')).toBe(false);
+    });
+
+    it('should handle multiple items added to the same group', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('group1', 1);
+        queue.addItem('group1', 2);
+        queue.addItem('group1', 3);
+
+        await queue.flushAndWait();
+
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler).toHaveBeenCalledWith('group1', expect.arrayContaining([1, 2, 3]));
+    });
+
+    it('should handle large batch sizes correctly', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        // Create a large array of items
+        const items = Array.from({ length: 150 }, (_, i) => i);
+
+        queue.addItems('group1', items);
+
+        await queue.flushAndWait();
+
+        // Due to the default maxBatchSize of 100, we expect multiple handler calls
+        expect(handler.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+        // Verify all items were processed
+        const processedItems = handler.mock.calls.flatMap(call => call[1]);
+        expect(processedItems).toHaveLength(items.length);
+        expect(new Set(processedItems)).toEqual(new Set(items));
+    });
+
+    it('should handle errors in handler without failing the queue', async () => {
+        const consoleErrorMock = jest.spyOn(console, 'error').mockImplementation();
+
+        const handler = jest.fn().mockImplementation((group, items) => {
+            if (group === 'error-group') {
+                throw new Error('Test error');
+            }
+        });
+
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('error-group', 1);
+        queue.addItem('normal-group', 2);
+
+        await queue.flushAndWait();
+
+        expect(handler).toHaveBeenCalledWith('error-group', [1]);
+        expect(handler).toHaveBeenCalledWith('normal-group', [2]);
+        expect(consoleErrorMock).toHaveBeenCalled();
+
+        // Both groups should be removed because their queues are empty
+        expect(queue.queues.size).toBe(0);
+
+        consoleErrorMock.mockRestore();
+    });
+
+    it('should handle async handler functions', async () => {
+        let processingPromise: Promise<void> | null = null;
+
+        const handler = jest.fn().mockImplementation((group, items) => {
+            processingPromise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 10);
+            });
+            return processingPromise;
+        });
+
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        queue.addItem('group1', 1);
+        const waitPromise = queue.flushAndWait();
+
+        // Check that the handler was called
+        expect(handler).toHaveBeenCalled();
+        expect(queue.queues.size).toBe(1);
+
+        // Fast-forward time to resolve the processing promise
+        jest.advanceTimersByTime(100);
+
+        // Wait for the processing to complete
+        await waitPromise;
+
+        // The group should be removed now
+        expect(queue.queues.size).toBe(0);
+    });
+
+    it('should not error when flushing non-existing groups', async () => {
+        const handler = jest.fn();
+        const queue = new GroupedThrottledQueue<number>(handler);
+
+        await expect(queue.flushGroupAndWait('non-existing')).resolves.not.toThrow();
+        queue.flushGroup('non-existing'); // Should not throw
+
+        expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('should automatically flush after maxDelay', async () => {
+        const handler = jest.fn().mockResolvedValue(undefined);
+        const queue = new GroupedThrottledQueue(handler);
+        queue.maxDelay = 1000; // Set a max delay for the timeout
+
+        queue.addItem('group-1', 1);
+        expect(queue.timeout).not.toBeNull();
+
+        jest.advanceTimersByTime(500);
+
+        queue.addItem('group-2', 2);
+        await queue.wait();
+        expect(handler).not.toHaveBeenCalled();
+
+        // Fast-forward time
+        jest.advanceTimersByTime(500);
+
+        await queue.wait();
+        expect(handler).toHaveBeenCalledWith('group-1', [1]);
+        expect(handler).toHaveBeenCalledWith('group-2', [2]);
+        expect(queue.queues.size).toBe(0);
+        expect(queue.timeout).toBeNull();
+    });
+});

package/src/helpers/GroupedThrottledQueue.ts

@@ -0,0 +1,108 @@
+import { ThrottledQueue } from './ThrottledQueue';
+
+/**
+ * Items are added to the queue and filtered by a handler function.
+ * Then they are throttled per filtered group.
+ */
+export class GroupedThrottledQueue<T> {
+    queues: Map<string, ThrottledQueue<T>> = new Map();
+    handler: (group: string, items: T[]) => Promise<void> | void;
+    timeout: NodeJS.Timeout | null = null;
+
+    /**
+     * The queue is cleared at least after this duration.
+     * Set to null (default) to disable the timeout.
+     * In milliseconds.
+     */
+    maxDelay: number | null = 10_000;
+
+    constructor(
+        handler: (group: string, items: T[]) => Promise<void> | void,
+        options: { maxDelay?: number | null } = {},
+    ) {
+        this.handler = handler;
+        this.maxDelay = options.maxDelay ?? 10_000;
+    }
+
+    addItems(group: string, items: T[]): void {
+        const existingQueue = this.queues.get(group);
+        if (existingQueue) {
+            existingQueue.addItems(items);
+            this.startTimeout();
+            return;
+        }
+        const newQueue = new ThrottledQueue<T>(items => this.handler(group, items), {
+            maxDelay: null,
+            emptyHandler: () => {
+                this.queues.delete(group);
+            },
+        });
+        this.queues.set(group, newQueue);
+        newQueue.addItems(items);
+        this.startTimeout();
+    }
+
+    addItem(group: string, item: T): void {
+        this.addItems(group, [item]);
+    }
+
+    stopTimeout() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+    }
+
+    startTimeout() {
+        if (this.timeout || this.maxDelay === null) {
+            // Keep existing
+            return;
+        }
+
+        this.timeout = setTimeout(() => {
+            this.timeout = null;
+            this.flushAll();
+        }, this.maxDelay); // Adjust the timeout duration as needed
+    }
+
+    flushGroup(group: string): void {
+        const queue = this.queues.get(group);
+        if (queue) {
+            queue.flushAll();
+        }
+    }
+
+    flushAll(): void {
+        for (const queue of this.queues.values()) {
+            queue.flushAll();
+        }
+        this.stopTimeout();
+    }
+
+    async waitGroup(group: string) {
+        const queue = this.queues.get(group);
+        if (queue) {
+            await queue.wait();
+        }
+    }
+
+    async flushGroupAndWait(group: string) {
+        const queue = this.queues.get(group);
+        if (queue) {
+            await queue.flushAndWait();
+        }
+    }
+
+    async flushAndWait() {
+        this.stopTimeout();
+        for (const queue of this.queues.values()) {
+            await queue.flushAndWait();
+        }
+    }
+
+    async wait() {
+        for (const queue of this.queues.values()) {
+            await queue.wait();
+        }
+    }
+}