@gravito/flare 1.0.0-alpha.6 → 1.0.0

package/README.md

@@ -59,7 +59,7 @@ class InvoicePaid extends Notification {
 ### 2. Configure OrbitFlare
 
 ```typescript
-import { PlanetCore } from 'gravito-core'
+import { PlanetCore } from '@gravito/core'
 import { OrbitFlare } from '@gravito/flare'
 import { OrbitSignal } from '@gravito/signal'
 import { OrbitStream } from '@gravito/stream'

package/dist/index.cjs

@@ -1,48 +1,38 @@
+"use strict";
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  SmsChannel: () => SmsChannel,
-  SlackChannel: () => SlackChannel,
-  OrbitFlare: () => OrbitFlare,
-  NotificationManager: () => NotificationManager,
-  Notification: () => Notification,
-  MailChannel: () => MailChannel,
+var index_exports = {};
+__export(index_exports, {
+  BroadcastChannel: () => BroadcastChannel,
   DatabaseChannel: () => DatabaseChannel,
-  BroadcastChannel: () => BroadcastChannel
+  MailChannel: () => MailChannel,
+  Notification: () => Notification,
+  NotificationManager: () => NotificationManager,
+  OrbitFlare: () => OrbitFlare,
+  SlackChannel: () => SlackChannel,
+  SmsChannel: () => SmsChannel
 });
-module.exports = __toCommonJS(exports_src);
+module.exports = __toCommonJS(index_exports);
 
 // src/channels/BroadcastChannel.ts
-class BroadcastChannel {
-  broadcastService;
+var BroadcastChannel = class {
   constructor(broadcastService) {
     this.broadcastService = broadcastService;
   }
@@ -54,12 +44,16 @@ class BroadcastChannel {
     const notifiableId = notifiable.getNotifiableId();
     const notifiableType = notifiable.getNotifiableType?.() || "user";
     const channel = `private-${notifiableType}.${notifiableId}`;
-    await this.broadcastService.broadcast(channel, broadcastNotification.type, broadcastNotification.data);
+    await this.broadcastService.broadcast(
+      channel,
+      broadcastNotification.type,
+      broadcastNotification.data
+    );
   }
-}
+};
+
 // src/channels/DatabaseChannel.ts
-class DatabaseChannel {
-  dbService;
+var DatabaseChannel = class {
   constructor(dbService) {
     this.dbService = dbService;
   }
@@ -75,10 +69,10 @@ class DatabaseChannel {
       data: dbNotification.data
     });
   }
-}
+};
+
 // src/channels/MailChannel.ts
-class MailChannel {
-  mailService;
+var MailChannel = class {
   constructor(mailService) {
     this.mailService = mailService;
   }
@@ -89,10 +83,10 @@ class MailChannel {
     const message = notification.toMail(notifiable);
     await this.mailService.send(message);
   }
-}
+};
+
 // src/channels/SlackChannel.ts
-class SlackChannel {
-  config;
+var SlackChannel = class {
   constructor(config) {
     this.config = config;
   }
@@ -118,10 +112,10 @@ class SlackChannel {
       throw new Error(`Failed to send Slack notification: ${response.statusText}`);
     }
   }
-}
+};
+
 // src/channels/SmsChannel.ts
-class SmsChannel {
-  config;
+var SmsChannel = class {
   constructor(config) {
     this.config = config;
   }
@@ -141,53 +135,89 @@ class SmsChannel {
         throw new Error(`Unsupported SMS provider: ${this.config.provider}`);
     }
   }
+  /**
+   * Send SMS via Twilio.
+   */
   async sendViaTwilio(message) {
     if (!this.config.apiKey || !this.config.apiSecret) {
       throw new Error("Twilio API key and secret are required");
     }
     const accountSid = this.config.apiKey;
     const authToken = this.config.apiSecret;
-    const response = await fetch(`https://api.twilio.com/2010-04-01/Accounts/${accountSid}/Messages.json`, {
-      method: "POST",
-      headers: {
-        Authorization: `Basic ${btoa(`${accountSid}:${authToken}`)}`,
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
-        From: this.config.from || "",
-        To: message.to,
-        Body: message.message
-      })
-    });
+    const response = await fetch(
+      `https://api.twilio.com/2010-04-01/Accounts/${accountSid}/Messages.json`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${btoa(`${accountSid}:${authToken}`)}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          From: this.config.from || "",
+          To: message.to,
+          Body: message.message
+        })
+      }
+    );
     if (!response.ok) {
       const error = await response.text();
       throw new Error(`Failed to send SMS via Twilio: ${error}`);
     }
   }
+  /**
+   * Send SMS via AWS SNS.
+   */
   async sendViaAwsSns(_message) {
     throw new Error("AWS SNS SMS provider not yet implemented. Please install @aws-sdk/client-sns");
   }
-}
+};
+
 // src/Notification.ts
