@flusys/nestjs-event-manager 3.0.1

package/fesm/entities/event.entity.js

@@ -0,0 +1,133 @@
+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 { RecurrenceType } from '@flusys/nestjs-shared/enums';
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { Column, Entity, Index } from 'typeorm';
+export class Event extends Identity {
+    constructor(...args){
+        super(...args), _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, "recurrenceEndDate", void 0), _define_property(this, "color", void 0), _define_property(this, "isActive", void 0), _define_property(this, "metadata", void 0);
+    }
+}
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Event.prototype, "title", void 0);
+_ts_decorate([
+    Column({
+        type: 'text',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Event.prototype, "description", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 500,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Event.prototype, "meetingLink", void 0);
+_ts_decorate([
+    Column({
+        name: 'start_date_time',
+        type: 'timestamp',
+        nullable: false
+    }),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], Event.prototype, "startDateTime", void 0);
+_ts_decorate([
+    Column({
+        name: 'end_date_time',
+        type: 'timestamp',
+        nullable: false
+    }),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], Event.prototype, "endDateTime", void 0);
+_ts_decorate([
+    Column({
+        name: 'is_all_day',
+        type: 'boolean',
+        nullable: false,
+        default: false
+    }),
+    _ts_metadata("design:type", Boolean)
+], Event.prototype, "isAllDay", void 0);
+_ts_decorate([
+    Column({
+        name: 'recurrence_type',
+        type: 'varchar',
+        length: 20,
+        nullable: false,
+        default: RecurrenceType.NONE
+    }),
+    _ts_metadata("design:type", String)
+], Event.prototype, "recurrenceType", void 0);
+_ts_decorate([
+    Column({
+        name: 'recurrence_end_date',
+        type: 'timestamp',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Event.prototype, "recurrenceEndDate", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 7,
+        nullable: false,
+        default: '#3B82F6'
+    }),
+    _ts_metadata("design:type", String)
+], Event.prototype, "color", void 0);
+_ts_decorate([
+    Column({
+        name: 'is_active',
+        type: 'boolean',
+        nullable: false,
+        default: true
+    }),
+    _ts_metadata("design:type", Boolean)
+], Event.prototype, "isActive", void 0);
+_ts_decorate([
+    Column({
+        type: 'simple-json',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Event.prototype, "metadata", void 0);
+Event = _ts_decorate([
+    Entity({
+        name: 'event'
+    }),
+    Index([
+        'startDateTime',
+        'endDateTime'
+    ]),
+    Index([
+        'isActive'
+    ])
+], Event);

package/fesm/entities/index.js

@@ -0,0 +1,24 @@
+// Entities without company feature
+export * from './event.entity';
+export * from './event-participant.entity';
+// Entities with company feature
+export * from './event-with-company.entity';
+import { Event } from './event.entity';
+import { EventParticipant } from './event-participant.entity';
+import { EventWithCompany } from './event-with-company.entity';
+// Core entities (no company feature)
+export const EventManagerCoreEntities = [
+    Event,
+    EventParticipant
+];
+// Company-specific entities (EventParticipant is event-scoped, not company-scoped)
+export const EventManagerCompanyEntities = [
+    EventWithCompany,
+    EventParticipant
+];
+export function getEventManagerEntitiesByConfig(enableCompanyFeature) {
+    return enableCompanyFeature ? EventManagerCompanyEntities : EventManagerCoreEntities;
+}
+// Base type aliases for backwards compatibility with services
+export { Event as EventBase } from './event.entity';
+export { EventParticipant as EventParticipantBase } from './event-participant.entity';

package/fesm/index.js

@@ -0,0 +1,10 @@
+// Export all event manager module components
+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/fesm/interfaces/event-manager-module.interface.js

@@ -0,0 +1,3 @@
+/**
+ * Async options for EventManagerModule registration
+ */ export { };

package/fesm/interfaces/event.interface.js

@@ -0,0 +1 @@
+export { };

package/fesm/interfaces/index.js

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

package/fesm/modules/event-manager.module.js

@@ -0,0 +1,123 @@
+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;
+}
+import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
+import { EVENT_MANAGER_ADAPTER } from '@flusys/nestjs-shared/interfaces';
+import { Module } from '@nestjs/common';
+import { EVENT_MANAGER_MODULE_OPTIONS } from '../config/event-manager.constants';
+import { EventController, EventParticipantController } from '../controllers';
+import { EventManagerAdapter } from '../adapters';
+import { EventManagerConfigService, EventManagerDataSourceProvider, EventManagerHelperService, EventParticipantService, EventService } from '../services';
+const CONTROLLERS = [
+    EventController,
+    EventParticipantController
+];
+const EXPORTED_SERVICES = [
+    EventManagerConfigService,
+    EventManagerDataSourceProvider,
+    EventManagerHelperService,
+    EventService,
+    EventParticipantService
+];
+const ADAPTER_PROVIDER = {
+    provide: EVENT_MANAGER_ADAPTER,
+    useClass: EventManagerAdapter
+};
+export class EventManagerModule {
+    static forRoot(options) {
+        return {
+            module: EventManagerModule,
+            global: options.global ?? false,
+            imports: [
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.buildProviders(options),
+                EventManagerAdapter,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                EVENT_MANAGER_ADAPTER
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: EventManagerModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders(),
+                EventManagerAdapter,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                EVENT_MANAGER_ADAPTER
+            ]
+        };
+    }
+    // Private Helpers
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES
+        ];
+        if (options) {
+            providers.unshift({
+                provide: EVENT_MANAGER_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: 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: 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([
+    Module({})
+], EventManagerModule);

package/fesm/modules/index.js

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

package/fesm/services/event-manager-config.service.js

@@ -0,0 +1,66 @@
+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 { Inject, Injectable } from '@nestjs/common';
+import { EventManagerModuleOptions } from '../interfaces';
+import { EVENT_MANAGER_MODULE_OPTIONS } from '../config/event-manager.constants';
+const DEFAULT_COLOR = '#3B82F6';
+const DEFAULT_MAX_RECURRENCE_OCCURRENCES = 365;
+export 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([
+    Injectable(),
+    _ts_param(0, Inject(EVENT_MANAGER_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EventManagerModuleOptions === "undefined" ? Object : EventManagerModuleOptions
+    ])
+], EventManagerConfigService);

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

@@ -0,0 +1,130 @@
+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 { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, InternalServerErrorException, Logger, Optional, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { Request } from 'express';
+import { EventManagerConfigService } from './event-manager-config.service';
+export class EventManagerDataSourceProvider extends 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 import('../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 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 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([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(EventManagerConfigService)),
+    _ts_param(1, Optional()),
+    _ts_param(1, Inject(REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof EventManagerConfigService === "undefined" ? Object : EventManagerConfigService,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], EventManagerDataSourceProvider);