@flusys/nestjs-event-manager 7.0.2 → 8.0.0-beta.1

package/cjs/services/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./event-manager-config.service"), exports);
-_export_star(require("./event-manager-datasource.provider"), exports);
-_export_star(require("./event-manager-helper.service"), exports);
-_export_star(require("./event.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/fesm/adapters/event-manager.adapter.js

@@ -1,55 +0,0 @@
-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 _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Injectable, Inject } from '@nestjs/common';
-import { EventManagerHelperService } from '../services/event-manager-helper.service';
-export class EventManagerAdapter {
-    async createEvent(options) {
-        return this.eventManagerHelper.createEvent(options);
-    }
-    async updateParticipantStatus(participantId, status) {
-        await this.eventManagerHelper.updateParticipantStatus(participantId, status);
-    }
-    async getEventsForUser(userId, startDate, endDate, companyId) {
-        return this.eventManagerHelper.getEventsForUser(userId, startDate.toISOString().split('T')[0], endDate.toISOString().split('T')[0], companyId);
-    }
-    async getEventById(eventId) {
-        return this.eventManagerHelper.getEventById(eventId);
-    }
-    constructor(eventManagerHelper){
-        _define_property(this, "eventManagerHelper", void 0);
-        this.eventManagerHelper = eventManagerHelper;
-    }
-}
-EventManagerAdapter = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(EventManagerHelperService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EventManagerHelperService === "undefined" ? Object : EventManagerHelperService
-    ])
-], EventManagerAdapter);

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

