@flusys/nestjs-event-manager 3.0.1

package/fesm/services/event.service.js

@@ -0,0 +1,411 @@
+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 { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { RecurrenceType } from '@flusys/nestjs-shared/enums';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
+import { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { In, IsNull } from 'typeorm';
+import { EventManagerConfigService } from './event-manager-config.service';
+import { Event, EventWithCompany, EventParticipant } from '../entities';
+import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
+export class EventService extends RequestScopedApiService {
+    // Abstract implementations
+    resolveEntity() {
+        return this.eventConfig.isCompanyFeatureEnabled() ? EventWithCompany : Event;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    // Override methods
+    async convertSingleDtoToEntity(dto, user) {
+        let entity = {};
+        if ('id' in dto && dto.id && typeof dto.id === 'string') {
+            const existing = await this.repository.findOne({
+                where: {
+                    id: dto.id
+                }
+            });
+            if (!existing) throw new NotFoundException('Event not found');
+            entity = existing;
+        }
+        const merged = {
+            ...entity,
+            title: dto.title ?? entity.title,
+            description: dto.description ?? entity.description,
+            meetingLink: dto.meetingLink ?? entity.meetingLink,
+            startDateTime: dto.startDateTime ?? entity.startDateTime,
+            endDateTime: dto.endDateTime ?? entity.endDateTime,
+            isAllDay: dto.isAllDay ?? entity.isAllDay ?? false,
+            recurrenceType: dto.recurrenceType ?? entity.recurrenceType ?? RecurrenceType.NONE,
+            recurrenceEndDate: dto.recurrenceEndDate ?? entity.recurrenceEndDate,
+            color: dto.color ?? entity.color ?? this.eventConfig.getDefaultColor(),
+            isActive: dto.isActive ?? entity.isActive ?? true,
+            metadata: dto.metadata ?? entity.metadata
+        };
+        if (this.eventConfig.isCompanyFeatureEnabled()) {
+            merged.companyId = user?.companyId ?? null;
+        }
+        if ('participantIds' in dto) {
+            this.pendingParticipantsList.push(dto.participantIds ?? []);
+        }
+        return merged;
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'isActive' && typeof value === 'boolean') {
+                query.andWhere(`${this.entityName}.isActive = :isActive`, {
+                    isActive: value
+                });
+            } else if (key === 'recurrenceType') {
+                query.andWhere(`${this.entityName}.recurrenceType = :recurrenceType`, {
+                    recurrenceType: value
+                });
+            } else if (key === 'participantUserId' && value) {
+                const eventIds = await this.getParticipantEventIds(value);
+                if (eventIds.length > 0) {
+                    query.andWhere(`${this.entityName}.id IN (:...participantEventIds)`, {
+                        participantEventIds: eventIds
+                    });
+                } else {
+                    query.andWhere('1 = 0');
+                }
+            } else {
+                query.andWhere(`${this.entityName}.${key} = :value`, {
+                    value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        this.applyEventCompanyFilter(query, user);
+        return result;
+    }
+    async afterInsertOperation(entities, user, _qr) {
+        for(let i = 0; i < entities.length; i++){
+            const participantIds = this.pendingParticipantsList[i] ?? [];
+            await this.addCreatorAndParticipants(entities[i].id, participantIds, user);
+        }
+        this.pendingParticipantsList = [];
+    }
+    // Public API methods
+    async getEventsForCalendarRange(queryDto, user) {
+        await this.ensureRepositoryInitialized();
+        const query = this.repository.createQueryBuilder('event').where('event.deletedAt IS NULL').andWhere('event.isActive = :isActive', {
+            isActive: queryDto.activeOnly !== false
+        });
+        query.andWhere('(event.startDateTime <= :endDate AND event.endDateTime >= :startDate)', {
+            startDate: queryDto.startDate,
+            endDate: queryDto.endDate
+        });
+        query.orWhere('event.deletedAt IS NULL AND event.recurrenceType != :none AND event.startDateTime <= :endDate AND (event.recurrenceEndDate IS NULL OR event.recurrenceEndDate >= :startDate)', {
+            none: RecurrenceType.NONE,
+            startDate: queryDto.startDate,
+            endDate: queryDto.endDate
+        });
+        this.applyEventCompanyFilter(query, user);
+        if (queryDto.userId) {
+            const eventIds = await this.getParticipantEventIds(queryDto.userId);
+            if (eventIds.length > 0) {
+                query.andWhere('event.id IN (:...eventIds)', {
+                    eventIds
+                });
+            } else {
+                return [];
+            }
+        }
+        const events = await query.getMany();
+        if (queryDto.includeParticipants && events.length > 0) {
+            await this.loadParticipantsForEvents(events);
+        }
+        return this.expandRecurringEvents(events, queryDto.startDate, queryDto.endDate);
+    }
+    async getEventWithParticipants(id, user) {
+        await this.ensureRepositoryInitialized();
+        const query = this.repository.createQueryBuilder('event').where('event.id = :id', {
+            id
+        }).andWhere('event.deletedAt IS NULL');
+        this.applyEventCompanyFilter(query, user);
+        const event = await query.getOne();
+        if (event) {
+            const participantRepo = await this.ensureParticipantRepositoryInitialized();
+            event.participants = await participantRepo.find({
+                where: {
+                    eventId: id,
+                    deletedAt: IsNull()
+                }
+            });
+        }
+        return event;
+    }
+    async addParticipants(eventId, userIds, _user) {
+        await this.ensureRepositoryInitialized();
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        const event = await this.repository.findOne({
+            where: {
+                id: eventId,
+                deletedAt: IsNull()
+            }
+        });
+        if (!event) {
+            throw new NotFoundException('Event not found');
+        }
+        const existingParticipants = await participantRepo.find({
+            where: {
+                eventId,
+                userId: In(userIds),
+                deletedAt: IsNull()
+            }
+        });
+        const existingUserIds = new Set(existingParticipants.map((p)=>p.userId));
+        const newParticipants = userIds.filter((userId)=>!existingUserIds.has(userId)).map((userId)=>({
+                eventId,
+                userId,
+                isOrganizer: false
+            }));
+        if (newParticipants.length === 0) {
+            return existingParticipants;
+        }
+        const created = await participantRepo.save(newParticipants);
+        return [
+            ...existingParticipants,
+            ...created
+        ];
+    }
+    // Private business logic helpers
+    async addCreatorAndParticipants(eventId, participantIds, user) {
+        if (!user?.id) return;
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        const allUserIds = new Set([
+            user.id,
+            ...participantIds
+        ]);
+        const participants = Array.from(allUserIds).map((userId)=>({
+                eventId,
+                userId,
+                isOrganizer: userId === user.id
+            }));
+        await participantRepo.save(participants);
+    }
+    expandRecurringEvents(events, rangeStart, rangeEnd) {
+        const result = [];
+        const maxOccurrences = this.eventConfig.getMaxRecurrenceOccurrences();
+        for (const event of events){
+            if (event.recurrenceType === RecurrenceType.NONE) {
+                result.push(this.toCalendarEvent(event));
+            } else {
+                result.push(...this.generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences));
+            }
+        }
+        return result.sort((a, b)=>new Date(a.startDateTime).getTime() - new Date(b.startDateTime).getTime());
+    }
+    generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences) {
+        const occurrences = [];
+        const eventDuration = new Date(event.endDateTime).getTime() - new Date(event.startDateTime).getTime();
+        const recurrenceEnd = event.recurrenceEndDate ? new Date(event.recurrenceEndDate) : null;
+        const recurrenceType = event.recurrenceType;
+        const recurrenceDays = event.metadata?.recurrenceDays || [
+            new Date(event.startDateTime).getDay()
+        ];
+        let currentStart = new Date(event.startDateTime);
+        let count = 0;
+        if (recurrenceType === RecurrenceType.WEEKLY || recurrenceType === RecurrenceType.BIWEEKLY) {
+            let weekStart = new Date(event.startDateTime);
+            weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+            while(count < maxOccurrences){
+                for (const dayOfWeek of recurrenceDays){
+                    if (count >= maxOccurrences) break;
+                    currentStart = new Date(weekStart);
+                    currentStart.setDate(currentStart.getDate() + dayOfWeek);
+                    currentStart.setHours(new Date(event.startDateTime).getHours());
+                    currentStart.setMinutes(new Date(event.startDateTime).getMinutes());
+                    if (currentStart < new Date(event.startDateTime)) continue;
+                    const shouldBreak = this.shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd);
+                    if (shouldBreak) {
+                        count = maxOccurrences;
+                        break;
+                    }
+                    const occurrence = this.tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, occurrences.length > 0);
+                    if (occurrence) occurrences.push(occurrence);
+                    count++;
+                }
+                const weeksToAdd = recurrenceType === RecurrenceType.BIWEEKLY ? 2 : 1;
+                weekStart.setDate(weekStart.getDate() + 7 * weeksToAdd);
+            }
+        } else {
+            const originalDayOfMonth = new Date(event.startDateTime).getDate();
+            while(count < maxOccurrences){
+                if (this.shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd)) break;
+                const occurrence = this.tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, count > 0);
+                if (occurrence) occurrences.push(occurrence);
+                currentStart = this.getNextOccurrenceDate(currentStart, recurrenceType, originalDayOfMonth);
+                count++;
+            }
+        }
+        return occurrences;
+    }
+    // Private utility helpers
+    async ensureParticipantRepositoryInitialized() {
+        if (!this.participantRepository) {
+            this.participantRepository = await this.dataSourceProvider.getRepository(EventParticipant);
+        }
+        return this.participantRepository;
+    }
+    async getParticipantEventIds(userId) {
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        const results = await participantRepo.createQueryBuilder('ep').select('ep.eventId').where('ep.userId = :userId', {
+            userId
+        }).andWhere('ep.deletedAt IS NULL').getRawMany();
+        return results.map((p)=>p.ep_event_id);
+    }
+    async loadParticipantsForEvents(events) {
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        const eventIds = events.map((e)=>e.id);
+        const participants = await participantRepo.find({
+            where: {
+                eventId: In(eventIds),
+                deletedAt: IsNull()
+            }
+        });
+        const participantsByEvent = new Map();
+        for (const p of participants){
+            const list = participantsByEvent.get(p.eventId) || [];
+            list.push(p);
+            participantsByEvent.set(p.eventId, list);
+        }
+        for (const event of events){
+            event.participants = participantsByEvent.get(event.id) || [];
+        }
+    }
+    applyEventCompanyFilter(query, user) {
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.eventConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'event'
+        }, user);
+    }
+    shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd) {
+        return recurrenceEnd && currentStart > recurrenceEnd || currentStart > rangeEnd;
+    }
+    tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, isRecurrenceInstance) {
+        const currentEnd = new Date(currentStart.getTime() + eventDuration);
+        if (currentEnd >= rangeStart && currentStart <= rangeEnd) {
+            return {
+                ...this.toCalendarEvent(event),
+                id: `${event.id}_${currentStart.toISOString()}`,
+                originalEventId: event.id,
+                isRecurrenceInstance,
+                startDateTime: new Date(currentStart),
+                endDateTime: currentEnd
+            };
+        }
+        return null;
+    }
+    getNextOccurrenceDate(current, recurrenceType, originalDayOfMonth) {
+        const next = new Date(current);
+        switch(recurrenceType){
+            case RecurrenceType.DAILY:
+                next.setDate(next.getDate() + 1);
+                break;
+            case RecurrenceType.MONTHLY:
+                {
+                    const targetDay = originalDayOfMonth ?? current.getDate();
+                    next.setMonth(next.getMonth() + 1);
+                    const lastDayOfMonth = new Date(next.getFullYear(), next.getMonth() + 1, 0).getDate();
+                    next.setDate(Math.min(targetDay, lastDayOfMonth));
+                    break;
+                }
+            default:
+                break;
+        }
+        return next;
+    }
+    // Private transformation helpers
+    toCalendarEvent(event) {
+        return {
+            id: event.id,
+            title: event.title,
+            description: event.description,
+            meetingLink: event.meetingLink,
+            startDateTime: event.startDateTime,
+            endDateTime: event.endDateTime,
+            isAllDay: event.isAllDay,
+            recurrenceType: event.recurrenceType,
+            recurrenceEndDate: event.recurrenceEndDate,
+            color: event.color,
+            isActive: event.isActive,
+            metadata: event.metadata,
+            createdAt: event.createdAt,
+            updatedAt: event.updatedAt,
+            deletedAt: event.deletedAt,
+            createdById: event.createdById,
+            updatedById: event.updatedById,
+            deletedById: event.deletedById,
+            participants: event.participants?.map((p)=>this.toParticipantInfo(p))
+        };
+    }
+    toParticipantInfo(p) {
+        return {
+            id: p.id,
+            eventId: p.eventId,
+            userId: p.userId,
+            status: p.status,
+            isOrganizer: p.isOrganizer,
+            metadata: p.metadata,
+            createdAt: p.createdAt,
+            updatedAt: p.updatedAt,
+            deletedAt: p.deletedAt,
+            createdById: p.createdById,
+            updatedById: p.updatedById,
+            deletedById: p.deletedById
+        };
+    }
+    constructor(cacheManager, utilsService, eventConfig, dataSourceProvider){
+        super('event', null, cacheManager, utilsService, EventService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "eventConfig", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "participantRepository", void 0), _define_property(this, "pendingParticipantsList", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.eventConfig = eventConfig, this.dataSourceProvider = dataSourceProvider, this.participantRepository = null, this.pendingParticipantsList = [];
+    }
+}
+EventService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(EventManagerConfigService)),
+    _ts_param(3, Inject(EventManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof EventManagerConfigService === "undefined" ? Object : EventManagerConfigService,
+        typeof EventManagerDataSourceProvider === "undefined" ? Object : EventManagerDataSourceProvider
+    ])
+], EventService);

