@flusys/nestjs-event-manager 6.0.2 → 6.1.0

package/cjs/adapters/event-manager.adapter.spec.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _nestjsshared = require("@flusys/nestjs-shared");
+const _eventmanageradapter = require("./event-manager.adapter");
+describe('EventManagerAdapter', ()=>{
+    let adapter;
+    let mockHelper;
+    beforeEach(()=>{
+        mockHelper = {
+            createEvent: jest.fn(),
+            updateParticipantStatus: jest.fn(),
+            getEventsForUser: jest.fn(),
+            getEventById: jest.fn()
+        };
+        adapter = new _eventmanageradapter.EventManagerAdapter(mockHelper);
+    });
+    describe('createEvent', ()=>{
+        it('delegates to the helper service and returns its result', async ()=>{
+            const options = {
+                title: 'Sprint Planning',
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00'
+            };
+            const expected = {
+                id: 'event-uuid-1',
+                title: 'Sprint Planning',
+                description: null,
+                eventDate: '2026-04-03',
+                startTime: '09:00',
+                endTime: '10:00',
+                isAllDay: false,
+                recurrenceType: 'none',
+                recurrenceEndDate: null,
+                weekDays: null,
+                color: '#3B82F6',
+                meetingLink: null,
+                isActive: true,
+                companyId: null,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            mockHelper.createEvent.mockResolvedValue(expected);
+            const result = await adapter.createEvent(options);
+            expect(mockHelper.createEvent).toHaveBeenCalledWith(options);
+            expect(result).toBe(expected);
+        });
+        it('propagates errors thrown by the helper service', async ()=>{
+            mockHelper.createEvent.mockRejectedValue(new Error('boom'));
+            await expect(adapter.createEvent({})).rejects.toThrow('boom');
+        });
+    });
+    describe('updateParticipantStatus', ()=>{
+        it('delegates to the helper service', async ()=>{
+            mockHelper.updateParticipantStatus.mockResolvedValue(undefined);
+            await adapter.updateParticipantStatus('participant-uuid-1', _nestjsshared.ParticipantStatus.ACCEPTED);
+            expect(mockHelper.updateParticipantStatus).toHaveBeenCalledWith('participant-uuid-1', _nestjsshared.ParticipantStatus.ACCEPTED);
+        });
+    });
+    describe('getEventsForUser', ()=>{
+        it('converts Date range boundaries to YYYY-MM-DD strings before delegating', async ()=>{
+            mockHelper.getEventsForUser.mockResolvedValue([]);
+            const startDate = new Date('2026-04-01T00:00:00.000Z');
+            const endDate = new Date('2026-04-30T23:59:59.000Z');
+            await adapter.getEventsForUser('user-uuid-1', startDate, endDate, 'company-uuid-1');
+            expect(mockHelper.getEventsForUser).toHaveBeenCalledWith('user-uuid-1', '2026-04-01', '2026-04-30', 'company-uuid-1');
+        });
+        it('forwards undefined companyId when not supplied', async ()=>{
+            mockHelper.getEventsForUser.mockResolvedValue([]);
+            const startDate = new Date('2026-04-01T00:00:00.000Z');
+            const endDate = new Date('2026-04-02T00:00:00.000Z');
+            await adapter.getEventsForUser('user-uuid-1', startDate, endDate);
+            expect(mockHelper.getEventsForUser).toHaveBeenCalledWith('user-uuid-1', '2026-04-01', '2026-04-02', undefined);
+        });
+        it('returns the events resolved by the helper service', async ()=>{
+            const events = [
+                {
+                    id: 'event-uuid-1'
+                }
+            ];
+            mockHelper.getEventsForUser.mockResolvedValue(events);
+            const result = await adapter.getEventsForUser('user-uuid-1', new Date('2026-01-01T00:00:00.000Z'), new Date('2026-01-31T00:00:00.000Z'));
+            expect(result).toBe(events);
+        });
+    });
+    describe('getEventById', ()=>{
+        it('returns the event resolved by the helper service', async ()=>{
+            const event = {
+                id: 'event-uuid-1'
+            };
+            mockHelper.getEventById.mockResolvedValue(event);
+            const result = await adapter.getEventById('event-uuid-1');
+            expect(mockHelper.getEventById).toHaveBeenCalledWith('event-uuid-1');
+            expect(result).toBe(event);
+        });
+        it('returns null when the helper service finds no matching event', async ()=>{
+            mockHelper.getEventById.mockResolvedValue(null);
+            const result = await adapter.getEventById('missing-uuid');
+            expect(result).toBeNull();
+        });
+    });
+});

package/cjs/controllers/event.controller.spec.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _enums = require("@flusys/nestjs-shared/enums");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _config = require("../config");
+const _eventcontroller = require("./event.controller");
+function buildCalendarEvent(overrides = {}) {
+    return {
+        id: 'event-uuid-1',
+        title: 'Sprint Planning',
+        description: null,
+        eventDate: '2026-04-03',
+        startTime: '09:00',
+        endTime: '10:00',
+        isAllDay: false,
+        recurrenceType: _enums.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
+    };
+}
+describe('EventController', ()=>{
+    let controller;
+    let mockService;
+    const user = (0, _loggedusermock.buildMockUser)();
+    beforeEach(()=>{
+        mockService = {
+            getEventsForCalendarRange: jest.fn(),
+            updateParticipantStatus: jest.fn()
+        };
+        controller = new _eventcontroller.EventController(mockService);
+    });
+    describe('getCalendarEvents', ()=>{
+        it('returns a ListResponseDto shaped payload with meta reflecting the result count', async ()=>{
+            const events = [
+                buildCalendarEvent(),
+                buildCalendarEvent({
+                    id: 'event-uuid-2'
+                })
+            ];
+            mockService.getEventsForCalendarRange.mockResolvedValue(events);
+            const dto = {
+                startDate: '2026-04-01',
+                endDate: '2026-04-30'
+            };
+            const result = await controller.getCalendarEvents(dto, user);
+            expect(mockService.getEventsForCalendarRange).toHaveBeenCalledWith(dto, user);
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(_config.EVENT_MESSAGES.GET_ALL_SUCCESS);
+            expect(result.data).toHaveLength(2);
+            expect(result.meta).toEqual({
+                total: 2,
+                page: 0,
+                pageSize: 2,
+                count: 2
+            });
+        });
+        it('returns an empty payload with zeroed meta when no events are found', async ()=>{
+            mockService.getEventsForCalendarRange.mockResolvedValue([]);
+            const dto = {
+                startDate: '2026-04-01',
+                endDate: '2026-04-01'
+            };
+            const result = await controller.getCalendarEvents(dto, user);
+            expect(result.data).toEqual([]);
+            expect(result.meta).toEqual({
+                total: 0,
+                page: 0,
+                pageSize: 0,
+                count: 0
+            });
+        });
+        it('serializes events through CalendarEventResponseDto, exposing only declared fields', async ()=>{
+            const events = [
+                buildCalendarEvent({
+                    originalEventId: 'event-uuid-1',
+                    isRecurrenceInstance: true,
+                    // extraneous field that must be stripped by excludeExtraneousValues
+                    ...{
+                        secretInternalField: 'should-not-leak'
+                    }
+                })
+            ];
+            mockService.getEventsForCalendarRange.mockResolvedValue(events);
+            const dto = {
+                startDate: '2026-04-01',
+                endDate: '2026-04-30'
+            };
+            const result = await controller.getCalendarEvents(dto, user);
+            const [firstEvent] = result.data ?? [];
+            expect(firstEvent).not.toHaveProperty('secretInternalField');
+            expect(firstEvent).toMatchObject({
+                id: 'event-uuid-1',
+                originalEventId: 'event-uuid-1',
+                isRecurrenceInstance: true
+            });
+        });
+        it('propagates errors raised by the service', async ()=>{
+            mockService.getEventsForCalendarRange.mockRejectedValue(new Error('db down'));
+            const dto = {
+                startDate: '2026-04-01',
+                endDate: '2026-04-30'
+            };
+            await expect(controller.getCalendarEvents(dto, user)).rejects.toThrow('db down');
+        });
+    });
+    describe('updateParticipantStatus', ()=>{
+        it('returns a SingleResponseDto shaped payload on success', async ()=>{
+            const participant = {
+                id: 'participant-uuid-1',
+                eventId: 'event-uuid-1',
+                userId: user.id,
+                status: _enums.ParticipantStatus.ACCEPTED,
+                isOrganizer: false,
+                createdAt: new Date('2026-01-01T00:00:00Z'),
+                updatedAt: new Date('2026-01-02T00:00:00Z')
+            };
+            mockService.updateParticipantStatus.mockResolvedValue(participant);
+            const dto = {
+                id: 'participant-uuid-1',
+                status: _enums.ParticipantStatus.ACCEPTED
+            };
+            const result = await controller.updateParticipantStatus(dto, user);
+            expect(mockService.updateParticipantStatus).toHaveBeenCalledWith(dto, user);
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(_config.EVENT_PARTICIPANT_MESSAGES.STATUS_UPDATE_SUCCESS);
+            expect(result.data).toMatchObject({
+                id: 'participant-uuid-1',
+                status: _enums.ParticipantStatus.ACCEPTED
+            });
+        });
+        it('propagates a NotFoundException raised by the service', async ()=>{
+            mockService.updateParticipantStatus.mockRejectedValue(new _common.NotFoundException({
+                message: 'Event participant not found',
+                messageKey: _config.EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
+            }));
+            const dto = {
+                id: 'missing-uuid',
+                status: _enums.ParticipantStatus.DECLINED
+            };
+            await expect(controller.updateParticipantStatus(dto, user)).rejects.toThrow(_common.NotFoundException);
+        });
+    });
+});

package/cjs/docs/event-manager-swagger.config.spec.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventmanagerswaggerconfig = require("./event-manager-swagger.config");
+describe('eventManagerSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)();
+        expect(config.title).toBe('Event Manager API');
+        expect(config.path).toBe('api/docs/event-manager');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should exclude companyId schema properties when the company feature is disabled', ()=>{
+        const config = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'EventResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'CalendarEventResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should describe company-scoped events and multi-tenant support only when the company feature is enabled', ()=>{
+        const withCompany = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Company-scoped events');
+        expect(withCompany.description).toContain('Company isolation');
+        expect(withCompany.description).toContain('## Multi-Tenant Support');
+        expect(withCompany.description).toContain('and multi-tenant capabilities');
+        expect(withoutCompany.description).not.toContain('Company-scoped events');
+        expect(withoutCompany.description).not.toContain('Company isolation');
+        expect(withoutCompany.description).not.toContain('## Multi-Tenant Support');
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _eventmanagerswaggerconfig.eventManagerSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+const _eventparticipantentity = require("./event-participant.entity");
+describe('getEventManagerEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect((0, _index.getEventManagerEntitiesByConfig)(false)).toBe(_index.EventManagerCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect((0, _index.getEventManagerEntitiesByConfig)(true)).toBe(_index.EventManagerCompanyEntities);
+    });
+    it('EventParticipant is shared between core and company entity sets (event-scoped, not company-scoped)', ()=>{
+        expect((0, _index.getEventManagerEntitiesByConfig)(false)).toContain(_eventparticipantentity.EventParticipant);
+        expect((0, _index.getEventManagerEntitiesByConfig)(true)).toContain(_eventparticipantentity.EventParticipant);
+    });
+});

