@flusys/nestjs-event-manager 4.1.0 → 5.0.0

package/README.md

@@ -1,66 +1,9 @@
 # @flusys/nestjs-event-manager
 
-> Calendar event management for NestJS — recurrence patterns (DAILY, WEEKLY, BIWEEKLY, MONTHLY), participant tracking with status, company scoping, and a cross-module adapter for dependency-free integration.
+Calendar event management for NestJS — recurrence patterns (DAILY, WEEKLY, BIWEEKLY, MONTHLY), participant tracking with status, and an `EVENT_MANAGER_ADAPTER` injection token for dependency-free cross-module integration.
 
 [![npm version](https://img.shields.io/npm/v/@flusys/nestjs-event-manager.svg)](https://www.npmjs.com/package/@flusys/nestjs-event-manager)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![NestJS](https://img.shields.io/badge/NestJS-11.x-red.svg)](https://nestjs.com/)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg)](https://www.typescriptlang.org/)
-[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18.x-green.svg)](https://nodejs.org/)
-
----
-
-## Table of Contents
-
-- [Overview](#overview)
-- [Features](#features)
-- [Compatibility](#compatibility)
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Module Registration](#module-registration)
-  - [forRoot (Sync)](#forroot-sync)
-  - [forRootAsync (Factory)](#forrootasync-factory)
-- [Configuration Reference](#configuration-reference)
-- [API Endpoints](#api-endpoints)
-- [Entities](#entities)
-- [Recurrence Patterns](#recurrence-patterns)
-- [Participant Status](#participant-status)
-- [Cross-Module Adapter (EVENT_MANAGER_ADAPTER)](#cross-module-adapter-event_manager_adapter)
-- [Exported Services](#exported-services)
-- [Programmatic Usage](#programmatic-usage)
-- [Troubleshooting](#troubleshooting)
-- [License](#license)
-
----
-
-## Overview
-
-`@flusys/nestjs-event-manager` provides a structured calendar event system with rich recurrence support and per-user participant tracking. The module exposes an `EVENT_MANAGER_ADAPTER` injection token so other modules (Notification, Email) can create events without taking a direct dependency on this package.
-
----
-
-## Features
-
-- **Calendar events** — Title, description, meeting link, time range, color, all-day flag
-- **Recurrence engine** — NONE, DAILY, WEEKLY, BIWEEKLY, MONTHLY patterns with configurable end dates and day-of-week sets
-- **Participant tracking** — Per-user status: PENDING, ACCEPTED, DECLINED, TENTATIVE
-- **Organizer designation** — Mark specific participants as event organizer
-- **Company scoping** — Optional `companyId`/`branchId` on events
-- **Cross-module adapter** — `EVENT_MANAGER_ADAPTER` token for creating events without circular imports
-- **REQUEST-scoped services** — Dynamic entity resolution per HTTP request
-- **POST-only RPC** — All endpoints use `POST`
-
----
-
-## Compatibility
-
-| Package | Version |
-|---------|---------|
-| `@flusys/nestjs-core` | `^4.0.0` |
-| `@flusys/nestjs-shared` | `^4.0.0` |
-| `@nestjs/core` | `^11.0.0` |
-| `typeorm` | `^0.3.0` |
-| Node.js | `>= 18.x` |
 
 ---
 
@@ -72,304 +15,184 @@ npm install @flusys/nestjs-event-manager @flusys/nestjs-shared @flusys/nestjs-co
 
 ---
 
-## Quick Start
+## 1. Module Registration
+
+### forRoot (sync)
 
-### Without Company Feature
+#### Mode 1: Single Database
 
 ```typescript
-import { Module } from '@nestjs/common';
 import { EventManagerModule } from '@flusys/nestjs-event-manager';
 
-@Module({
-  imports: [
-    EventManagerModule.forRoot({
-      dataSource: appDataSource,      // TypeORM DataSource instance
-      enableCompanyFeature: false,
-      cacheInstance: hybridCache,     // HybridCache instance
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-### With Company Feature
-
-```typescript
 EventManagerModule.forRoot({
-  dataSource: appDataSource,
-  enableCompanyFeature: true,   // Adds companyId/branchId to Event entity
-  cacheInstance: hybridCache,
-})
+  global: true,
+  includeController: true,
+  bootstrapAppConfig: {
+    databaseMode: 'single',
+    enableCompanyFeature: false,
+  },
+  config: {
+    defaultColor: '#3B82F6', // optional, hex color for new events
+    maxRecurrenceOccurrences: 365, // optional, cap on expanded occurrences
+    defaultDatabaseConfig: {
+      type: 'mysql',
+      host: process.env.DB_HOST,
+      port: Number(process.env.DB_PORT ?? 3306),
+      username: process.env.DB_USER,
+      password: process.env.DB_PASSWORD,
+      database: process.env.DB_NAME,
+    },
+  },
+});
 ```
 
-After registration:
-- `EventController` at `/event-manager/event/*`
-- `EventParticipantController` at `/event-manager/participant/*`
-- `EVENT_MANAGER_ADAPTER` token is available for injection
-
----
-
-## Module Registration
-
-### forRoot (Sync)
+#### Mode 2: Multi-Tenant
 
 ```typescript
 EventManagerModule.forRoot({
-  /** TypeORM DataSource connected to the application database */
-  dataSource: DataSource;
-
-  /** When true, Event entity includes companyId/branchId columns */
-  enableCompanyFeature: boolean;
-
-  /** Cache instance (HybridCache from nestjs-shared) */
-  cacheInstance: HybridCache;
-})
+  global: true,
+  includeController: true,
+  bootstrapAppConfig: {
+    databaseMode: 'multi-tenant',
+    enableCompanyFeature: true,
+  },
+  config: {
+    defaultColor: '#3B82F6',
+    maxRecurrenceOccurrences: 365,
+    tenantDefaultDatabaseConfig: {
+      type: 'mysql',
+      host: process.env.TENANT_DB_HOST,
+      port: Number(process.env.TENANT_DB_PORT ?? 3306),
+      username: process.env.TENANT_DB_USER,
+      password: process.env.TENANT_DB_PASSWORD,
+      database: process.env.TENANT_DB_NAME,
+    },
+    tenants: [
+      { id: 'tenant-a', database: 'tenant_a_db' },
+      { id: 'tenant-b', database: 'tenant_b_db' },
+    ],
+  },
+});
 ```
 
-### forRootAsync (Factory)
+### forRootAsync (factory — recommended)
 
 ```typescript
-import { EnvConfigService } from '@flusys/nestjs-core';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { EventManagerModule, ITenantDatabaseConfig } from '@flusys/nestjs-event-manager';
 
+// Single database
 EventManagerModule.forRootAsync({
+  global: true,
+  bootstrapAppConfig: {
+    databaseMode: 'single',
+    enableCompanyFeature: true,
+  },
   imports: [ConfigModule],
-  inject: [EnvConfigService],
-  useFactory: (envConfig: EnvConfigService) => ({
-    dataSource: envConfig.getDataSource(),
-    enableCompanyFeature: envConfig.isCompanyFeatureEnabled(),
-    cacheInstance: envConfig.getCacheInstance(),
+  useFactory: (cfg: ConfigService) => ({
+    defaultColor: cfg.get('EVENT_DEFAULT_COLOR', '#3B82F6'),
+    maxRecurrenceOccurrences: cfg.get<number>('EVENT_MAX_RECURRENCE', 365),
+    defaultDatabaseConfig: {
+      type: 'mysql',
+      host: cfg.get('DB_HOST'),
+      port: cfg.get<number>('DB_PORT'),
+      username: cfg.get('DB_USER'),
+      password: cfg.get('DB_PASSWORD'),
+      database: cfg.get('DB_NAME'),
+    },
   }),
-})
-```
-
-**Registered providers:**
-
-| Provider | Token | Scope |
-|----------|-------|-------|
-| Module options | `EVENT_MANAGER_MODULE_OPTIONS` | Singleton |
-| `EventManagerConfigService` | class | Singleton |
-| `EventManagerDataSourceProvider` | class | Singleton |
-| `EventService` | class | REQUEST |
-| `EventParticipantService` | class | REQUEST |
-| `EventManagerHelperService` | class | Singleton |
-| `EventManagerAdapter` | `EVENT_MANAGER_ADAPTER` | Singleton |
-
-**Exported:** `EventManagerHelperService`, `EVENT_MANAGER_ADAPTER`, `EventManagerConfigService`
-
----
-
-## Configuration Reference
-
-```typescript
-interface IEventManagerModuleOptions {
-  /** Connected TypeORM DataSource */
-  dataSource: DataSource;
-
-  /** When true, uses company-aware Event entity variant */
-  enableCompanyFeature: boolean;
+  inject: [ConfigService],
+});
 
-  /** HybridCache instance for caching */
-  cacheInstance: HybridCache;
-}
-
-interface IEventManagerModuleAsyncOptions {
-  imports?: ModuleMetadata['imports'];
-  inject?: any[];
-  useFactory: (...args: any[]) => IEventManagerModuleOptions | Promise<IEventManagerModuleOptions>;
-}
-```
-
----
-
-## API Endpoints
-
-All endpoints use **POST** and require JWT authentication.
-
-### Events — `POST /event-manager/event/*`
-
-| Endpoint | Permission | Description |
-|----------|-----------|-------------|
-| `POST /event-manager/event/insert` | `event.create` | Create a new calendar event |
-| `POST /event-manager/event/get-all` | `event.read` | List events with pagination and date filters |
-| `POST /event-manager/event/get/:id` | `event.read` | Get event by ID |
-| `POST /event-manager/event/update` | `event.update` | Update event details |
-| `POST /event-manager/event/delete` | `event.delete` | Delete event (and all participants) |
-| `POST /event-manager/event/get-my-events` | JWT | Get events where current user is a participant |
-| `POST /event-manager/event/get-by-date-range` | `event.read` | Get events within a date range |
-
-**Create event request:**
-
-```json
-POST /event-manager/event/insert
-{
-  "title": "Team Standup",
-  "description": "Daily standup meeting",
-  "startDate": "2026-03-10T09:00:00Z",
-  "endDate": "2026-03-10T09:30:00Z",
-  "isAllDay": false,
-  "color": "#3B82F6",
-  "meetingLink": "https://meet.example.com/standup",
-  "recurrence": {
-    "type": "DAILY",
-    "endDate": "2026-12-31",
-    "daysOfWeek": [1, 2, 3, 4, 5]
+// Multi-tenant
+EventManagerModule.forRootAsync({
+  global: true,
+  bootstrapAppConfig: {
+    databaseMode: 'multi-tenant',
+    enableCompanyFeature: true,
   },
-  "participants": [
-    { "userId": "uuid-1", "isOrganizer": true },
-    { "userId": "uuid-2", "isOrganizer": false }
-  ]
-}
+  imports: [ConfigModule],
+  useFactory: (cfg: ConfigService) => ({
+    defaultColor: cfg.get('EVENT_DEFAULT_COLOR', '#3B82F6'),
+    maxRecurrenceOccurrences: cfg.get<number>('EVENT_MAX_RECURRENCE', 365),
+    tenantDefaultDatabaseConfig: {
+      type: 'mysql',
+      host: cfg.get('TENANT_DB_HOST'),
+      port: cfg.get<number>('TENANT_DB_PORT'),
+      username: cfg.get('TENANT_DB_USER'),
+      password: cfg.get('TENANT_DB_PASSWORD'),
+      database: cfg.get('TENANT_DB_NAME'),
+    },
+    tenants: cfg.get<ITenantDatabaseConfig[]>('TENANTS'),
+  }),
+  inject: [ConfigService],
+});
 ```
 
-### Participants — `POST /event-manager/participant/*`
-
-| Endpoint | Permission | Description |
-|----------|-----------|-------------|
-| `POST /event-manager/participant/insert` | `event.update` | Add participant to event |
-| `POST /event-manager/participant/get-all` | `event.read` | List participants for an event |
-| `POST /event-manager/participant/update-status` | JWT | Update own participation status |
-| `POST /event-manager/participant/delete` | `event.update` | Remove participant from event |
-
-**Update status request:**
-
-```json
-POST /event-manager/participant/update-status
-{
-  "eventId": "uuid",
-  "status": "ACCEPTED"
-}
-```
+**Exported services** (available for injection after registration):
+`EventService`, `EventManagerHelperService`, `EventManagerConfigService`, `EventManagerDataSourceProvider`, `EVENT_MANAGER_ADAPTER`
 
 ---
 
-## Entities
-
-### Core Entities
-
-| Entity | Table | Description |
-|--------|-------|-------------|
-| `Event` | `event_manager_event` | Calendar event with recurrence config |
-| `EventParticipant` | `event_manager_participant` | User participation with status |
-
-### Company Feature Entities (`enableCompanyFeature: true`)
-
-| Entity | Table | Description |
-|--------|-------|-------------|
-| `EventWithCompany` | `event_manager_event` | Same as Event + `companyId` and `branchId` |
+## 2. Entities
 
 ```typescript
-import { EventManagerModule } from '@flusys/nestjs-event-manager';
+import { getEventManagerEntitiesByConfig } from '@flusys/nestjs-event-manager/entities';
 
 TypeOrmModule.forRoot({
   entities: [
-    ...EventManagerModule.getEntities({ enableCompanyFeature: true }),
+    ...getEventManagerEntitiesByConfig(false), // match enableCompanyFeature in bootstrapAppConfig
   ],
-})
-```
-
----
-
-## Recurrence Patterns
-
-| Type | Description |
-|------|-------------|
-| `NONE` | Single occurrence, no recurrence |
-| `DAILY` | Repeats every day (or specific days via `daysOfWeek`) |
-| `WEEKLY` | Repeats every week on the same day |
-| `BIWEEKLY` | Repeats every two weeks |
-| `MONTHLY` | Repeats on the same day of month |
-
-**Recurrence configuration:**
-
-```typescript
-interface IRecurrenceConfig {
-  type: 'NONE' | 'DAILY' | 'WEEKLY' | 'BIWEEKLY' | 'MONTHLY';
-  endDate?: string;         // ISO date — when recurrence stops
-  daysOfWeek?: number[];    // 0=Sunday, 1=Monday, ... 6=Saturday (for DAILY/WEEKLY)
-  interval?: number;        // Custom interval (e.g., every 3 weeks)
-}
+});
 ```
 
----
-
-## Participant Status
+| `enableCompanyFeature` | Entities registered                    |
+| ---------------------- | -------------------------------------- |
+| `false`                | `Event`, `EventParticipant`            |
+| `true`                 | `EventWithCompany`, `EventParticipant` |
 
-| Status | Description |
-|--------|-------------|
-| `PENDING` | Invited but not responded |
-| `ACCEPTED` | Confirmed attendance |
-| `DECLINED` | Declined invitation |
-| `TENTATIVE` | Tentatively attending |
-
-Participants update their own status via `POST /event-manager/participant/update-status`.
+The service resolves the correct entity variant automatically per request.
 
 ---
 
-## Cross-Module Adapter (EVENT_MANAGER_ADAPTER)
-
-The adapter allows other modules to create and manage events without importing `@flusys/nestjs-event-manager` directly. This prevents circular dependencies.
-
-**The interface is defined in `@flusys/nestjs-shared`:**
+## 4. Cross-Module Adapter (EVENT_MANAGER_ADAPTER)
 
-```typescript
-import { IEventManagerAdapter, EVENT_MANAGER_ADAPTER } from '@flusys/nestjs-shared/interfaces';
-```
-
-**Using the adapter in another module:**
+Other modules can create events without importing this package directly. The `IEventManagerAdapter` interface and `EVENT_MANAGER_ADAPTER` token are defined in `@flusys/nestjs-shared`.
 
 ```typescript
-import { IEventManagerAdapter } from '@flusys/nestjs-shared/interfaces';
-import { EVENT_MANAGER_ADAPTER } from '@flusys/nestjs-shared/interfaces';
+import { IEventManagerAdapter, EVENT_MANAGER_ADAPTER } from '@flusys/nestjs-shared';
+import { Optional } from '@nestjs/common';
 
 @Injectable()
-export class MeetingService {
+export class NotificationService {
   constructor(
-    @Optional() @Inject(EVENT_MANAGER_ADAPTER)
+    @Optional()
+    @Inject(EVENT_MANAGER_ADAPTER)
     private readonly eventAdapter?: IEventManagerAdapter,
   ) {}
 
-  async scheduleMeeting(data: { title: string; userId: string; date: Date }): Promise<void> {
+  async scheduleReminder(userId: string, date: string): Promise<void> {
     await this.eventAdapter?.createEvent({
-      title: data.title,
-      startDate: data.date,
-      participants: [{ userId: data.userId, isOrganizer: true }],
+      title: 'Reminder',
+      eventDate: date,
+      startTime: '09:00',
+      endTime: '09:30',
+      participantIds: [userId],
+      organizerId: userId,
     });
   }
 }
 ```
 
-Using `@Optional()` means your module works even when `EventManagerModule` is not registered.
-
-**IEventManagerAdapter interface:**
-
-```typescript
-interface IEventManagerAdapter {
-  createEvent(data: ICreateEventData): Promise<{ id: string }>;
-  updateEvent(id: string, data: Partial<ICreateEventData>): Promise<void>;
-  deleteEvent(id: string): Promise<void>;
-  addParticipant(eventId: string, userId: string): Promise<void>;
-  removeParticipant(eventId: string, userId: string): Promise<void>;
-  updateParticipantStatus(eventId: string, userId: string, status: ParticipantStatus): Promise<void>;
-}
-```
-
----
+The adapter exposes: `createEvent`, `updateParticipantStatus`, `getEventsForUser`, `getEventById`.
 
-## Exported Services
-
-| Service | Description |
-|---------|-------------|
-| `EventManagerHelperService` | Singleton service for programmatic event management from other modules |
-| `EventService` | Full event CRUD (REQUEST-scoped) |
-| `EventParticipantService` | Participant management (REQUEST-scoped) |
-| `EventManagerConfigService` | Exposes runtime config |
-| `EVENT_MANAGER_ADAPTER` | Cross-module adapter token |
+Using `@Optional()` means your module works even when `EventManagerModule` is not registered.
 
 ---
 
-## Programmatic Usage
+## 5. Programmatic Usage (singleton)
 
-Use `EventManagerHelperService` (singleton) for programmatic access from within the same application:
+Use `EventManagerHelperService` (not REQUEST-scoped) for programmatic event creation from background jobs or other singleton services:
 
 ```typescript
 import { EventManagerHelperService } from '@flusys/nestjs-event-manager';
@@ -381,15 +204,13 @@ export class OnboardingService {
     private readonly eventHelper: EventManagerHelperService,
   ) {}
 
-  async scheduleOnboardingCall(userId: string): Promise<void> {
-    const nextWeek = new Date();
-    nextWeek.setDate(nextWeek.getDate() + 7);
-
+  async scheduleCall(userId: string): Promise<void> {
     await this.eventHelper.createEvent({
       title: 'Onboarding Call',
-      startDate: nextWeek,
-      endDate: new Date(nextWeek.getTime() + 30 * 60 * 1000), // +30 min
-      participants: [{ userId, isOrganizer: false }],
+      eventDate: '2026-05-01',
+      startTime: '10:00',
+      endTime: '10:30',
+      organizerId: userId,
     });
   }
 }
@@ -397,39 +218,7 @@ export class OnboardingService {
 
 ---
 
-## Troubleshooting
-
-**`EVENT_MANAGER_ADAPTER` is undefined**
-
-`EventManagerModule` was not registered in the application module. Either register it or use `@Optional()` in the consuming service.
-
----
-
-**Events not filtered by company**
-
-Ensure `enableCompanyFeature: true` is set and the JWT contains `companyId`. Without the company ID in the token, company-scoped queries return all events.
-
----
-
-**Recurrence events not expanding**
-
-`nestjs-event-manager` stores the recurrence configuration as a JSON column — it does not auto-expand recurring events into separate database rows. Your frontend or a separate expansion service is responsible for generating occurrences from the recurrence config.
-
----
-
-**`No metadata for entity`**
-
-Register entities in TypeORM:
-```typescript
-entities: [...EventManagerModule.getEntities({ enableCompanyFeature: true })]
-```
-
----
 
 ## License
 
 MIT © FLUSYS
-
----
-
-> Part of the **FLUSYS** framework — a full-stack monorepo powering Angular 21 + NestJS 11 applications.

package/adapters/event-manager.adapter.d.ts

@@ -4,8 +4,6 @@ export declare class EventManagerAdapter implements IEventManagerAdapter {
     private readonly eventManagerHelper;
     constructor(eventManagerHelper: EventManagerHelperService);
     createEvent(options: CreateEventOptions): Promise<EventResult>;
-    addParticipants(eventId: string, userIds: string[], companyId?: string): Promise<void>;
-    removeParticipant(eventId: string, userId: string): Promise<void>;
     updateParticipantStatus(participantId: string, status: ParticipantStatus): Promise<void>;
     getEventsForUser(userId: string, startDate: Date, endDate: Date, companyId?: string): Promise<EventResult[]>;
     getEventById(eventId: string): Promise<EventResult | null>;

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

@@ -41,17 +41,11 @@ let EventManagerAdapter = class EventManagerAdapter {
     async createEvent(options) {
         return this.eventManagerHelper.createEvent(options);
     }
-    async addParticipants(eventId, userIds, companyId) {
-        await this.eventManagerHelper.addParticipants(eventId, userIds, companyId);
-    }
-    async removeParticipant(eventId, userId) {
-        await this.eventManagerHelper.removeParticipant(eventId, userId);
-    }
     async updateParticipantStatus(participantId, status) {
         await this.eventManagerHelper.updateParticipantStatus(participantId, status);
     }
     async getEventsForUser(userId, startDate, endDate, companyId) {
-        return this.eventManagerHelper.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);

package/cjs/config/message-keys.js

@@ -10,9 +10,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get EVENT_MANAGER_MODULE_MESSAGES () {
-        return EVENT_MANAGER_MODULE_MESSAGES;
-    },
     get EVENT_MESSAGES () {
         return EVENT_MESSAGES;
     },
@@ -21,37 +18,10 @@ _export(exports, {
     }
 });
 const EVENT_MESSAGES = {
-    CREATE_SUCCESS: 'event.create.success',
-    CREATE_MANY_SUCCESS: 'event.create.many.success',
-    GET_SUCCESS: 'event.get.success',
     GET_ALL_SUCCESS: 'event.get.all.success',
-    UPDATE_SUCCESS: 'event.update.success',
-    UPDATE_MANY_SUCCESS: 'event.update.many.success',
-    DELETE_SUCCESS: 'event.delete.success',
-    RESTORE_SUCCESS: 'event.restore.success',
-    NOT_FOUND: 'event.not.found',
-    PUBLISH_SUCCESS: 'event.publish.success',
-    UNPUBLISH_SUCCESS: 'event.unpublish.success',
-    CANCEL_SUCCESS: 'event.cancel.success',
-    UPCOMING_SUCCESS: 'event.upcoming.success',
-    MY_EVENTS_SUCCESS: 'event.my.events.success'
+    NOT_FOUND: 'event.not.found'
 };
 const EVENT_PARTICIPANT_MESSAGES = {
-    CREATE_SUCCESS: 'event.participant.create.success',
-    CREATE_MANY_SUCCESS: 'event.participant.create.many.success',
-    GET_SUCCESS: 'event.participant.get.success',
-    GET_ALL_SUCCESS: 'event.participant.get.all.success',
-    UPDATE_SUCCESS: 'event.participant.update.success',
-    UPDATE_MANY_SUCCESS: 'event.participant.update.many.success',
-    DELETE_SUCCESS: 'event.participant.delete.success',
-    RESTORE_SUCCESS: 'event.participant.restore.success',
     NOT_FOUND: 'event.participant.not.found',
-    REGISTER_SUCCESS: 'event.participant.register.success',
-    UNREGISTER_SUCCESS: 'event.participant.unregister.success',
-    CHECKIN_SUCCESS: 'event.participant.checkin.success',
     STATUS_UPDATE_SUCCESS: 'event.participant.status.update.success'
 };
-const EVENT_MANAGER_MODULE_MESSAGES = {
-    EVENT: EVENT_MESSAGES,
-    EVENT_PARTICIPANT: EVENT_PARTICIPANT_MESSAGES
-};