package/fesm/services/index.js

@@ -0,0 +1,5 @@
+export * from './event-manager-config.service';
+export * from './event-manager-datasource.provider';
+export * from './event-manager-helper.service';
+export * from './event.service';
+export * from './event-participant.service';

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from './adapters';
+export * from './controllers';
+export * from './services';
+export * from './entities';
+export * from './modules';
+export * from './config';
+export * from './docs';
+export * from './dtos';
+export * from './interfaces';

package/interfaces/event-manager-module.interface.d.ts

@@ -0,0 +1,20 @@
+import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface IEventManagerModuleConfig extends IDataSourceServiceOptions {
+    defaultColor?: string;
+    maxRecurrenceOccurrences?: number;
+}
+export interface EventManagerModuleOptions extends IDynamicModuleConfig {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: IEventManagerModuleConfig;
+}
+export interface EventManagerOptionsFactory extends IModuleOptionsFactory<IEventManagerModuleConfig> {
+    createEventManagerOptions(): Promise<IEventManagerModuleConfig> | IEventManagerModuleConfig;
+}
+export interface EventManagerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
+    bootstrapAppConfig: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<IEventManagerModuleConfig> | IEventManagerModuleConfig;
+    inject?: any[];
+    useClass?: Type<EventManagerOptionsFactory>;
+    useExisting?: Type<EventManagerOptionsFactory>;
+}