package/cjs/modules/event-manager.module.spec.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interfaces = require("@flusys/nestjs-shared/interfaces");
+const _eventmanagermodule = require("./event-manager.module");
+const _eventmanagerconstants = require("../config/event-manager.constants");
+const _controllers = require("../controllers");
+const _adapters = require("../adapters");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('EventManagerModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with the event controller registered', ()=>{
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRoot({});
+            expect(dynamicModule.module).toBe(_eventmanagermodule.EventManagerModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                _controllers.EventController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(_eventmanagermodule.EventManagerModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(_eventmanagermodule.EventManagerModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register the EVENT_MANAGER_ADAPTER provider backed by EventManagerAdapter', ()=>{
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRoot({});
+            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === _interfaces.EVENT_MANAGER_ADAPTER);
+            expect(adapterProvider.useClass).toBe(_adapters.EventManagerAdapter);
+        });
+        it('should export EVENT_MANAGER_ADAPTER alongside the base services', ()=>{
+            expect(_eventmanagermodule.EventManagerModule.forRoot({}).exports).toContain(_interfaces.EVENT_MANAGER_ADAPTER);
+        });
+        it('should register an EVENT_MANAGER_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRootAsync({
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should still wire the adapter provider when using async registration', ()=>{
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRootAsync({
+                useFactory: jest.fn()
+            });
+            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === _interfaces.EVENT_MANAGER_ADAPTER);
+            expect(adapterProvider.useClass).toBe(_adapters.EventManagerAdapter);
+        });
+        it('useFactory: builds an EVENT_MANAGER_MODULE_OPTIONS provider merging resolved config', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                foo: 'bar'
+            });
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                foo: 'bar'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createEventManagerOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createEventManagerOptions", jest.fn().mockResolvedValue({
+                        foo: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRootAsync({
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createEventManagerOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                foo: 'from-class'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createEventManagerOptions", jest.fn());
+                }
+            };
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no EVENT_MANAGER_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = _eventmanagermodule.EventManagerModule.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS);
+        });
+    });
+});