-class Notification {
+var Notification = class {
+  /**
+   * Get mail message (optional).
+   * Implement this if the notification will be sent via the mail channel.
+   */
   toMail(_notifiable) {
     throw new Error("toMail method not implemented");
   }
+  /**
+   * Get database notification (optional).
+   * Implement this if the notification will be stored via the database channel.
+   */
   toDatabase(_notifiable) {
     throw new Error("toDatabase method not implemented");
   }
+  /**
+   * Get broadcast notification (optional).
+   * Implement this if the notification will be sent via the broadcast channel.
+   */
   toBroadcast(_notifiable) {
     throw new Error("toBroadcast method not implemented");
   }
+  /**
+   * Get Slack message (optional).
+   * Implement this if the notification will be sent via the Slack channel.
+   */
   toSlack(_notifiable) {
     throw new Error("toSlack method not implemented");
   }
+  /**
+   * Get SMS message (optional).
+   * Implement this if the notification will be sent via the SMS channel.
+   */
   toSms(_notifiable) {
     throw new Error("toSms method not implemented");
   }
+  /**
+   * Check whether this notification should be queued.
+   */
   shouldQueue() {
     return "queue" in this || "connection" in this || "delay" in this;
   }
+  /**
+   * Get queue configuration.
+   */
   getQueueConfig() {
     if (this.shouldQueue()) {
       const queueable = this;
@@ -199,21 +229,50 @@ class Notification {
     }
     return {};
   }
-}
+};
+
 // src/NotificationManager.ts
-class NotificationManager {
-  core;
-  channels = new Map;
-  queueManager;
+var NotificationManager = class {
   constructor(core) {
     this.core = core;
   }
+  /**
+   * Channel registry.
+   */
+  channels = /* @__PURE__ */ new Map();
+  /**
+   * Queue manager (optional, injected by `orbit-queue`).
+   */
+  queueManager;
+  /**
+   * Register a notification channel.
+   *
+   * @param name - The name of the channel.
+   * @param channel - The channel instance.
+   */
   channel(name, channel) {
     this.channels.set(name, channel);
   }
+  /**
+   * Register the queue manager (called by `orbit-queue`).
+   *
+   * @param manager - The queue manager implementation.
+   */
   setQueueManager(manager) {
     this.queueManager = manager;
   }
+  /**
+   * Send a notification.
+   *
+   * @param notifiable - The recipient of the notification.
+   * @param notification - The notification instance.
+   * @returns A promise that resolves when the notification is sent or queued.
+   *
+   * @example
+   * ```typescript
+   * await notificationManager.send(user, new InvoicePaid(invoice))
+   * ```
+   */
   async send(notifiable, notification) {
     const channels = notification.via(notifiable);
     if (notification.shouldQueue() && this.queueManager) {
@@ -229,11 +288,23 @@ class NotificationManager {
           await this.sendNow(notifiable, notification, channels);
         }
       };
-      await this.queueManager.push(queueJob, queueConfig.queue, queueConfig.connection, queueConfig.delay);
+      await this.queueManager.push(
+        queueJob,
+        queueConfig.queue,
+        queueConfig.connection,
+        queueConfig.delay
+      );
       return;
     }
     await this.sendNow(notifiable, notification, channels);
   }
+  /**
+   * Send immediately (without queue).
+   *
+   * @param notifiable - The recipient.
+   * @param notification - The notification.
+   * @param channels - The list of channels to send via.
+   */
   async sendNow(notifiable, notification, channels) {
     for (const channelName of channels) {
       const channel = this.channels.get(channelName);
@@ -244,10 +315,19 @@ class NotificationManager {
       try {
         await channel.send(notification, notifiable);
       } catch (error) {
-        this.core.logger.error(`[NotificationManager] Failed to send notification via '${channelName}':`, error);
+        this.core.logger.error(
+          `[NotificationManager] Failed to send notification via '${channelName}':`,
+          error
+        );
       }
     }
   }
+  /**
+   * Serialize notification (for queuing).
+   *
+   * @param notification - The notification to serialize.
+   * @returns A plain object representation of the notification.
+   */
   serializeNotification(notification) {
     const data = {};
     for (const [key, value] of Object.entries(notification)) {
@@ -257,9 +337,10 @@ class NotificationManager {
     }
     return data;
   }
-}
+};
+
 // src/OrbitFlare.ts
-class OrbitFlare {
+var OrbitFlare = class _OrbitFlare {
   options;
   constructor(options = {}) {
     this.options = {
@@ -271,9 +352,20 @@ class OrbitFlare {
       ...options
     };
   }
+  /**
+   * Configure OrbitFlare.
+   *
+   * @param options - The OrbitFlare configuration options.
+   * @returns A new OrbitFlare instance.
+   */
   static configure(options = {}) {
-    return new OrbitFlare(options);
+    return new _OrbitFlare(options);
   }
+  /**
+   * Install OrbitFlare into PlanetCore.
+   *
+   * @param core - The PlanetCore instance.
+   */
   async install(core) {
     const manager = new NotificationManager(core);
     if (this.options.enableMail) {
@@ -327,4 +419,15 @@ class OrbitFlare {
     }
     core.logger.info("[OrbitFlare] Installed");
   }
-}
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BroadcastChannel,
+  DatabaseChannel,
+  MailChannel,
+  Notification,
+  NotificationManager,
+  OrbitFlare,
+  SlackChannel,
+  SmsChannel
+});