package/interfaces/event.interface.d.ts

@@ -0,0 +1,28 @@
+import { ParticipantStatus, RecurrenceType } from '@flusys/nestjs-shared/enums';
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+export interface IEvent extends IIdentity {
+    title: string;
+    description: string | null;
+    meetingLink: string | null;
+    startDateTime: Date;
+    endDateTime: Date;
+    isAllDay: boolean;
+    recurrenceType: RecurrenceType | string;
+    recurrenceEndDate: Date | null;
+    color: string;
+    isActive: boolean;
+    metadata: Record<string, unknown> | null;
+    companyId?: string | null;
+}
+export interface IEventParticipant extends IIdentity {
+    eventId: string;
+    userId: string;
+    status: ParticipantStatus | string;
+    isOrganizer: boolean;
+    metadata: Record<string, unknown> | null;
+}
+export interface ICalendarEvent extends IEvent {
+    originalEventId?: string;
+    isRecurrenceInstance?: boolean;
+    participants?: IEventParticipant[];
+}

package/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event.interface';
+export * from './event-manager-module.interface';

package/modules/event-manager.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { EventManagerModuleAsyncOptions, EventManagerModuleOptions } from '../interfaces';
+export declare class EventManagerModule {
+    static forRoot(options: EventManagerModuleOptions): DynamicModule;
+    static forRootAsync(options: EventManagerModuleAsyncOptions): DynamicModule;
+    private static buildProviders;
+    private static createAsyncProviders;
+}

