@ductape/sdk 0.1.7 → 0.1.8

package/dist/notifications/notifications.service.js

@@ -1,907 +0,0 @@
-"use strict";
-/**
- * NotificationsService - Main Notifications Service Class
- *
- * Provides a unified interface for sending notifications through multiple channels:
- * - Push notifications (Firebase, Expo)
- * - Email (SMTP)
- * - SMS (Twilio, Nexmo, Plivo)
- * - Callbacks (HTTP webhooks)
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationsService = void 0;
-exports.notificationsService = notificationsService;
-const products_service_1 = __importDefault(require("../products/services/products.service"));
-const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
-const logs_service_1 = __importDefault(require("../logs/logs.service"));
-const logs_types_1 = require("../logs/logs.types");
-const processor_utils_1 = require("../processor/utils/processor.utils");
-const cache_manager_1 = require("../cache/cache.manager");
-const sessions_1 = require("../sessions");
-const types_1 = require("./types");
-/**
- * NotificationsService - Send notifications through push, email, SMS, and callbacks
- *
- * @example
- * ```typescript
- * const notifications = new NotificationsService({
- *   workspace_id: 'ws-123',
- *   public_key: 'pk-123',
- *   user_id: 'user-123',
- *   token: 'token-123',
- *   env_type: 'production',
- * });
- *
- * // Send push notification
- * await notifications.push({
- *   product: 'my-product',
- *   env: 'production',
- *   notification: 'alerts:welcome-message',
- *   input: {
- *     device_tokens: ['token1', 'token2'],
- *     title: { name: 'John' },
- *     body: { message: 'Welcome!' },
- *   },
- * });
- *
- * // Send email
- * await notifications.email({
- *   product: 'my-product',
- *   env: 'production',
- *   notification: 'emails:order-confirmation',
- *   input: {
- *     recipients: ['user@example.com'],
- *     subject: { orderId: '12345' },
- *     template: { orderDetails: '...' },
- *   },
- * });
- * ```
- */
-class NotificationsService {
-    /**
-     * Create a new NotificationsService instance
-     * @param config - Configuration for authentication and workspace context
-     */
-    constructor(config) {
-        /** ProductBuilder instances cache (keyed by product tag) */
-        this.productBuilders = new Map();
-        /** LogService instance for logging operations */
-        this.logService = null;
-        /** Current product ID for logging */
-        this.productId = '';
-        /** Cache manager for 3-tier caching */
-        this.cacheManager = null;
-        /** Private keys per product for cache encryption */
-        this.privateKeys = new Map();
-        /** Local cache for cache configurations to avoid repeated API calls */
-        this.cacheConfigCache = new Map();
-        this.config = config;
-        this._privateKey = config.private_key;
-        // Initialize CacheManager if Redis client is provided
-        if (config.redis_client) {
-            this.cacheManager = new cache_manager_1.CacheManager({
-                workspace_id: config.workspace_id,
-                public_key: config.public_key,
-                user_id: config.user_id,
-                token: config.token,
-                env_type: config.env_type,
-                redis_client: config.redis_client,
-            });
-        }
-    }
-    // ==================== INTERNAL HELPERS ====================
-    /**
-     * Create a new ProductBuilder instance
-     */
-    createNewProductBuilder() {
-        return new products_service_1.default({
-            workspace_id: this.config.workspace_id,
-            public_key: this.config.public_key,
-            user_id: this.config.user_id,
-            token: this.config.token,
-            env_type: this.config.env_type,
-        });
-    }
-    /**
-     * Get or create a ProductBuilder instance for the given product tag
-     */
-    async getProductBuilder(productTag) {
-        let builder = this.productBuilders.get(productTag);
-        if (!builder) {
-            builder = this.createNewProductBuilder();
-            await builder.initializeProductByTag(productTag);
-            this.productBuilders.set(productTag, builder);
-            this.productId = builder.fetchProductId() || '';
-        }
-        return builder;
-    }
-    /**
-     * Initialize logging service
-     */
-    initializeLogService() {
-        var _a;
-        if (!this.logService) {
-            this.logService = new logs_service_1.default({
-                product_id: this.productId,
-                workspace_id: this.config.workspace_id,
-                public_key: this.config.public_key,
-                user_id: this.config.user_id,
-                token: this.config.token,
-                env_type: this.config.env_type,
-                workspace_private_key: (_a = this._privateKey) !== null && _a !== void 0 ? _a : undefined,
-            });
-        }
-    }
-    /**
-     * Validate cache tag exists in product and return cache configuration
-     * Uses local in-memory cache to avoid repeated API calls (5 minute TTL)
-     */
-    async validateCache(productTag, cacheTag) {
-        const cacheKey = `${productTag}:${cacheTag}`;
-        const cached = this.cacheConfigCache.get(cacheKey);
-        const now = Date.now();
-        const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-        // Return cached config if still valid
-        if (cached && (now - cached.fetchedAt) < CACHE_TTL) {
-            return { expiry: cached.expiry };
-        }
-        // Fetch from API and cache the result
-        const builder = await this.getProductBuilder(productTag);
-        const cache = await builder.fetchCache(cacheTag);
-        if (!cache) {
-            throw new Error(`Cache configuration '${cacheTag}' does not exist`);
-        }
-        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
-        return { expiry: cache.expiry };
-    }
-    /**
-     * Create a new ProcessorService instance
-     */
-    createNewProcessor() {
-        return new processor_service_1.default({
-            workspace_id: this.config.workspace_id,
-            public_key: this.config.public_key,
-            user_id: this.config.user_id,
-            token: this.config.token,
-            env_type: this.config.env_type,
-            private_key: this._privateKey,
-        });
-    }
-    /**
-     * Parse notification tag to extract notification and message tags
-     * Format: notification_tag:message_tag
-     */
-    parseNotificationTag(tag) {
-        const parts = tag.split(':');
-        if (parts.length !== 2) {
-            throw new Error(`Invalid notification tag format: "${tag}". Expected format: "notification_tag:message_tag"`);
-        }
-        return {
-            notificationTag: parts[0],
-            messageTag: parts[1],
-        };
-    }
-    /**
-     * Build INotificationRequest from channel-specific input
-     */
-    buildNotificationRequest(options) {
-        const request = {};
-        if (options.push_notification) {
-            request.push_notification = {
-                device_tokens: options.push_notification.device_tokens,
-                title: options.push_notification.title,
-                body: options.push_notification.body,
-                data: options.push_notification.data,
-            };
-        }
-        if (options.email) {
-            request.email = {
-                recipients: options.email.recipients,
-                subject: options.email.subject,
-                template: options.email.template,
-            };
-        }
-        if (options.sms) {
-            request.sms = {
-                recipients: options.sms.recipients,
-                body: options.sms.body,
-            };
-        }
-        if (options.callback) {
-            request.callback = {
-                query: options.callback.query,
-                headers: options.callback.headers,
-                params: options.callback.params,
-                body: options.callback.body,
-            };
-        }
-        return request;
-    }
-    // ==================== PUSH NOTIFICATIONS ====================
-    /**
-     * Send a push notification
-     *
-     * @param options - Push notification options
-     * @returns Notification result
-     *
-     * @example
-     * ```typescript
-     * const result = await notifications.push({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   notification: 'alerts:welcome',
-     *   input: {
-     *     device_tokens: ['device-token-1', 'device-token-2'],
-     *     title: { name: 'John' },
-     *     body: { message: 'Welcome to our app!' },
-     *     data: { action: 'open_home' },
-     *   },
-     * });
-     * ```
-     */
-    async push(options) {
-        var _a, _b, _c;
-        const { product, env, notification, input, session, cache } = options;
-        const start = Date.now();
-        const { notificationTag, messageTag } = this.parseNotificationTag(notification);
-        let sessionLogFields = {};
-        let resolvedInput = input;
-        try {
-            await this.getProductBuilder(product);
-            this.initializeLogService();
-            // Store private key for cache operations
-            this.privateKeys.set(product, this._privateKey);
-            // Process session if provided - verify and resolve $Session{} references
-            if (session && this._privateKey) {
-                const productBuilder = await this.getProductBuilder(product);
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(session, this._privateKey, input, env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await productBuilder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                sessionLogFields = sessionResult.logFields;
-                resolvedInput = sessionResult.input;
-            }
-            const processId = (0, processor_utils_1.generateObjectId)();
-            // Check cache for idempotency (prevent duplicate sends with same data)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'push',
-                    input: { notification, device_tokens: input.device_tokens, title: input.title, body: input.body },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add({
-                        process_id: processId,
-                        product_tag: product,
-                        env,
-                        start,
-                        end,
-                        type: logs_types_1.LogEventTypes.NOTIFICATIONS,
-                        name: 'Push notification - cache hit',
-                        message: `Push notification cache hit (${cached.source})`,
-                        data: { notification, cache_source: cached.source },
-                        status: logs_types_1.LogEventStatus.SUCCESS,
-                        cache_tag: cache,
-                        cache_key: cached.key,
-                        cache_status: true,
-                    });
-                    return cached.data;
-                }
-            }
-            const processor = this.createNewProcessor();
-            const notificationInput = {
-                product,
-                env,
-                event: notification,
-                input: {
-                    push_notification: {
-                        device_tokens: resolvedInput.device_tokens,
-                        title: resolvedInput.title,
-                        body: resolvedInput.body,
-                        data: resolvedInput.data,
-                    },
-                },
-                session,
-                cache,
-            };
-            await processor.processNotification(notificationInput);
-            const result = {
-                success: true,
-                channel: types_1.NotificationChannelType.PUSH,
-                messageId: processId,
-            };
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'push',
-                    input: { notification, device_tokens: resolvedInput.device_tokens, title: resolvedInput.title, body: resolvedInput.body },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign({ process_id: processId, product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Push notification sent', message: 'Push notification sent successfully', data: { notification, recipients: resolvedInput.device_tokens.length }, status: logs_types_1.LogEventStatus.SUCCESS }, sessionLogFields));
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign({ process_id: (0, processor_utils_1.generateObjectId)(), product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Push notification failed', message: errorMessage, data: { notification }, status: logs_types_1.LogEventStatus.FAIL }, sessionLogFields));
-            return {
-                success: false,
-                channel: types_1.NotificationChannelType.PUSH,
-                error: errorMessage,
-            };
-        }
-    }
-    // ==================== EMAIL ====================
-    /**
-     * Send an email
-     *
-     * @param options - Email options
-     * @returns Notification result
-     *
-     * @example
-     * ```typescript
-     * const result = await notifications.email({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   notification: 'emails:order-confirmation',
-     *   input: {
-     *     recipients: ['user@example.com', 'admin@example.com'],
-     *     subject: { orderId: '12345' },
-     *     template: {
-     *       customerName: 'John Doe',
-     *       orderTotal: '$99.99',
-     *     },
-     *   },
-     * });
-     * ```
-     */
-    async email(options) {
-        var _a, _b, _c;
-        const { product, env, notification, input, session, cache } = options;
-        const start = Date.now();
-        const { notificationTag, messageTag } = this.parseNotificationTag(notification);
-        let sessionLogFields = {};
-        let resolvedInput = input;
-        try {
-            await this.getProductBuilder(product);
-            this.initializeLogService();
-            // Store private key for cache operations
-            this.privateKeys.set(product, this._privateKey);
-            // Process session if provided - verify and resolve $Session{} references
-            if (session && this._privateKey) {
-                const productBuilder = await this.getProductBuilder(product);
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(session, this._privateKey, input, env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await productBuilder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                sessionLogFields = sessionResult.logFields;
-                resolvedInput = sessionResult.input;
-            }
-            const processId = (0, processor_utils_1.generateObjectId)();
-            // Check cache for idempotency (prevent duplicate sends with same data)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'email',
-                    input: { notification, recipients: input.recipients, subject: input.subject },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add({
-                        process_id: processId,
-                        product_tag: product,
-                        env,
-                        start,
-                        end,
-                        type: logs_types_1.LogEventTypes.NOTIFICATIONS,
-                        name: 'Email - cache hit',
-                        message: `Email cache hit (${cached.source})`,
-                        data: { notification, cache_source: cached.source },
-                        status: logs_types_1.LogEventStatus.SUCCESS,
-                        cache_tag: cache,
-                        cache_key: cached.key,
-                        cache_status: true,
-                    });
-                    return cached.data;
-                }
-            }
-            const processor = this.createNewProcessor();
-            const notificationInput = {
-                product,
-                env,
-                event: notification,
-                input: {
-                    email: {
-                        recipients: resolvedInput.recipients,
-                        subject: resolvedInput.subject,
-                        template: resolvedInput.template,
-                    },
-                },
-                session,
-                cache,
-            };
-            await processor.processNotification(notificationInput);
-            const result = {
-                success: true,
-                channel: types_1.NotificationChannelType.EMAIL,
-                messageId: processId,
-            };
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'email',
-                    input: { notification, recipients: resolvedInput.recipients, subject: resolvedInput.subject },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign({ process_id: processId, product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Email sent', message: 'Email sent successfully', data: { notification, recipients: resolvedInput.recipients.length }, status: logs_types_1.LogEventStatus.SUCCESS }, sessionLogFields));
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign({ process_id: (0, processor_utils_1.generateObjectId)(), product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Email failed', message: errorMessage, data: { notification }, status: logs_types_1.LogEventStatus.FAIL }, sessionLogFields));
-            return {
-                success: false,
-                channel: types_1.NotificationChannelType.EMAIL,
-                error: errorMessage,
-            };
-        }
-    }
-    // ==================== SMS ====================
-    /**
-     * Send an SMS
-     *
-     * @param options - SMS options
-     * @returns Notification result
-     *
-     * @example
-     * ```typescript
-     * const result = await notifications.sms({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   notification: 'sms:verification',
-     *   input: {
-     *     recipients: ['+1234567890', '+0987654321'],
-     *     body: { code: '123456' },
-     *   },
-     * });
-     * ```
-     */
-    async sms(options) {
-        var _a, _b, _c;
-        const { product, env, notification, input, session, cache } = options;
-        const start = Date.now();
-        const { notificationTag, messageTag } = this.parseNotificationTag(notification);
-        let sessionLogFields = {};
-        let resolvedInput = input;
-        try {
-            await this.getProductBuilder(product);
-            this.initializeLogService();
-            // Store private key for cache operations
-            this.privateKeys.set(product, this._privateKey);
-            // Process session if provided - verify and resolve $Session{} references
-            if (session && this._privateKey) {
-                const productBuilder = await this.getProductBuilder(product);
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(session, this._privateKey, input, env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await productBuilder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                sessionLogFields = sessionResult.logFields;
-                resolvedInput = sessionResult.input;
-            }
-            const processId = (0, processor_utils_1.generateObjectId)();
-            // Check cache for idempotency (prevent duplicate sends with same data)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'sms',
-                    input: { notification, recipients: resolvedInput.recipients, body: resolvedInput.body },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign({ process_id: processId, product_tag: product, env,
-                        start,
-                        end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'SMS - cache hit', message: `SMS cache hit (${cached.source})`, data: { notification, cache_source: cached.source }, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: cached.key, cache_status: true }, sessionLogFields));
-                    return cached.data;
-                }
-            }
-            const processor = this.createNewProcessor();
-            const notificationInput = {
-                product,
-                env,
-                event: notification,
-                input: {
-                    sms: {
-                        recipients: resolvedInput.recipients,
-                        body: resolvedInput.body,
-                    },
-                },
-                session,
-                cache,
-            };
-            await processor.processNotification(notificationInput);
-            const result = {
-                success: true,
-                channel: types_1.NotificationChannelType.SMS,
-                messageId: processId,
-            };
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'sms',
-                    input: { notification, recipients: resolvedInput.recipients, body: resolvedInput.body },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign({ process_id: processId, product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'SMS sent', message: 'SMS sent successfully', data: { notification, recipients: resolvedInput.recipients.length }, status: logs_types_1.LogEventStatus.SUCCESS }, sessionLogFields));
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign({ process_id: (0, processor_utils_1.generateObjectId)(), product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'SMS failed', message: errorMessage, data: { notification }, status: logs_types_1.LogEventStatus.FAIL }, sessionLogFields));
-            return {
-                success: false,
-                channel: types_1.NotificationChannelType.SMS,
-                error: errorMessage,
-            };
-        }
-    }
-    // ==================== CALLBACK ====================
-    /**
-     * Send a callback (HTTP webhook)
-     *
-     * @param options - Callback options
-     * @returns Notification result
-     *
-     * @example
-     * ```typescript
-     * const result = await notifications.callback({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   notification: 'webhooks:order-created',
-     *   input: {
-     *     body: {
-     *       orderId: '12345',
-     *       status: 'created',
-     *       timestamp: Date.now(),
-     *     },
-     *     headers: {
-     *       'X-Custom-Header': 'value',
-     *     },
-     *   },
-     * });
-     * ```
-     */
-    async callback(options) {
-        var _a, _b, _c;
-        const { product, env, notification, input, session, cache } = options;
-        const start = Date.now();
-        const { notificationTag, messageTag } = this.parseNotificationTag(notification);
-        let sessionLogFields = {};
-        let resolvedInput = input;
-        try {
-            await this.getProductBuilder(product);
-            this.initializeLogService();
-            // Store private key for cache operations
-            this.privateKeys.set(product, this._privateKey);
-            // Process session if provided - verify and resolve $Session{} references
-            if (session && this._privateKey) {
-                const productBuilder = await this.getProductBuilder(product);
-                const sessionResult = await (0, sessions_1.processSessionForExecution)(session, this._privateKey, input, env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await productBuilder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                sessionLogFields = sessionResult.logFields;
-                resolvedInput = sessionResult.input;
-            }
-            const processId = (0, processor_utils_1.generateObjectId)();
-            // Check cache for idempotency (prevent duplicate sends with same data)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'callback',
-                    input: { notification, body: resolvedInput.body, query: resolvedInput.query },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    const end = Date.now();
-                    (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign({ process_id: processId, product_tag: product, env,
-                        start,
-                        end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Callback - cache hit', message: `Callback cache hit (${cached.source})`, data: { notification, cache_source: cached.source }, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: cached.key, cache_status: true }, sessionLogFields));
-                    return cached.data;
-                }
-            }
-            const processor = this.createNewProcessor();
-            const notificationInput = {
-                product,
-                env,
-                event: notification,
-                input: {
-                    callback: {
-                        query: resolvedInput.query,
-                        headers: resolvedInput.headers,
-                        params: resolvedInput.params,
-                        body: resolvedInput.body,
-                    },
-                },
-                session,
-                cache,
-            };
-            await processor.processNotification(notificationInput);
-            const result = {
-                success: true,
-                channel: types_1.NotificationChannelType.CALLBACK,
-                messageId: processId,
-            };
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(product, cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: product,
-                    component_tag: `${notificationTag}:${messageTag}`,
-                    component_type: 'notification',
-                    operation: 'callback',
-                    input: { notification, body: resolvedInput.body, query: resolvedInput.query },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            const end = Date.now();
-            (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign({ process_id: processId, product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Callback sent', message: 'Callback sent successfully', data: { notification }, status: logs_types_1.LogEventStatus.SUCCESS }, sessionLogFields));
-            return result;
-        }
-        catch (error) {
-            const end = Date.now();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign({ process_id: (0, processor_utils_1.generateObjectId)(), product_tag: product, env,
-                start,
-                end, type: logs_types_1.LogEventTypes.NOTIFICATIONS, name: 'Callback failed', message: errorMessage, data: { notification }, status: logs_types_1.LogEventStatus.FAIL }, sessionLogFields));
-            return {
-                success: false,
-                channel: types_1.NotificationChannelType.CALLBACK,
-                error: errorMessage,
-            };
-        }
-    }
-    // ==================== MULTI-CHANNEL SEND ====================
-    /**
-     * Send notifications to multiple channels at once
-     *
-     * @param options - Multi-channel notification options
-     * @returns Results for each channel
-     *
-     * @example
-     * ```typescript
-     * const result = await notifications.send({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   notification: 'alerts:order-placed',
-     *   push_notification: {
-     *     device_tokens: ['token1'],
-     *     title: { order: 'New Order' },
-     *     body: { message: 'Order #12345 placed' },
-     *   },
-     *   email: {
-     *     recipients: ['user@example.com'],
-     *     subject: { orderId: '12345' },
-     *     template: { orderDetails: '...' },
-     *   },
-     *   sms: {
-     *     recipients: ['+1234567890'],
-     *     body: { message: 'Order #12345 placed' },
-     *   },
-     * });
-     * ```
-     */
-    async send(options) {
-        const results = {
-            success: false,
-            channels: {},
-        };
-        const promises = [];
-        if (options.push_notification) {
-            promises.push(this.push({
-                product: options.product,
-                env: options.env,
-                notification: options.notification,
-                input: options.push_notification,
-                session: options.session,
-                cache: options.cache,
-            }).then((result) => {
-                results.channels.push = result;
-            }));
-        }
-        if (options.email) {
-            promises.push(this.email({
-                product: options.product,
-                env: options.env,
-                notification: options.notification,
-                input: options.email,
-                session: options.session,
-                cache: options.cache,
-            }).then((result) => {
-                results.channels.email = result;
-            }));
-        }
-        if (options.sms) {
-            promises.push(this.sms({
-                product: options.product,
-                env: options.env,
-                notification: options.notification,
-                input: options.sms,
-                session: options.session,
-                cache: options.cache,
-            }).then((result) => {
-                results.channels.sms = result;
-            }));
-        }
-        if (options.callback) {
-            promises.push(this.callback({
-                product: options.product,
-                env: options.env,
-                notification: options.notification,
-                input: options.callback,
-                session: options.session,
-                cache: options.cache,
-            }).then((result) => {
-                results.channels.callback = result;
-            }));
-        }
-        await Promise.all(promises);
-        // Overall success if at least one channel succeeded
-        results.success = Object.values(results.channels).some((channel) => channel === null || channel === void 0 ? void 0 : channel.success);
-        return results;
-    }
-    // ==================== SCHEDULING ====================
-    /**
-     * Schedule a notification to be sent at a later time
-     *
-     * @param options - Notification options with scheduling
-     * @returns Dispatch result with job ID
-     *
-     * @example
-     * ```typescript
-     * const result = await notifications.dispatch({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   notification: 'reminders:payment-due',
-     *   input: {
-     *     push_notification: {
-     *       device_tokens: ['token1'],
-     *       title: { name: 'Payment' },
-     *       body: { message: 'Your payment is due' },
-     *     },
-     *   },
-     *   schedule: {
-     *     start_at: Date.now() + 86400000, // 24 hours from now
-     *   },
-     * });
-     * ```
-     */
-    async dispatch(options) {
-        const { product, env, notification, schedule, retries = 3 } = options;
-        await this.getProductBuilder(product);
-        this.initializeLogService();
-        const processor = this.createNewProcessor();
-        const notificationRequest = this.buildNotificationRequest(options);
-        // TODO: dispatchNotification is not yet implemented in ProcessorService
-        // For now, fall back to immediate processing
-        const notificationInput = {
-            product,
-            env,
-            event: notification,
-            input: notificationRequest,
-            session: options.session,
-            cache: options.cache,
-            retries,
-        };
-        await processor.processNotification(notificationInput);
-        const scheduledAt = (schedule === null || schedule === void 0 ? void 0 : schedule.start_at) ? Number(schedule.start_at) : Date.now();
-        return {
-            job_id: (0, processor_utils_1.generateObjectId)(),
-            status: 'queued',
-            scheduled_at: scheduledAt,
-            recurring: !!(schedule === null || schedule === void 0 ? void 0 : schedule.cron) || !!(schedule === null || schedule === void 0 ? void 0 : schedule.every),
-            next_run_at: (schedule === null || schedule === void 0 ? void 0 : schedule.cron) || (schedule === null || schedule === void 0 ? void 0 : schedule.every) ? scheduledAt : undefined,
-        };
-    }
-}
-exports.NotificationsService = NotificationsService;
-/**
- * Factory function for creating NotificationsService instances
- */
-function notificationsService(config) {
-    return new NotificationsService(config);
-}
-exports.default = NotificationsService;
-//# sourceMappingURL=notifications.service.js.map