@buenojs/bueno 0.8.3 → 0.8.5

package/dist/notification/index.js

@@ -0,0 +1,484 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/notification/types.ts
+function isTemplateRef(value) {
+  return typeof value === "object" && value !== null && "templateId" in value;
+}
+
+// src/notification/service.ts
+class NotificationService {
+  channels = new Map;
+  config;
+  metrics = new Map;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  registerChannel(service) {
+    if (this.channels.has(service.name)) {
+      throw new Error(`Channel already registered: ${service.name}`);
+    }
+    this.channels.set(service.name, service);
+    if (this.config.enableMetrics) {
+      this.metrics.set(service.name, {
+        sent: 0,
+        failed: 0,
+        successRate: 0,
+        avgSendTime: 0,
+        totalSendTime: 0,
+        updatedAt: new Date
+      });
+    }
+  }
+  unregisterChannel(channelName) {
+    this.channels.delete(channelName);
+    this.metrics.delete(channelName);
+  }
+  getChannel(channelName) {
+    return this.channels.get(channelName) || null;
+  }
+  getChannels() {
+    return Array.from(this.channels.keys());
+  }
+  hasChannel(channelName) {
+    return this.channels.has(channelName);
+  }
+  async send(message) {
+    const startTime = Date.now();
+    try {
+      const service = this.channels.get(message.channel);
+      if (!service) {
+        throw new Error(`Channel not registered: ${message.channel}`);
+      }
+      const resolvedMessage = await this._resolveTemplates(message);
+      service.validate(resolvedMessage);
+      const messageId = await service.send(resolvedMessage);
+      if (this.config.enableMetrics) {
+        this._updateMetrics(message.channel, true, Date.now() - startTime);
+      }
+      return messageId;
+    } catch (error) {
+      if (this.config.enableMetrics) {
+        this._updateMetrics(message.channel, false, Date.now() - startTime);
+      }
+      throw error;
+    }
+  }
+  async sendBatch(messages) {
+    const results = [];
+    for (const message of messages) {
+      try {
+        const messageId = await this.send(message);
+        results.push(messageId);
+      } catch (error) {
+        results.push(undefined);
+      }
+    }
+    return results;
+  }
+  async sendNotifiable(notifiable, channel) {
+    if (channel) {
+      const message2 = await notifiable.build(channel);
+      return this.send(message2);
+    }
+    if (notifiable.buildAll) {
+      const messages = await notifiable.buildAll();
+      const results = await this.sendBatch(Object.values(messages).filter((m) => m !== undefined));
+      return results[0];
+    }
+    const message = await notifiable.build();
+    return this.send(message);
+  }
+  async queue(message) {
+    return;
+  }
+  async getChannelHealth(channelName) {
+    const service = this.channels.get(channelName);
+    if (!service)
+      return null;
+    return service.getHealth?.() || {
+      status: "healthy",
+      message: "OK",
+      checkedAt: new Date
+    };
+  }
+  async getHealthStatus() {
+    const health = {};
+    for (const [name] of this.channels) {
+      const channelHealth = await this.getChannelHealth(name);
+      if (channelHealth) {
+        health[name] = channelHealth;
+      }
+    }
+    return health;
+  }
+  getChannelMetrics(channelName) {
+    return this.metrics.get(channelName) || null;
+  }
+  getAllMetrics() {
+    const allMetrics = {};
+    for (const [name, metrics] of this.metrics) {
+      allMetrics[name] = metrics;
+    }
+    return allMetrics;
+  }
+  async _resolveTemplates(message) {
+    const engine = this.config.templateEngine;
+    if (!engine) {
+      this._assertNoTemplateRefs(message);
+      return message;
+    }
+    const channel = message.channel;
+    const msg = { ...message };
+    const resolveField = async (value, defaultFormat) => {
+      if (!isTemplateRef(value))
+        return value;
+      const fmt = value.outputFormat ?? defaultFormat;
+      const variant = value.variant ?? engine.getVariantForChannel(channel);
+      return engine.render(value.templateId, value.data, {
+        variant,
+        outputFormat: fmt
+      });
+    };
+    if (channel === "email") {
+      if (isTemplateRef(msg.html)) {
+        msg.html = await resolveField(msg.html, "html");
+      }
+      if (isTemplateRef(msg.text)) {
+        msg.text = await resolveField(msg.text, "text");
+      }
+    } else if (channel === "sms") {
+      if (isTemplateRef(msg.message)) {
+        msg.message = await resolveField(msg.message, "text");
+      }
+    } else if (channel === "push") {
+      if (isTemplateRef(msg.title)) {
+        msg.title = await resolveField(msg.title, "text");
+      }
+      if (isTemplateRef(msg.body)) {
+        msg.body = await resolveField(msg.body, "text");
+      }
+    }
+    return msg;
+  }
+  _assertNoTemplateRefs(message) {
+    for (const [key, value] of Object.entries(message)) {
+      if (isTemplateRef(value)) {
+        throw new Error(`TemplateRef found in field "${key}" but no templateEngine is configured in NotificationService`);
+      }
+    }
+  }
+  _updateMetrics(channelName, success, duration) {
+    const metrics = this.metrics.get(channelName);
+    if (!metrics)
+      return;
+    if (success) {
+      metrics.sent++;
+      metrics.totalSendTime += duration;
+    } else {
+      metrics.failed++;
+    }
+    const total = metrics.sent + metrics.failed;
+    metrics.successRate = total > 0 ? metrics.sent / total : 0;
+    metrics.avgSendTime = metrics.sent > 0 ? metrics.totalSendTime / metrics.sent : 0;
+    metrics.updatedAt = new Date;
+  }
+}
+function createNotificationService(config) {
+  return new NotificationService(config);
+}
+// src/notification/channels/base.ts
+class BaseChannelService {
+  configSchema;
+  async getHealth() {
+    return {
+      status: "healthy",
+      message: "Channel is operational",
+      checkedAt: new Date
+    };
+  }
+  validateField(value, expectedType, fieldName) {
+    const actualType = typeof value;
+    if (actualType !== expectedType) {
+      throw new Error(`Invalid ${this.name} message: ${fieldName} must be ${expectedType}, got ${actualType}`);
+    }
+  }
+  validateRequired(value, fieldName) {
+    if (value === undefined || value === null) {
+      throw new Error(`Invalid ${this.name} message: ${fieldName} is required`);
+    }
+  }
+}
+// src/notification/channels/email.ts
+class EmailChannelService extends BaseChannelService {
+  name = "email";
+  config;
+  sentCount = 0;
+  failureCount = 0;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  validate(message) {
+    if (typeof message !== "object" || message === null) {
+      throw new Error("Invalid email message: must be an object");
+    }
+    const msg = message;
+    if (msg.channel !== "email") {
+      throw new Error('Invalid email message: channel must be "email"');
+    }
+    if (typeof msg.recipient !== "string" || !msg.recipient.includes("@")) {
+      throw new Error("Invalid email message: recipient must be a valid email");
+    }
+    if (typeof msg.subject !== "string" || msg.subject.length === 0) {
+      throw new Error("Invalid email message: subject is required");
+    }
+    if (!msg.html && !msg.text) {
+      throw new Error("Invalid email message: either html or text must be provided");
+    }
+  }
+  async send(message) {
+    try {
+      if (this.config.dryRun) {
+        console.log(`[EmailChannel] Would send email to: ${message.recipient}`);
+        console.log(`  Subject: ${message.subject}`);
+        this.sentCount++;
+        return this._generateMessageId();
+      }
+      const messageId = this._generateMessageId();
+      console.log(`[EmailChannel] Email sent: ${messageId} to ${message.recipient}`);
+      this.sentCount++;
+      return messageId;
+    } catch (error) {
+      this.failureCount++;
+      throw new Error(`Failed to send email: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getMetrics() {
+    const total = this.sentCount + this.failureCount;
+    return {
+      sent: this.sentCount,
+      failed: this.failureCount,
+      total,
+      successRate: total > 0 ? this.sentCount / total : 0
+    };
+  }
+  _generateMessageId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `${timestamp}.${random}@bueno.local`;
+  }
+}
+// src/notification/channels/sms.ts
+class SMSChannelService extends BaseChannelService {
+  name = "sms";
+  config;
+  sentCount = 0;
+  failureCount = 0;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  validate(message) {
+    if (typeof message !== "object" || message === null) {
+      throw new Error("Invalid SMS message: must be an object");
+    }
+    const msg = message;
+    if (msg.channel !== "sms") {
+      throw new Error('Invalid SMS message: channel must be "sms"');
+    }
+    if (typeof msg.recipient !== "string" || msg.recipient.length === 0) {
+      throw new Error("Invalid SMS message: recipient (phone number) is required");
+    }
+    if (typeof msg.message !== "string" || msg.message.length === 0) {
+      throw new Error("Invalid SMS message: message is required");
+    }
+    if (msg.message.length > 160) {
+      console.warn(`SMS message exceeds 160 characters (${msg.message.length}), will be split`);
+    }
+  }
+  async send(message) {
+    try {
+      if (this.config.dryRun) {
+        console.log(`[SMSChannel] Would send SMS to: ${message.recipient}`);
+        console.log(`  Message: ${message.message.substring(0, 50)}...`);
+        this.sentCount++;
+        return this._generateMessageId();
+      }
+      const messageId = this._generateMessageId();
+      console.log(`[SMSChannel] SMS sent: ${messageId} to ${message.recipient}`);
+      this.sentCount++;
+      return messageId;
+    } catch (error) {
+      this.failureCount++;
+      throw new Error(`Failed to send SMS: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getMetrics() {
+    const total = this.sentCount + this.failureCount;
+    return {
+      sent: this.sentCount,
+      failed: this.failureCount,
+      total,
+      successRate: total > 0 ? this.sentCount / total : 0
+    };
+  }
+  _generateMessageId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `sms_${timestamp}_${random}`;
+  }
+}
+// src/notification/channels/whatsapp.ts
+class WhatsAppChannelService extends BaseChannelService {
+  name = "whatsapp";
+  config;
+  sentCount = 0;
+  failureCount = 0;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  validate(message) {
+    if (typeof message !== "object" || message === null) {
+      throw new Error("Invalid WhatsApp message: must be an object");
+    }
+    const msg = message;
+    if (msg.channel !== "whatsapp") {
+      throw new Error('Invalid WhatsApp message: channel must be "whatsapp"');
+    }
+    if (typeof msg.recipient !== "string" || msg.recipient.length === 0) {
+      throw new Error("Invalid WhatsApp message: recipient (phone number) is required");
+    }
+    if (typeof msg.templateId !== "string" || msg.templateId.length === 0) {
+      throw new Error("Invalid WhatsApp message: templateId is required");
+    }
+  }
+  async send(message) {
+    try {
+      if (this.config.dryRun) {
+        console.log(`[WhatsAppChannel] Would send WhatsApp to: ${message.recipient}`);
+        console.log(`  Template: ${message.templateId}`);
+        console.log(`  Parameters: ${JSON.stringify(message.parameters || {})}`);
+        this.sentCount++;
+        return this._generateMessageId();
+      }
+      const messageId = this._generateMessageId();
+      console.log(`[WhatsAppChannel] WhatsApp sent: ${messageId} to ${message.recipient}`);
+      this.sentCount++;
+      return messageId;
+    } catch (error) {
+      this.failureCount++;
+      throw new Error(`Failed to send WhatsApp: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getMetrics() {
+    const total = this.sentCount + this.failureCount;
+    return {
+      sent: this.sentCount,
+      failed: this.failureCount,
+      total,
+      successRate: total > 0 ? this.sentCount / total : 0
+    };
+  }
+  _generateMessageId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `wa_${timestamp}_${random}`;
+  }
+}
+// src/notification/channels/push.ts
+class PushNotificationChannelService extends BaseChannelService {
+  name = "push";
+  config;
+  sentCount = 0;
+  failureCount = 0;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  validate(message) {
+    if (typeof message !== "object" || message === null) {
+      throw new Error("Invalid push message: must be an object");
+    }
+    const msg = message;
+    if (msg.channel !== "push") {
+      throw new Error('Invalid push message: channel must be "push"');
+    }
+    if (typeof msg.recipient !== "string" || msg.recipient.length === 0) {
+      throw new Error("Invalid push message: recipient (device token) is required");
+    }
+    if (typeof msg.title !== "string" || msg.title.length === 0) {
+      throw new Error("Invalid push message: title is required");
+    }
+    if (typeof msg.body !== "string" || msg.body.length === 0) {
+      throw new Error("Invalid push message: body is required");
+    }
+  }
+  async send(message) {
+    try {
+      if (this.config.dryRun) {
+        console.log(`[PushChannel] Would send push to: ${message.recipient}`);
+        console.log(`  Title: ${message.title}`);
+        console.log(`  Body: ${message.body}`);
+        this.sentCount++;
+        return this._generateMessageId();
+      }
+      const messageId = this._generateMessageId();
+      console.log(`[PushChannel] Push sent: ${messageId} to ${message.recipient}`);
+      this.sentCount++;
+      return messageId;
+    } catch (error) {
+      this.failureCount++;
+      throw new Error(`Failed to send push: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getMetrics() {
+    const total = this.sentCount + this.failureCount;
+    return {
+      sent: this.sentCount,
+      failed: this.failureCount,
+      total,
+      successRate: total > 0 ? this.sentCount / total : 0
+    };
+  }
+  _generateMessageId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `push_${timestamp}_${random}`;
+  }
+}
+export {
+  createNotificationService,
+  WhatsAppChannelService,
+  SMSChannelService,
+  PushNotificationChannelService,
+  NotificationService,
+  EmailChannelService,
+  BaseChannelService
+};