@@ -1,100 +0,0 @@
-import { ParticipantStatus } from '@flusys/nestjs-shared';
-import { EventManagerAdapter } from './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(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', ParticipantStatus.ACCEPTED);
-            expect(mockHelper.updateParticipantStatus).toHaveBeenCalledWith('participant-uuid-1', 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/fesm/config/event-actions.js

@@ -1,10 +0,0 @@
-/**
- * Domain event actions published by the event manager module, alongside the CRUD
- * lifecycle actions every ApiService emits.
- */ export const EVENT_MANAGER_EVENT_ACTIONS = {
-    PARTICIPANT_STATUS_CHANGED: 'participant-status-changed'
-};
-/** Every entity the event manager module publishes under */ export const EVENT_MANAGER_EVENT_ENTITIES = {
-    EVENT: 'event'
-};
-export const EVENT_MANAGER_EVENT_MODULE = 'event-manager';

package/fesm/config/event-manager.constants.js

@@ -1,3 +0,0 @@
-/**
- * Event Manager Module Constants
- */ export const EVENT_MANAGER_MODULE_OPTIONS = 'EVENT_MANAGER_MODULE_OPTIONS';

package/fesm/config/message-keys.js

@@ -1,9 +0,0 @@
-// ==================== EVENT MANAGER MODULE MESSAGE KEYS ====================
-export const EVENT_MESSAGES = {
-    GET_ALL_SUCCESS: 'event.get.all.success',
-    NOT_FOUND: 'event.not.found'
-};
-export const EVENT_PARTICIPANT_MESSAGES = {
-    NOT_FOUND: 'event.participant.not.found',
-    STATUS_UPDATE_SUCCESS: 'event.participant.status.update.success'
-};

package/fesm/controllers/event.controller.js

@@ -1,180 +0,0 @@
-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 _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController } from '@flusys/nestjs-shared/classes';
-import { CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
-import { ListResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
-import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { plainToInstance } from 'class-transformer';
-import { EVENT_MESSAGES, EVENT_PARTICIPANT_MESSAGES } from '../config';
-import { EVENT_PERMISSIONS } from '../docs';
-import { CalendarEventResponseDto, CalendarQueryDto, CreateEventDto, EventParticipantResponseDto, EventResponseDto, UpdateEventDto, UpdateParticipantStatusDto } from '../dtos';
-import { EventService } from '../services/event.service';
-export class EventController extends createApiController(CreateEventDto, UpdateEventDto, EventResponseDto, {
-    entityName: 'event',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                EVENT_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async getCalendarEvents(dto, user) {
-        const events = await this.eventService.getEventsForCalendarRange(dto, user);
-        const plainOptions = {
-            excludeExtraneousValues: true
-        };
-        const data = plainToInstance(CalendarEventResponseDto, events, plainOptions);
-        return {
-            success: true,
-            message: 'Calendar events retrieved successfully',
-            messageKey: EVENT_MESSAGES.GET_ALL_SUCCESS,
-            data,
-            meta: {
-                total: data.length,
-                page: 0,
-                pageSize: data.length,
-                count: data.length
-            }
-        };
-    }
-    async updateParticipantStatus(dto, user) {
-        const participant = await this.eventService.updateParticipantStatus(dto, user);
-        const plainOptions = {
-            excludeExtraneousValues: true
-        };
-        return {
-            success: true,
-            message: 'Participant status updated successfully',
-            messageKey: EVENT_PARTICIPANT_MESSAGES.STATUS_UPDATE_SUCCESS,
-            data: plainToInstance(EventParticipantResponseDto, participant, plainOptions)
-        };
-    }
-    constructor(eventService){
-        super(eventService), _define_property(this, "eventService", void 0), this.eventService = eventService;
-    }
-}
-_ts_decorate([
-    Post('calendar'),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get events for calendar range with recurrence expansion'
-    }),
-    ApiBody({
-        type: CalendarQueryDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Calendar events retrieved successfully',
-        type: ListResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof CalendarQueryDto === "undefined" ? Object : CalendarQueryDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EventController.prototype, "getCalendarEvents", null);
-_ts_decorate([
-    Post('update-participant-status'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    ApiBearerAuth(),
-    HttpCode(HttpStatus.OK),
-    RequirePermission(EVENT_PERMISSIONS.UPDATE),
-    ApiOperation({
-        summary: 'Update participant status (accept/decline/tentative)'
-    }),
-    ApiBody({
-        type: UpdateParticipantStatusDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: SingleResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof UpdateParticipantStatusDto === "undefined" ? Object : UpdateParticipantStatusDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EventController.prototype, "updateParticipantStatus", null);
-EventController = _ts_decorate([
-    ApiTags('Events'),
-    Controller('event-manager/event'),
-    _ts_param(0, Inject(EventService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EventService === "undefined" ? Object : EventService
-    ])
-], EventController);

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

@@ -1,152 +0,0 @@
-import { NotFoundException } from '@nestjs/common';
-import { ParticipantStatus, RecurrenceType } from '@flusys/nestjs-shared/enums';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { EVENT_MESSAGES, EVENT_PARTICIPANT_MESSAGES } from '../config';
-import { EventController } from './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: 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 = buildMockUser();
-    beforeEach(()=>{
-        mockService = {
-            getEventsForCalendarRange: jest.fn(),
-            updateParticipantStatus: jest.fn()
-        };
-        controller = new 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(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: 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: ParticipantStatus.ACCEPTED
-            };
-            const result = await controller.updateParticipantStatus(dto, user);
-            expect(mockService.updateParticipantStatus).toHaveBeenCalledWith(dto, user);
-            expect(result.success).toBe(true);
-            expect(result.messageKey).toBe(EVENT_PARTICIPANT_MESSAGES.STATUS_UPDATE_SUCCESS);
-            expect(result.data).toMatchObject({
-                id: 'participant-uuid-1',
-                status: ParticipantStatus.ACCEPTED
-            });
-        });
-        it('propagates a NotFoundException raised by the service', async ()=>{
-            mockService.updateParticipantStatus.mockRejectedValue(new NotFoundException({
-                message: 'Event participant not found',
-                messageKey: EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
-            }));
-            const dto = {
-                id: 'missing-uuid',
-                status: ParticipantStatus.DECLINED
-            };
-            await expect(controller.updateParticipantStatus(dto, user)).rejects.toThrow(NotFoundException);
-        });
-    });
-});

package/fesm/docs/event-manager-swagger.config.js

@@ -1,118 +0,0 @@
-/** Schema properties to exclude when company feature is disabled */ const COMPANY_SCHEMA_EXCLUSIONS = [
-    {
-        schemaName: 'EventResponseDto',
-        properties: [
-            'companyId'
-        ]
-    },
-    {
-        schemaName: 'CalendarEventResponseDto',
-        properties: [
-            'companyId'
-        ]
-    }
-];
-function buildDescription(enableCompanyFeature, isMultiTenant) {
-    const multiTenantNote = isMultiTenant ? `\n> **Multi-Tenant Mode**: Include \`x-tenant-id\` header to target a specific tenant database.\n` : '';
-    const companyFeatures = enableCompanyFeature ? '\n- **Company-scoped events**' : '';
-    const companyIsolation = enableCompanyFeature ? '\n- **Company isolation**' : '';
-    const multiTenantSection = enableCompanyFeature ? `
-## Multi-Tenant Support
-
-Events are automatically isolated by:
-- **Company ID**: Events belong to specific companies
-- **User Context**: Participants are company members
-
-All queries automatically filter by current user's company context.
-` : '';
-    return `
-# Event Manager API
-${multiTenantNote}
-Calendar event management with recurrence support${enableCompanyFeature ? ' and multi-tenant capabilities' : ''}.
-
-## Features
-
-### 📅 Event Management
-- Create, read, update, delete events
-- Color-coded events
-- All-day event support${companyFeatures}
-
-### 🔄 Recurrence Support
-- **None**: Single occurrence
-- **Daily**: Every day
-- **Weekly**: Specific days of the week
-- **Biweekly**: Every two weeks
-- **Monthly**: Same day each month
-
-### 👥 Participant Management
-- Status tracking (pending, accepted, declined, tentative)
-- Organizer designation
-
-### 📆 Calendar Queries
-- Date range queries
-- Automatic recurrence expansion
-- Filter by user participation
-- Include/exclude participants in response
-
-### 🔒 Security
-- JWT authentication required
-- Permission-based access control${companyIsolation}
-
-## Recurrence Patterns
-
-### Weekly Recurrence
-Use the \`weekDays\` array to specify which days repeat:
-- \`"SUN"\` = Sunday
-- \`"MON"\` = Monday
-- \`"TUE"\` = Tuesday
-- \`"WED"\` = Wednesday
-- \`"THU"\` = Thursday
-- \`"FRI"\` = Friday
-- \`"SAT"\` = Saturday
-
-Example: \`{ "weekDays": ["MON", "WED", "FRI"] }\` = Monday, Wednesday, Friday
-
-### Recurrence Expansion
-Calendar queries automatically expand recurring events into individual instances.
-Each instance includes:
-- \`isRecurrenceInstance: true\`
-- \`originalEventId\`: Reference to parent event
-${multiTenantSection}
-## API Endpoints
-
-All endpoints use POST method (RPC style):
-
-### Events
-- \`/event-manager/event/insert\` - Create event
-- \`/event-manager/event/get/:id\` - Get by ID
-- \`/event-manager/event/get-all\` - List with pagination
-- \`/event-manager/event/update\` - Update event
-- \`/event-manager/event/delete\` - Soft delete
-- \`/event-manager/event/calendar\` - Calendar query with expansion
-
-### Participant Operations (via Event endpoints)
-- \`/event-manager/event/update-participant-status\` - Update status
-
-## Getting Started
-
-1. **Authenticate**: Obtain JWT token from /auth/login
-2. **Create Event**: POST to /event-manager/event/insert
-3. **Query Calendar**: POST to /event-manager/event/calendar with date range
-`;
-}
-/**
- * Event Manager Module Swagger Configuration
- * Use this with setupSwaggerDocs() from @flusys/nestjs-core
- */ export function eventManagerSwaggerConfig(bootstrapConfig) {
-    const enableCompanyFeature = bootstrapConfig?.enableCompanyFeature ?? true;
-    const isMultiTenant = bootstrapConfig?.databaseMode === 'multi-tenant';
-    return {
-        title: 'Event Manager API',
-        description: buildDescription(enableCompanyFeature, isMultiTenant),
-        version: '1.0',
-        path: 'api/docs/event-manager',
-        bearerAuth: true,
-        excludeTags: [],
-        excludeSchemaProperties: enableCompanyFeature ? undefined : COMPANY_SCHEMA_EXCLUSIONS
-    };
-}