@454creative/easy-events/dist/nestjs-providers.js

A minimal event engine for Node.js and NestJS, wrapping Emmett for lightweight in-process event handling

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SimpleEasyEventsProvider = exports.EnhancedEasyEventsProvider = exports.StorageEngineProvider = exports.ObservabilityEngineProvider = exports.EasyEventsProvider = void 0;
const index_1 = require("./index");
const observability_engine_1 = require("./observability-engine");
const storage_engines_1 = require("./storage-engines");
/**
 * Factory provider for Easy Events with proper error handling and dependency management
 * This addresses the initialization order issues encountered in NestJS applications
 */
exports.EasyEventsProvider = {
    provide: 'EVENTS',
    useFactory: (logger) => {
        try {
            return (0, index_1.createEventsInstance)({
                enableObservability: true,
                enableStorage: true,
                logger
            });
        }
        catch (error) {
            // Fallback to basic events instance
            if (logger) {
                logger.warn('Easy Events: Using fallback events instance due to initialization error');
            }
            else {
                console.warn('Easy Events: Using fallback events instance due to initialization error');
            }
            return (0, index_1.createEventsInstance)();
        }
    },
    inject: ['Logger'] // Optional logger injection
};
/**
 * Observability provider with proper error handling
 * Depends on ConfigService and LoggerService for proper initialization
 */
exports.ObservabilityEngineProvider = {
    provide: 'OBSERVABILITY_ENGINE',
    useFactory: (configService, logger) => {
        try {
            const config = configService?.get('observability') || {};
            const observability = new observability_engine_1.DefaultObservabilityEngine(config);
            if (logger) {
                logger.info('Easy Events: Observability engine provider initialized successfully');
            }
            return observability;
        }
        catch (error) {
            if (logger) {
                logger.warn('Easy Events: Failed to initialize observability engine provider, using default');
            }
            else {
                console.warn('Easy Events: Failed to initialize observability engine provider, using default');
            }
            // Return default observability engine as fallback
            return new observability_engine_1.DefaultObservabilityEngine();
        }
    },
    inject: ['ConfigService', 'Logger'] // Optional dependencies
};
/**
 * Storage engine provider with proper error handling
 * Depends on ConfigService and LoggerService for proper initialization
 */
exports.StorageEngineProvider = {
    provide: 'STORAGE_ENGINE',
    useFactory: (configService, logger) => {
        try {
            // Note: config could be used for storage configuration in the future
            configService?.get('storage');
            const storage = new storage_engines_1.MemoryStorageEngine();
            if (logger) {
                logger.info('Easy Events: Storage engine provider initialized successfully');
            }
            return storage;
        }
        catch (error) {
            if (logger) {
                logger.warn('Easy Events: Failed to initialize storage engine provider, using memory storage');
            }
            else {
                console.warn('Easy Events: Failed to initialize storage engine provider, using memory storage');
            }
            // Return memory storage as fallback
            return new storage_engines_1.MemoryStorageEngine();
        }
    },
    inject: ['ConfigService', 'Logger'] // Optional dependencies
};
/**
 * Enhanced events provider that integrates with observability and storage
 * This provider ensures proper initialization order and error handling
 */
exports.EnhancedEasyEventsProvider = {
    provide: 'ENHANCED_EVENTS',
    useFactory: (observabilityEngine, _storageEngine, logger) => {
        try {
            const events = (0, index_1.createEventsInstance)({
                enableObservability: true,
                enableStorage: true,
                logger
            });
            // Set observability if available
            if (observabilityEngine) {
                events.setObservability(observabilityEngine);
            }
            if (logger) {
                logger.info('Easy Events: Enhanced events provider initialized successfully');
            }
            return events;
        }
        catch (error) {
            if (logger) {
                logger.warn('Easy Events: Failed to initialize enhanced events provider, using basic instance');
            }
            else {
                console.warn('Easy Events: Failed to initialize enhanced events provider, using basic instance');
            }
            // Return basic events instance as fallback
            return (0, index_1.createEventsInstance)();
        }
    },
    inject: ['OBSERVABILITY_ENGINE', 'STORAGE_ENGINE', 'Logger'] // Optional dependencies
};
/**
 * Simple events provider for basic usage without observability/storage
 * This is the most reliable provider for basic event handling
 */
exports.SimpleEasyEventsProvider = {
    provide: 'SIMPLE_EVENTS',
    useFactory: (logger) => {
        try {
            const events = (0, index_1.createEventsInstance)({
                enableObservability: false,
                enableStorage: false,
                logger
            });
            if (logger) {
                logger.info('Easy Events: Simple events provider initialized successfully');
            }
            return events;
        }
        catch (error) {
            if (logger) {
                logger.error('Easy Events: Failed to initialize simple events provider');
            }
            else {
                console.error('Easy Events: Failed to initialize simple events provider');
            }
            // Return basic engine as last resort
            return (0, index_1.createEventsInstance)();
        }
    },
    inject: ['Logger'] // Optional logger injection
};
//# sourceMappingURL=nestjs-providers.js.map