@flusys/nestjs-event-manager 3.0.1

package/cjs/interfaces/event.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/cjs/interfaces/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./event.interface"), exports);
+_export_star(require("./event-manager-module.interface"), 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/cjs/modules/event-manager.module.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventManagerModule", {
+    enumerable: true,
+    get: function() {
+        return EventManagerModule;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _interfaces = require("@flusys/nestjs-shared/interfaces");
+const _common = require("@nestjs/common");
+const _eventmanagerconstants = require("../config/event-manager.constants");
+const _controllers = require("../controllers");
+const _adapters = require("../adapters");
+const _services = require("../services");
+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;
+}
+const CONTROLLERS = [
+    _controllers.EventController,
+    _controllers.EventParticipantController
+];
+const EXPORTED_SERVICES = [
+    _services.EventManagerConfigService,
+    _services.EventManagerDataSourceProvider,
+    _services.EventManagerHelperService,
+    _services.EventService,
+    _services.EventParticipantService
+];
+const ADAPTER_PROVIDER = {
+    provide: _interfaces.EVENT_MANAGER_ADAPTER,
+    useClass: _adapters.EventManagerAdapter
+};
+let EventManagerModule = class EventManagerModule {
+    static forRoot(options) {
+        return {
+            module: EventManagerModule,
+            global: options.global ?? false,
+            imports: [
+                _modules.CacheModule,
+                _modules.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.buildProviders(options),
+                _adapters.EventManagerAdapter,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                _interfaces.EVENT_MANAGER_ADAPTER
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: EventManagerModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                _modules.CacheModule,
+                _modules.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders(),
+                _adapters.EventManagerAdapter,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                _interfaces.EVENT_MANAGER_ADAPTER
+            ]
+        };
+    }
+    // Private Helpers
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES
+        ];
+        if (options) {
+            providers.unshift({
+                provide: _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS,
+                    useFactory: async (...args)=>({
+                            ...options,
+                            config: await options.useFactory(...args)
+                        }),
+                    inject: options.inject || []
+                }
+            ];
+        }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) return [];
+        const providers = [
+            {
+                provide: _eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createEventManagerOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
+        }
+        return providers;
+    }
+};
+EventManagerModule = _ts_decorate([
+    (0, _common.Module)({})
+], EventManagerModule);

package/cjs/modules/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./event-manager.module"), 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/cjs/services/event-manager-config.service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventManagerConfigService", {
+    enumerable: true,
+    get: function() {
+        return EventManagerConfigService;
+    }
+});
+const _common = require("@nestjs/common");
+const _interfaces = require("../interfaces");
+const _eventmanagerconstants = require("../config/event-manager.constants");
+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);
+    };
+}
+const DEFAULT_COLOR = '#3B82F6';
+const DEFAULT_MAX_RECURRENCE_OCCURRENCES = 365;
+let EventManagerConfigService = class EventManagerConfigService {
+    // IModuleConfigService Implementation
+    isCompanyFeatureEnabled() {
+        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    // Config Getters
+    getDefaultColor() {
+        return this.options.config?.defaultColor ?? DEFAULT_COLOR;
+    }
+    getMaxRecurrenceOccurrences() {
+        return this.options.config?.maxRecurrenceOccurrences ?? DEFAULT_MAX_RECURRENCE_OCCURRENCES;
+    }
+    getOptions() {
+        return this.options;
+    }
+    constructor(options){
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+};
+EventManagerConfigService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)(_eventmanagerconstants.EVENT_MANAGER_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.EventManagerModuleOptions === "undefined" ? Object : _interfaces.EventManagerModuleOptions
+    ])
+], EventManagerConfigService);

