@flusys/nestjs-event-manager 6.0.2 → 6.1.0

package/fesm/services/event-manager-datasource.provider.spec.js

@@ -0,0 +1,194 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { Event, EventParticipant, EventWithCompany } from '../entities';
+import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
+function buildConfigService(overrides = {}) {
+    return {
+        isCompanyFeatureEnabled: jest.fn().mockReturnValue(overrides.isCompanyFeatureEnabled ?? false),
+        getDatabaseMode: jest.fn().mockReturnValue('single'),
+        isMultiTenant: jest.fn().mockReturnValue(false),
+        getDefaultColor: jest.fn(),
+        getMaxRecurrenceOccurrences: jest.fn(),
+        getOptions: jest.fn().mockReturnValue(overrides.options ?? {
+            bootstrapAppConfig: {
+                enableCompanyFeature: false,
+                databaseMode: 'single'
+            },
+            config: {
+                defaultDatabaseConfig: {
+                    type: 'mysql',
+                    host: 'localhost'
+                },
+                tenantDefaultDatabaseConfig: undefined,
+                tenants: []
+            }
+        })
+    };
+}
+describe('EventManagerDataSourceProvider', ()=>{
+    afterEach(()=>{
+        jest.restoreAllMocks();
+    });
+    describe('constructor / buildParentOptions', ()=>{
+        it('maps module options to the parent IDataSourceServiceOptions shape', ()=>{
+            const configService = buildConfigService({
+                options: {
+                    bootstrapAppConfig: {
+                        enableCompanyFeature: true,
+                        databaseMode: 'multi-tenant'
+                    },
+                    config: {
+                        defaultDatabaseConfig: {
+                            type: 'mysql',
+                            host: 'db-host'
+                        },
+                        tenantDefaultDatabaseConfig: {
+                            type: 'mysql',
+                            host: 'tenant-host'
+                        },
+                        tenants: [
+                            {
+                                id: 'tenant-1',
+                                database: 'tenant_db'
+                            }
+                        ]
+                    }
+                }
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            expect(provider.options).toEqual({
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true,
+                    databaseMode: 'multi-tenant'
+                },
+                defaultDatabaseConfig: {
+                    type: 'mysql',
+                    host: 'db-host'
+                },
+                tenantDefaultDatabaseConfig: {
+                    type: 'mysql',
+                    host: 'tenant-host'
+                },
+                tenants: [
+                    {
+                        id: 'tenant-1',
+                        database: 'tenant_db'
+                    }
+                ]
+            });
+        });
+        it('builds parent options gracefully when config is not provided', ()=>{
+            const configService = buildConfigService({
+                options: {
+                    bootstrapAppConfig: undefined,
+                    config: undefined
+                }
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            expect(provider.options).toEqual({
+                bootstrapAppConfig: undefined,
+                defaultDatabaseConfig: undefined,
+                tenantDefaultDatabaseConfig: undefined,
+                tenants: undefined
+            });
+        });
+    });
+    describe('getEnableCompanyFeatureForTenant', ()=>{
+        it('returns the tenant override when explicitly true', ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            const result = provider.getEnableCompanyFeatureForTenant({
+                enableCompanyFeature: true
+            });
+            expect(result).toBe(true);
+        });
+        it('returns the tenant override when explicitly false', ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: true
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            const result = provider.getEnableCompanyFeatureForTenant({
+                enableCompanyFeature: false
+            });
+            expect(result).toBe(false);
+        });
+        it('falls back to the config service when tenant flag is undefined', ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: true
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            const result = provider.getEnableCompanyFeatureForTenant({});
+            expect(result).toBe(true);
+        });
+        it('falls back to the config service when no tenant is provided', ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            const result = provider.getEnableCompanyFeatureForTenant(undefined);
+            expect(result).toBe(false);
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('loads core event-manager entities when the company feature is disabled', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            const spy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue({
+                isInitialized: true
+            });
+            const config = {
+                type: 'mysql',
+                host: 'localhost'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(spy).toHaveBeenCalledWith(config, expect.arrayContaining([
+                Event,
+                EventParticipant
+            ]));
+            expect(spy.mock.calls[0][1]).not.toContain(EventWithCompany);
+        });
+        it('loads company-scoped event-manager entities when the company feature is enabled', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: true
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            const spy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue({
+                isInitialized: true
+            });
+            const config = {
+                type: 'mysql',
+                host: 'localhost'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(spy).toHaveBeenCalledWith(config, expect.arrayContaining([
+                EventWithCompany,
+                EventParticipant
+            ]));
+            expect(spy.mock.calls[0][1]).not.toContain(Event);
+        });
+        it('uses the current tenant override to resolve entities when a request is present', async ()=>{
+            const configService = buildConfigService({
+                isCompanyFeatureEnabled: false
+            });
+            const provider = new EventManagerDataSourceProvider(configService);
+            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue({
+                enableCompanyFeature: true
+            });
+            const spy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue({
+                isInitialized: true
+            });
+            const config = {
+                type: 'mysql',
+                host: 'localhost'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(spy).toHaveBeenCalledWith(config, expect.arrayContaining([
+                EventWithCompany,
+                EventParticipant
+            ]));
+        });
+    });
+});

package/fesm/services/event-manager-helper.service.spec.js

@@ -0,0 +1,323 @@
+import { NotFoundException } from '@nestjs/common';
+import { ParticipantStatus, RecurrenceType } from '@flusys/nestjs-shared';
+import { createMockRepository } from '@test-utils/mocks/repository.mock';
+import { EVENT_PARTICIPANT_MESSAGES } from '../config';
+import { EventParticipant, EventWithCompany } from '../entities';
+import { EventManagerHelperService } from './event-manager-helper.service';
+function buildEvent(overrides = {}) {
+    return {
+        id: 'event-uuid-1',
+        title: 'Sprint Planning',
+        description: null,
+        eventDate: '2026-04-03',
+        startTime: '09:00',
+        endTime: '10:00',
+        isAllDay: false,
+        recurrenceType: RecurrenceType.NONE,
+        recurrenceEndDate: null,
+        weekDays: null,
+        color: '#3B82F6',
+        meetingLink: null,
+        isActive: true,
+        createdAt: new Date('2026-01-01T00:00:00Z'),
+        updatedAt: new Date('2026-01-01T00:00:00Z'),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildParticipant(overrides = {}) {
+    return {
+        id: 'participant-uuid-1',
+        eventId: 'event-uuid-1',
+        userId: 'user-uuid-1',
+        status: ParticipantStatus.PENDING,
+        isOrganizer: false,
+        createdAt: new Date('2026-01-01T00:00:00Z'),
+        updatedAt: new Date('2026-01-01T00:00:00Z'),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('EventManagerHelperService', ()=>{
+    let service;
+    let mockEventRepo;
+    let mockParticipantRepo;
+    let mockConfigService;
+    let mockDataSourceProvider;
+    let mockUtilsService;
+    // `getRawMany` isn't part of the shared MockQueryBuilder — the participant queries in this
+    // service use `.getRawMany()`, so we augment the shared mock query builder instances here.
+    let mockEventQb;
+    let mockParticipantQb;
+    beforeEach(()=>{
+        mockEventRepo = createMockRepository();
+        mockParticipantRepo = createMockRepository();
+        mockEventQb = mockEventRepo.createQueryBuilder();
+        mockEventQb.getRawMany = jest.fn();
+        mockParticipantQb = mockParticipantRepo.createQueryBuilder();
+        mockParticipantQb.getRawMany = jest.fn();
+        mockConfigService = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
+            getDefaultColor: jest.fn().mockReturnValue('#3B82F6')
+        };
+        const fakeDataSource = {
+            getRepository: jest.fn((entity)=>entity === EventParticipant ? mockParticipantRepo : mockEventRepo)
+        };
+        mockDataSourceProvider = {
+            getDataSource: jest.fn().mockResolvedValue(fakeDataSource)
+        };
+        mockUtilsService = {
+            clearCache: jest.fn()
+        };
+        service = new EventManagerHelperService({}, mockUtilsService, mockConfigService, mockDataSourceProvider);
+    });
+    describe('createEvent', ()=>{
+        it('creates a timed event with the given fields and clears the cache', async ()=>{
+            const saved = buildEvent();
+            mockEventRepo.save.mockResolvedValue(saved);
+            mockParticipantRepo.save.mockResolvedValue([]);
+            const result = await service.createEvent({
+                title: 'Sprint Planning',
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00'
+            });
+            expect(mockEventRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                title: 'Sprint Planning',
+                startTime: '09:00',
+                endTime: '10:00',
+                isAllDay: false,
+                recurrenceType: RecurrenceType.NONE,
+                color: '#3B82F6'
+            }));
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('event', {});
+            expect(result.id).toBe(saved.id);
+            expect(result.companyId).toBeNull();
+        });
+        it('forces symbolic 00:00 / 23:59 markers for all-day events regardless of supplied times', async ()=>{
+            const saved = buildEvent({
+                isAllDay: true,
+                startTime: '00:00',
+                endTime: '23:59'
+            });
+            mockEventRepo.save.mockResolvedValue(saved);
+            await service.createEvent({
+                title: 'Company Holiday',
+                eventDate: '2026-12-25',
+                startTime: '09:00',
+                endTime: '17:00',
+                isAllDay: true
+            });
+            expect(mockEventRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                isAllDay: true,
+                startTime: '00:00',
+                endTime: '23:59'
+            }));
+        });
+        it('attaches companyId only when the company feature is enabled and a companyId is supplied', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const saved = buildEvent();
+            mockEventRepo.save.mockResolvedValue(saved);
+            await service.createEvent({
+                title: 'Sprint Planning',
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00',
+                companyId: 'company-uuid-1'
+            });
+            expect(mockEventRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                companyId: 'company-uuid-1'
+            }));
+        });
+        it('does not attach companyId when the company feature is disabled, even if supplied', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const saved = buildEvent();
+            mockEventRepo.save.mockResolvedValue(saved);
+            await service.createEvent({
+                title: 'Sprint Planning',
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00',
+                companyId: 'company-uuid-1'
+            });
+            const savedArg = mockEventRepo.save.mock.calls[0][0];
+            expect(savedArg).not.toHaveProperty('companyId');
+        });
+        it('adds the organizer and all participants with PENDING status, de-duplicated', async ()=>{
+            const saved = buildEvent();
+            mockEventRepo.save.mockResolvedValue(saved);
+            mockParticipantRepo.save.mockResolvedValue([]);
+            await service.createEvent({
+                title: 'Sprint Planning',
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00',
+                organizerId: 'organizer-uuid-1',
+                participantIds: [
+                    'organizer-uuid-1',
+                    'participant-uuid-2'
+                ]
+            });
+            const savedParticipants = mockParticipantRepo.save.mock.calls[0][0];
+            expect(savedParticipants).toHaveLength(2);
+            expect(savedParticipants).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    userId: 'organizer-uuid-1',
+                    isOrganizer: true,
+                    status: ParticipantStatus.PENDING
+                }),
+                expect.objectContaining({
+                    userId: 'participant-uuid-2',
+                    isOrganizer: false,
+                    status: ParticipantStatus.PENDING
+                })
+            ]));
+        });
+        it('skips participant creation entirely when no organizer or participants are given', async ()=>{
+            const saved = buildEvent();
+            mockEventRepo.save.mockResolvedValue(saved);
+            await service.createEvent({
+                title: 'Sprint Planning',
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00'
+            });
+            expect(mockParticipantRepo.save).not.toHaveBeenCalled();
+        });
+    });
+    describe('updateParticipantStatus', ()=>{
+        it('updates the status of an existing participant', async ()=>{
+            const participant = buildParticipant({
+                status: ParticipantStatus.PENDING
+            });
+            mockParticipantRepo.findOne.mockResolvedValue(participant);
+            mockParticipantRepo.save.mockResolvedValue({
+                ...participant,
+                status: ParticipantStatus.ACCEPTED
+            });
+            await service.updateParticipantStatus('participant-uuid-1', ParticipantStatus.ACCEPTED);
+            expect(mockParticipantRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                status: ParticipantStatus.ACCEPTED
+            }));
+        });
+        it('throws NotFoundException with the correct messageKey when the participant does not exist', async ()=>{
+            mockParticipantRepo.findOne.mockResolvedValue(null);
+            await expect(service.updateParticipantStatus('missing-uuid', ParticipantStatus.ACCEPTED)).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
+                })
+            });
+            await expect(service.updateParticipantStatus('missing-uuid', ParticipantStatus.ACCEPTED)).rejects.toBeInstanceOf(NotFoundException);
+        });
+    });
+    describe('getEventsForUser', ()=>{
+        it('returns an empty list without querying events when the user has no participant rows', async ()=>{
+            mockParticipantQb.getRawMany.mockResolvedValue([]);
+            const result = await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30');
+            expect(result).toEqual([]);
+            expect(mockEventQb.getMany).not.toHaveBeenCalled();
+            expect(mockEventQb.where).not.toHaveBeenCalled();
+        });
+        it('queries events scoped to the participant event ids and date range', async ()=>{
+            mockParticipantQb.getRawMany.mockResolvedValue([
+                {
+                    ep_event_id: 'event-uuid-1'
+                }
+            ]);
+            const events = [
+                buildEvent()
+            ];
+            mockEventQb.getMany.mockResolvedValue(events);
+            const result = await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30');
+            const eventQb = mockEventQb;
+            expect(eventQb.where).toHaveBeenCalledWith('event.id IN (:...eventIds)', {
+                eventIds: [
+                    'event-uuid-1'
+                ]
+            });
+            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate <= :endDate', {
+                endDate: '2026-04-30'
+            });
+            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate >= :startDate', {
+                startDate: '2026-04-01'
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe('event-uuid-1');
+        });
+        it('handles a zero-length range (startDate === endDate)', async ()=>{
+            mockParticipantQb.getRawMany.mockResolvedValue([
+                {
+                    ep_event_id: 'event-uuid-1'
+                }
+            ]);
+            mockEventQb.getMany.mockResolvedValue([
+                buildEvent()
+            ]);
+            const result = await service.getEventsForUser('user-uuid-1', '2026-04-03', '2026-04-03');
+            const eventQb = mockEventQb;
+            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate <= :endDate', {
+                endDate: '2026-04-03'
+            });
+            expect(eventQb.andWhere).toHaveBeenCalledWith('event.eventDate >= :startDate', {
+                startDate: '2026-04-03'
+            });
+            expect(result).toHaveLength(1);
+        });
+        it('scopes the query to the company when the company feature is enabled and a companyId is given', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockParticipantQb.getRawMany.mockResolvedValue([
+                {
+                    ep_event_id: 'event-uuid-1'
+                }
+            ]);
+            mockEventQb.getMany.mockResolvedValue([
+                buildEvent()
+            ]);
+            await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30', 'company-uuid-1');
+            const eventQb = mockEventQb;
+            expect(eventQb.andWhere).toHaveBeenCalledWith('event.companyId = :companyId', {
+                companyId: 'company-uuid-1'
+            });
+        });
+        it('does not scope the query to the company when the company feature is disabled', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            mockParticipantQb.getRawMany.mockResolvedValue([
+                {
+                    ep_event_id: 'event-uuid-1'
+                }
+            ]);
+            mockEventQb.getMany.mockResolvedValue([
+                buildEvent()
+            ]);
+            await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30', 'company-uuid-1');
+            const eventQb = mockEventQb;
+            const companyCalls = eventQb.andWhere.mock.calls.filter((call)=>call[0] === 'event.companyId = :companyId');
+            expect(companyCalls).toHaveLength(0);
+        });
+        it('requests the correct entity for the company feature toggle', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockParticipantQb.getRawMany.mockResolvedValue([]);
+            await service.getEventsForUser('user-uuid-1', '2026-04-01', '2026-04-30');
+            const fakeDataSource = await mockDataSourceProvider.getDataSource();
+            expect(fakeDataSource.getRepository).toHaveBeenCalledWith(EventWithCompany);
+        });
+    });
+    describe('getEventById', ()=>{
+        it('returns the mapped event when found', async ()=>{
+            mockEventRepo.findOne.mockResolvedValue(buildEvent());
+            const result = await service.getEventById('event-uuid-1');
+            expect(result?.id).toBe('event-uuid-1');
+        });
+        it('returns null when the event does not exist', async ()=>{
+            mockEventRepo.findOne.mockResolvedValue(null);
+            const result = await service.getEventById('missing-uuid');
+            expect(result).toBeNull();
+        });
+    });
+});

