@ductape/sdk 0.0.4 → 0.0.6

package/dist/notifications/notifications.service.js

@@ -0,0 +1,905 @@
+"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() {
+        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,
+            });
+        }
+    }
+    /**
+     * 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