package/cjs/services/event-manager-datasource.provider.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventManagerDataSourceProvider", {
+    enumerable: true,
+    get: function() {
+        return EventManagerDataSourceProvider;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _express = require("express");
+const _eventmanagerconfigservice = require("./event-manager-config.service");
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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);
+    };
+}
+let EventManagerDataSourceProvider = class EventManagerDataSourceProvider extends _modules.MultiTenantDataSourceService {
+    // Factory Methods
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    // Feature Flags
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+    }
+    // Entity Management
+    async getEventManagerEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+        const entities = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+        // EventParticipant doesn't need company variant - company context comes from Event
+        return enable ? [
+            entities.EventWithCompany,
+            entities.EventParticipant
+        ] : [
+            entities.Event,
+            entities.EventParticipant
+        ];
+    }
+    // Overrides
+    async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = await this.getEventManagerEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+    async getSingleDataSource() {
+        if (EventManagerDataSourceProvider.singleDataSource?.isInitialized) {
+            return EventManagerDataSourceProvider.singleDataSource;
+        }
+        if (EventManagerDataSourceProvider.singleConnectionLock) {
+            return EventManagerDataSourceProvider.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        if (!config) {
+            throw new _common.InternalServerErrorException('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+        }
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EventManagerDataSourceProvider.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            EventManagerDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            EventManagerDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    async getOrCreateTenantConnection(tenant) {
+        const existing = EventManagerDataSourceProvider.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) {
+            return existing;
+        }
+        const pendingConnection = EventManagerDataSourceProvider.connectionLocks.get(tenant.id);
+        if (pendingConnection) {
+            return pendingConnection;
+        }
+        const config = this.buildTenantDatabaseConfig(tenant);
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        EventManagerDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
+        try {
+            const dataSource = await connectionPromise;
+            EventManagerDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            EventManagerDataSourceProvider.connectionLocks.delete(tenant.id);
+        }
+    }
+    constructor(configService, request){
+        super(EventManagerDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), _define_property(this, "logger", void 0), this.configService = configService, this.logger = new _common.Logger(EventManagerDataSourceProvider.name);
+    }
+};
+_define_property(EventManagerDataSourceProvider, "tenantConnections", new Map());
+_define_property(EventManagerDataSourceProvider, "singleDataSource", null);
+_define_property(EventManagerDataSourceProvider, "tenantsRegistry", new Map());
+_define_property(EventManagerDataSourceProvider, "initialized", false);
+_define_property(EventManagerDataSourceProvider, "connectionLocks", new Map());
+_define_property(EventManagerDataSourceProvider, "singleConnectionLock", null);
+EventManagerDataSourceProvider = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_eventmanagerconfigservice.EventManagerConfigService)),
+    _ts_param(1, (0, _common.Optional)()),
+    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _eventmanagerconfigservice.EventManagerConfigService === "undefined" ? Object : _eventmanagerconfigservice.EventManagerConfigService,
+        typeof _express.Request === "undefined" ? Object : _express.Request
+    ])
+], EventManagerDataSourceProvider);