package/fesm/services/event.service.js

@@ -355,11 +355,16 @@ export class EventService extends ApiService {
                 break;
             case RecurrenceType.MONTHLY:
                 {
+                    // Compute the target year/month from the *original* date before any mutation.
+                    // Mutating `d` first (e.g. via setUTCMonth) can overflow past short months
+                    // (Jan 31 -> Feb 31 normalizes to Mar 3), which would then compute
+                    // `lastDayOfMonth` for the wrong (already-overflowed) month and silently
+                    // skip target months that have fewer days than the original day-of-month.
                     const targetDay = originalDayOfMonth ?? d.getUTCDate();
-                    d.setUTCMonth(d.getUTCMonth() + 1);
-                    const lastDayOfMonth = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0)).getUTCDate();
-                    d.setUTCDate(Math.min(targetDay, lastDayOfMonth));
-                    break;
+                    const targetYear = d.getUTCFullYear();
+                    const targetMonth = d.getUTCMonth() + 1;
+                    const lastDayOfMonth = new Date(Date.UTC(targetYear, targetMonth + 1, 0)).getUTCDate();
+                    return new Date(Date.UTC(targetYear, targetMonth, Math.min(targetDay, lastDayOfMonth))).toISOString().slice(0, 10);
                 }
             default:
                 break;