package/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './event-manager.module';

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@flusys/nestjs-event-manager",
+  "version": "3.0.1",
+  "description": "Event manager module with calendar support and recurrence",
+  "main": "cjs/index.js",
+  "module": "fesm/index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "event-manager",
+    "calendar",
+    "recurrence",
+    "@flusys"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js",
+      "require": "./cjs/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js",
+      "require": "./cjs/controllers/index.js"
+    },
+    "./docs": {
+      "types": "./docs/index.d.ts",
+      "import": "./fesm/docs/index.js",
+      "require": "./cjs/docs/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js",
+      "require": "./cjs/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js",
+      "require": "./cjs/entities/index.js"
+    },
+    "./enums": {
+      "types": "./enums/index.d.ts",
+      "import": "./fesm/enums/index.js",
+      "require": "./cjs/enums/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js",
+      "require": "./cjs/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js",
+      "require": "./cjs/modules/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js",
+      "require": "./cjs/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js",
+      "require": "./*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/config": "^3.0.0 || ^4.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/platform-express": "^10.0.0 || ^11.0.0",
+    "@nestjs/swagger": "^7.0.0 || ^11.0.0",
+    "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
+    "class-transformer": "^0.5.0",
+    "class-validator": "^0.14.0",
+    "typeorm": "^0.3.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "3.0.1",
+    "@flusys/nestjs-shared": "3.0.1"
+  }
+}