package/cjs/services/event-manager-config.service.spec.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventmanagerconfigservice = require("./event-manager-config.service");
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: undefined,
+        config: undefined,
+        ...overrides
+    };
+}
+describe('EventManagerConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns true when bootstrap config enables the company feature', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('returns false when bootstrap config disables the company feature', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults to false when bootstrapAppConfig is missing', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions());
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when not configured', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions());
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(false);
+        });
+        it('returns false when database mode is not configured', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions());
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getDefaultColor', ()=>{
+        it('returns the configured default color', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                config: {
+                    defaultColor: '#FF0000'
+                }
+            }));
+            expect(service.getDefaultColor()).toBe('#FF0000');
+        });
+        it('falls back to the built-in default color', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions());
+            expect(service.getDefaultColor()).toBe('#3B82F6');
+        });
+    });
+    describe('getMaxRecurrenceOccurrences', ()=>{
+        it('returns the configured max occurrences', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions({
+                config: {
+                    maxRecurrenceOccurrences: 50
+                }
+            }));
+            expect(service.getMaxRecurrenceOccurrences()).toBe(50);
+        });
+        it('falls back to the built-in default of 365', ()=>{
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(buildOptions());
+            expect(service.getMaxRecurrenceOccurrences()).toBe(365);
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the raw options object as-is', ()=>{
+            const options = buildOptions({
+                config: {
+                    defaultColor: '#ABCDEF'
+                }
+            });
+            const service = new _eventmanagerconfigservice.EventManagerConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});