@flusys/nestjs-event-manager 3.0.1

package/fesm/controllers/event.controller.js

@@ -0,0 +1,219 @@
+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 { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+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 } from '@flusys/nestjs-shared/guards';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { plainToInstance } from 'class-transformer';
+import { BulkAddParticipantsDto, CalendarQueryDto, CalendarEventResponseDto, CreateEventDto, EventParticipantResponseDto, EventResponseDto, UpdateEventDto } from '../dtos';
+import { EVENT_PERMISSIONS } from '../docs';
+import { EventService } from '../services/event.service';
+export class EventController extends createApiController(CreateEventDto, UpdateEventDto, EventResponseDto, {
+    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 data = plainToInstance(CalendarEventResponseDto, events);
+        return {
+            success: true,
+            message: 'Calendar events retrieved successfully',
+            data,
+            meta: {
+                total: data.length,
+                page: 0,
+                pageSize: data.length,
+                count: data.length
+            }
+        };
+    }
+    async getEventWithParticipants(body, user) {
+        const event = await this.eventService.getEventWithParticipants(body.id, user);
+        if (!event) {
+            return {
+                success: false,
+                message: 'Event not found'
+            };
+        }
+        return {
+            success: true,
+            message: 'Event retrieved successfully',
+            data: plainToInstance(EventResponseDto, event)
+        };
+    }
+    async addParticipants(dto, user) {
+        const participants = await this.eventService.addParticipants(dto.eventId, dto.userIds, user);
+        return {
+            success: true,
+            message: 'Participants added successfully',
+            data: plainToInstance(EventParticipantResponseDto, participants)
+        };
+    }
+    constructor(eventService){
+        super(eventService), _define_property(this, "eventService", void 0), this.eventService = eventService;
+    }
+}
+_ts_decorate([
+    Post('calendar'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    HttpCode(HttpStatus.OK),
+    RequirePermission(EVENT_PERMISSIONS.READ),
+    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('get-with-participants'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    HttpCode(HttpStatus.OK),
+    RequirePermission(EVENT_PERMISSIONS.READ),
+    ApiOperation({
+        summary: 'Get event with participants'
+    }),
+    ApiBody({
+        schema: {
+            properties: {
+                id: {
+                    type: 'string',
+                    format: 'uuid'
+                }
+            }
+        }
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Event retrieved successfully',
+        type: SingleResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_param(1, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EventController.prototype, "getEventWithParticipants", null);
+_ts_decorate([
+    Post('add-participants'),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    HttpCode(HttpStatus.OK),
+    RequirePermission(EVENT_PERMISSIONS.UPDATE),
+    ApiOperation({
+        summary: 'Add participants to an event'
+    }),
+    ApiBody({
+        type: BulkAddParticipantsDto
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Participants added successfully',
+        type: SingleResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_param(1, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof BulkAddParticipantsDto === "undefined" ? Object : BulkAddParticipantsDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EventController.prototype, "addParticipants", 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/index.js

@@ -0,0 +1,2 @@
+export * from './event.controller';
+export * from './event-participant.controller';

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

@@ -0,0 +1,128 @@
+/** Schema properties to exclude when company feature is disabled */ const COMPANY_SCHEMA_EXCLUSIONS = [
+    {
+        schemaName: 'EventResponseDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'CalendarEventResponseDto',
+        properties: [
+            'companyId'
+        ]
+    }
+];
+function buildDescription(enableCompanyFeature) {
+    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
+
+Calendar event management with recurrence support${enableCompanyFeature ? ' and multi-tenant capabilities' : ''}.
+
+## Features
+
+### 📅 Event Management
+- Create, read, update, delete events
+- Rich metadata support
+- Meeting link integration
+- Color-coded events${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
+- Add/remove participants
+- Status tracking (pending, accepted, declined, tentative)
+- Organizer designation
+- Bulk participant operations
+
+### 📆 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 \`metadata.recurrenceDays\` array to specify days:
+- 0 = Sunday
+- 1 = Monday
+- 2 = Tuesday
+- 3 = Wednesday
+- 4 = Thursday
+- 5 = Friday
+- 6 = Saturday
+
+Example: \`{ "recurrenceDays": [1, 3, 5] }\` = Monday, Wednesday, Friday
+
+### Recurrence Expansion
+Calendar queries automatically expand recurring events into individual instances.
+Each instance includes:
+- \`isRecurrenceInstance: true\`
+- \`originalEventId\`: Reference to parent event
+- \`recurrenceInstanceDate\`: Specific occurrence date
+${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
+- \`/event-manager/event/get-with-participants\` - Get with participant list
+- \`/event-manager/event/add-participants\` - Add participants
+
+### Participants
+- \`/event-manager/participant/insert\` - Create participant
+- \`/event-manager/participant/get-all\` - List participants
+- \`/event-manager/participant/update-status\` - Update status
+- \`/event-manager/participant/get-by-event\` - Get by event
+- \`/event-manager/participant/get-by-user\` - Get by user
+- \`/event-manager/participant/remove\` - Remove from event
+
+## Getting Started
+
+1. **Authenticate**: Obtain JWT token from /auth/login
+2. **Create Event**: POST to /event-manager/event/insert
+3. **Add Participants**: POST to /event-manager/event/add-participants
+4. **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;
+    return {
+        title: 'Event Manager API',
+        description: buildDescription(enableCompanyFeature),
+        version: '1.0',
+        path: 'api/docs/event-manager',
+        bearerAuth: true,
+        excludeTags: [],
+        excludeSchemaProperties: enableCompanyFeature ? undefined : COMPANY_SCHEMA_EXCLUSIONS
+    };
+}

package/fesm/docs/index.js

@@ -0,0 +1,4 @@
+// Re-export permissions from shared for convenience
+export { EVENT_PERMISSIONS, EVENT_PARTICIPANT_PERMISSIONS } from '@flusys/nestjs-shared';
+// Swagger configuration
+export { eventManagerSwaggerConfig } from './event-manager-swagger.config';

package/fesm/dtos/calendar-query.dto.js

@@ -0,0 +1,168 @@
+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);
+}
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Expose, Type } from 'class-transformer';
+import { IsBoolean, IsDate, IsNotEmpty, IsOptional, IsUUID } from 'class-validator';
+import { EventParticipantResponseDto } from './event-participant.dto';
+export class CalendarQueryDto {
+    constructor(){
+        _define_property(this, "startDate", void 0);
+        _define_property(this, "endDate", void 0);
+        _define_property(this, "includeParticipants", void 0);
+        _define_property(this, "userId", void 0);
+        _define_property(this, "activeOnly", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        description: 'Start date for calendar range',
+        example: '2024-01-01T00:00:00Z'
+    }),
+    IsNotEmpty(),
+    IsDate(),
+    Type(()=>Date),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], CalendarQueryDto.prototype, "startDate", void 0);
+_ts_decorate([
+    ApiProperty({
+        description: 'End date for calendar range',
+        example: '2024-01-31T23:59:59Z'
+    }),
+    IsNotEmpty(),
+    IsDate(),
+    Type(()=>Date),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], CalendarQueryDto.prototype, "endDate", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        description: 'Include participant details',
+        default: false
+    }),
+    IsOptional(),
+    IsBoolean(),
+    _ts_metadata("design:type", Boolean)
+], CalendarQueryDto.prototype, "includeParticipants", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        description: 'Filter by specific user ID'
+    }),
+    IsOptional(),
+    IsUUID(),
+    _ts_metadata("design:type", String)
+], CalendarQueryDto.prototype, "userId", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        description: 'Include only active events',
+        default: true
+    }),
+    IsOptional(),
+    IsBoolean(),
+    _ts_metadata("design:type", Boolean)
+], CalendarQueryDto.prototype, "activeOnly", void 0);
+export class CalendarEventResponseDto {
+    constructor(){
+        _define_property(this, "id", void 0);
+        _define_property(this, "title", void 0);
+        _define_property(this, "description", void 0);
+        _define_property(this, "meetingLink", void 0);
+        _define_property(this, "startDateTime", void 0);
+        _define_property(this, "endDateTime", void 0);
+        _define_property(this, "isAllDay", void 0);
+        _define_property(this, "recurrenceType", void 0);
+        _define_property(this, "color", void 0);
+        _define_property(this, "isActive", void 0);
+        _define_property(this, "originalEventId", void 0);
+        _define_property(this, "isRecurrenceInstance", void 0);
+        _define_property(this, "participants", void 0);
+    }
+}
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], CalendarEventResponseDto.prototype, "id", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], CalendarEventResponseDto.prototype, "title", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Object)
+], CalendarEventResponseDto.prototype, "description", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Object)
+], CalendarEventResponseDto.prototype, "meetingLink", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], CalendarEventResponseDto.prototype, "startDateTime", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], CalendarEventResponseDto.prototype, "endDateTime", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", Boolean)
+], CalendarEventResponseDto.prototype, "isAllDay", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], CalendarEventResponseDto.prototype, "recurrenceType", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], CalendarEventResponseDto.prototype, "color", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", Boolean)
+], CalendarEventResponseDto.prototype, "isActive", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", String)
+], CalendarEventResponseDto.prototype, "originalEventId", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Boolean)
+], CalendarEventResponseDto.prototype, "isRecurrenceInstance", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional({
+        type: ()=>[
+                EventParticipantResponseDto
+            ]
+    }),
+    Type(()=>EventParticipantResponseDto),
+    _ts_metadata("design:type", Array)
+], CalendarEventResponseDto.prototype, "participants", void 0);