package/services/event-manager-config.service.d.ts

@@ -0,0 +1,13 @@
+import { DatabaseMode } from '@flusys/nestjs-core';
+import { IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
+import { EventManagerModuleOptions } from '../interfaces';
+export declare class EventManagerConfigService implements IModuleConfigService {
+    private readonly options;
+    constructor(options: EventManagerModuleOptions);
+    isCompanyFeatureEnabled(): boolean;
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    getDefaultColor(): string;
+    getMaxRecurrenceOccurrences(): number;
+    getOptions(): EventManagerModuleOptions;
+}

package/services/event-manager-datasource.provider.d.ts

@@ -0,0 +1,23 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { Logger } from '@nestjs/common';
+import { Request } from 'express';
+import { DataSource } from 'typeorm';
+import { EventManagerConfigService } from './event-manager-config.service';
+export declare class EventManagerDataSourceProvider extends MultiTenantDataSourceService {
+    private readonly configService;
+    protected readonly logger: Logger;
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    constructor(configService: EventManagerConfigService, request?: Request);
+    private static buildParentOptions;
+    getEnableCompanyFeatureForTenant(tenant?: ITenantDatabaseConfig): boolean;
+    getEventManagerEntities(enableCompanyFeature?: boolean): Promise<any[]>;
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    protected getSingleDataSource(): Promise<DataSource>;
+    protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
+}

package/services/event-manager-helper.service.d.ts

@@ -0,0 +1,27 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { CreateEventOptions, EventResult, ParticipantStatus } from '@flusys/nestjs-shared';
+import { EventManagerConfigService } from './event-manager-config.service';
+import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
+export declare class EventManagerHelperService {
+    private readonly cacheManager;
+    private readonly utilsService;
+    private readonly configService;
+    private readonly dataSourceProvider;
+    private readonly logger;
+    private readonly eventEntityName;
+    private dataSource;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, configService: EventManagerConfigService, dataSourceProvider: EventManagerDataSourceProvider);
+    private getDataSource;
+    private getEventRepository;
+    private getParticipantRepository;
+    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>;
+    private addEventParticipants;
+    private toEventResult;
+    private clearCache;
+}