package/cjs/services/event-manager-helper.service.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventManagerHelperService", {
+    enumerable: true,
+    get: function() {
+        return EventManagerHelperService;
+    }
+});
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _nestjsshared = require("@flusys/nestjs-shared");
+const _eventmanagerconfigservice = require("./event-manager-config.service");
+const _eventmanagerdatasourceprovider = require("./event-manager-datasource.provider");
+const _entities = require("../entities");
+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);
+    };
+}
+let EventManagerHelperService = class EventManagerHelperService {
+    async getDataSource() {
+        if (!this.dataSource) {
+            this.dataSource = await this.dataSourceProvider.getDataSource();
+        }
+        return this.dataSource;
+    }
+    async getEventRepository() {
+        const ds = await this.getDataSource();
+        const EntityClass = this.configService.isCompanyFeatureEnabled() ? _entities.EventWithCompany : _entities.Event;
+        return ds.getRepository(EntityClass);
+    }
+    async getParticipantRepository() {
+        const ds = await this.getDataSource();
+        return ds.getRepository(_entities.EventParticipant);
+    }
+    async createEvent(options) {
+        const repo = await this.getEventRepository();
+        const entity = {
+            title: options.title,
+            description: options.description ?? null,
+            meetingLink: options.meetingLink ?? null,
+            startDateTime: options.startDateTime,
+            endDateTime: options.endDateTime,
+            isAllDay: options.isAllDay ?? false,
+            recurrenceType: options.recurrenceType ?? _nestjsshared.RecurrenceType.NONE,
+            recurrenceEndDate: options.recurrenceEndDate ?? null,
+            color: options.color ?? this.configService.getDefaultColor(),
+            isActive: true,
+            metadata: options.metadata ?? null
+        };
+        if (this.configService.isCompanyFeatureEnabled() && options.companyId) {
+            entity.companyId = options.companyId;
+        }
+        const saved = await repo.save(entity);
+        await this.addEventParticipants(saved.id, options.participantIds ?? [], options.organizerId);
+        await this.clearCache();
+        this.logger.debug(`Event created: ${saved.id} - ${options.title}`);
+        return this.toEventResult(saved);
+    }
+    async addParticipants(eventId, userIds, _companyId) {
+        const eventRepo = await this.getEventRepository();
+        const participantRepo = await this.getParticipantRepository();
+        const event = await eventRepo.findOne({
+            where: {
+                id: eventId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!event) {
+            throw new _common.NotFoundException('Event not found');
+        }
+        const existingParticipants = await participantRepo.find({
+            where: {
+                eventId,
+                userId: (0, _typeorm.In)(userIds),
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        const existingUserIds = new Set(existingParticipants.map((p)=>p.userId));
+        const newParticipants = userIds.filter((userId)=>!existingUserIds.has(userId)).map((userId)=>({
+                eventId,
+                userId,
+                status: _nestjsshared.ParticipantStatus.PENDING,
+                isOrganizer: false
+            }));
+        if (newParticipants.length > 0) {
+            await participantRepo.save(newParticipants);
+            this.logger.debug(`Added ${newParticipants.length} participants to event ${eventId}`);
+        }
+    }
+    async removeParticipant(eventId, userId) {
+        const participantRepo = await this.getParticipantRepository();
+        const participant = await participantRepo.findOne({
+            where: {
+                eventId,
+                userId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (participant) {
+            await participantRepo.softRemove(participant);
+            this.logger.debug(`Removed participant ${userId} from event ${eventId}`);
+        }
+    }
+    async updateParticipantStatus(participantId, status) {
+        const participantRepo = await this.getParticipantRepository();
+        const participant = await participantRepo.findOne({
+            where: {
+                id: participantId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!participant) {
+            throw new _common.NotFoundException('Event participant not found');
+        }
+        participant.status = status;
+        await participantRepo.save(participant);
+        this.logger.debug(`Updated participant ${participantId} status to ${status}`);
+    }
+    async getEventsForUser(userId, startDate, endDate, companyId) {
+        const eventRepo = await this.getEventRepository();
+        const participantRepo = await this.getParticipantRepository();
+        const participantEvents = await participantRepo.createQueryBuilder('ep').select('ep.eventId').where('ep.userId = :userId', {
+            userId
+        }).andWhere('ep.deletedAt IS NULL').getRawMany();
+        const eventIds = participantEvents.map((p)=>p.ep_event_id);
+        if (eventIds.length === 0) {
+            return [];
+        }
+        const query = eventRepo.createQueryBuilder('event').where('event.id IN (:...eventIds)', {
+            eventIds
+        }).andWhere('event.deletedAt IS NULL').andWhere('event.isActive = :isActive', {
+            isActive: true
+        }).andWhere('event.startDateTime <= :endDate', {
+            endDate
+        }).andWhere('event.endDateTime >= :startDate', {
+            startDate
+        });
+        if (this.configService.isCompanyFeatureEnabled() && companyId) {
+            query.andWhere('event.companyId = :companyId', {
+                companyId
+            });
+        }
+        const events = await query.getMany();
+        return events.map((e)=>this.toEventResult(e));
+    }
+    async getEventById(eventId) {
+        const repo = await this.getEventRepository();
+        const event = await repo.findOne({
+            where: {
+                id: eventId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        return event ? this.toEventResult(event) : null;
+    }
+    async addEventParticipants(eventId, participantIds, organizerId) {
+        if (!organizerId && participantIds.length === 0) return;
+        const participantRepo = await this.getParticipantRepository();
+        const allUserIds = new Set([
+            ...organizerId ? [
+                organizerId
+            ] : [],
+            ...participantIds
+        ]);
+        const participants = Array.from(allUserIds).map((userId)=>({
+                eventId,
+                userId,
+                status: _nestjsshared.ParticipantStatus.PENDING,
+                isOrganizer: userId === organizerId
+            }));
+        await participantRepo.save(participants);
+    }
+    toEventResult(event) {
+        const eventExt = 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,
+            companyId: eventExt.companyId ?? null,
+            createdAt: event.createdAt,
+            updatedAt: event.updatedAt
+        };
+    }
+    async clearCache() {
+        await this.utilsService.clearCache(this.eventEntityName, this.cacheManager);
+    }
+    constructor(cacheManager, utilsService, configService, dataSourceProvider){
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "utilsService", void 0);
+        _define_property(this, "configService", void 0);
+        _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "eventEntityName", void 0);
+        _define_property(this, "dataSource", void 0);
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+        this.configService = configService;
+        this.dataSourceProvider = dataSourceProvider;
+        this.logger = new _common.Logger(EventManagerHelperService.name);
+        this.eventEntityName = 'event';
+        this.dataSource = null;
+    }
+};
+EventManagerHelperService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_eventmanagerconfigservice.EventManagerConfigService)),
+    _ts_param(3, (0, _common.Inject)(_eventmanagerdatasourceprovider.EventManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _eventmanagerconfigservice.EventManagerConfigService === "undefined" ? Object : _eventmanagerconfigservice.EventManagerConfigService,
+        typeof _eventmanagerdatasourceprovider.EventManagerDataSourceProvider === "undefined" ? Object : _eventmanagerdatasourceprovider.EventManagerDataSourceProvider
+    ])
+], EventManagerHelperService);