@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/notifications/index.js

@@ -0,0 +1,741 @@
+// src/notifications/Notification.ts
+var Notification = class {
+  /**
+   * Whether this notification should be queued.
+   */
+  static shouldQueue = false;
+  /**
+   * The queue name for this notification.
+   */
+  static queue;
+  /**
+   * Delay in milliseconds before sending.
+   */
+  static delay;
+  /**
+   * Unique notification ID.
+   */
+  id;
+  /**
+   * When the notification was created.
+   */
+  createdAt;
+  constructor() {
+    this.id = this.generateId();
+    this.createdAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Get the notification type (default: class name).
+   */
+  get type() {
+    return this.constructor.name;
+  }
+  /**
+   * Check if the notification should be sent to the given notifiable.
+   * Override to add custom logic.
+   */
+  shouldSend(_notifiable) {
+    return true;
+  }
+  /**
+   * Generate a unique notification ID.
+   */
+  generateId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `notif_${timestamp}${random}`;
+  }
+  /**
+   * Get static queue configuration.
+   */
+  static getQueueConfig() {
+    return {
+      shouldQueue: this.shouldQueue,
+      queue: this.queue,
+      delay: this.delay
+    };
+  }
+};
+
+// src/queue/Job.ts
+import { randomBytes } from "crypto";
+
+// src/container/Container.ts
+var globalContainer = null;
+function getContainer() {
+  if (!globalContainer) {
+    throw new Error("Container not initialized. Call setContainer() first.");
+  }
+  return globalContainer;
+}
+
+// src/queue/Job.ts
+var globalDriver = null;
+function generateJobId() {
+  return randomBytes(16).toString("hex");
+}
+var Job = class {
+  /**
+   * The queue this job should be dispatched to.
+   * @default 'default'
+   */
+  static queue = "default";
+  /**
+   * Maximum number of times the job should be attempted.
+   * @default 3
+   */
+  static maxAttempts = 3;
+  /**
+   * Backoff strategy for retries.
+   * - 'exponential': 2^attempt * 1000ms (1s, 2s, 4s, 8s, ...)
+   * - 'linear': attempt * 1000ms (1s, 2s, 3s, 4s, ...)
+   * - number: fixed delay in milliseconds
+   * @default 'exponential'
+   */
+  static backoff = "exponential";
+  make(key) {
+    return getContainer().make(key);
+  }
+  /**
+   * Dispatch the job to the queue.
+   *
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options
+   */
+  static async dispatch(payload, options = {}) {
+    const driver = globalDriver;
+    if (!driver) {
+      throw new Error("Queue driver not configured. Call setQueueDriver() first.");
+    }
+    const jobId = generateJobId();
+    const now = /* @__PURE__ */ new Date();
+    const delay = options.delay ?? 0;
+    const job = {
+      id: jobId,
+      name: this.name,
+      payload,
+      queue: options.queue ?? this.queue,
+      attempts: 0,
+      maxAttempts: options.maxAttempts ?? this.maxAttempts,
+      availableAt: new Date(now.getTime() + delay),
+      createdAt: now,
+      reservedAt: null
+    };
+    await driver.push(job);
+    return jobId;
+  }
+  /**
+   * Dispatch the job after a delay.
+   *
+   * @param delayMs - Delay in milliseconds
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options (delay is overridden)
+   */
+  static async dispatchAfter(delayMs, payload, options = {}) {
+    return this.dispatch(payload, { ...options, delay: delayMs });
+  }
+  /**
+   * Calculate the retry delay based on backoff strategy.
+   */
+  static calculateRetryDelay(attempts) {
+    if (typeof this.backoff === "number") {
+      return this.backoff;
+    }
+    if (this.backoff === "linear") {
+      return attempts * 1e3;
+    }
+    return Math.pow(2, attempts) * 1e3;
+  }
+};
+var jobRegistry = /* @__PURE__ */ new Map();
+function registerJob(jobClass) {
+  jobRegistry.set(jobClass.name, jobClass);
+}
+
+// src/notifications/NotificationManager.ts
+var NotificationManager = class {
+  channels = /* @__PURE__ */ new Map();
+  channelFactories = /* @__PURE__ */ new Map();
+  resolvedChannels = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    if (options.channels) {
+      for (const [name, channel] of Object.entries(options.channels)) {
+        this.registerChannel(name, channel);
+      }
+    }
+    if (options.channelFactories) {
+      for (const [name, factory] of Object.entries(options.channelFactories)) {
+        this.registerChannelFactory(name, factory);
+      }
+    }
+  }
+  /**
+   * Register a notification channel.
+   */
+  registerChannel(name, channel) {
+    this.channels.set(name, channel);
+    return this;
+  }
+  /**
+   * Register a notification channel factory.
+   */
+  registerChannelFactory(name, factory) {
+    this.channelFactories.set(name, factory);
+    return this;
+  }
+  /**
+   * Get a notification channel by name.
+   */
+  channel(name) {
+    const resolved = this.resolvedChannels.get(name);
+    if (resolved) {
+      return resolved;
+    }
+    const channel = this.channels.get(name);
+    if (channel) {
+      return channel;
+    }
+    const factory = this.channelFactories.get(name);
+    if (factory) {
+      const created = factory({});
+      this.resolvedChannels.set(name, created);
+      return created;
+    }
+    throw new Error(`Notification channel "${name}" not found`);
+  }
+  /**
+   * Check if a channel is registered.
+   */
+  hasChannel(name) {
+    return this.channels.has(name) || this.channelFactories.has(name) || this.resolvedChannels.has(name);
+  }
+  /**
+   * Get all registered channel names.
+   */
+  getChannelNames() {
+    const names = /* @__PURE__ */ new Set([
+      ...this.channels.keys(),
+      ...this.channelFactories.keys(),
+      ...this.resolvedChannels.keys()
+    ]);
+    return Array.from(names);
+  }
+  /**
+   * Send a notification to a notifiable entity.
+   * Respects queue configuration on the notification class.
+   */
+  async send(notifiable, notification) {
+    const NotificationClass = notification.constructor;
+    const queueConfig = NotificationClass.getQueueConfig?.() ?? {
+      shouldQueue: false
+    };
+    if (queueConfig.shouldQueue) {
+      await this.queue(notifiable, notification, queueConfig);
+    } else {
+      await this.sendNow(notifiable, notification);
+    }
+  }
+  /**
+   * Send a notification immediately (bypasses queue).
+   */
+  async sendNow(notifiable, notification) {
+    const shouldSend = await notification.shouldSend(notifiable);
+    if (!shouldSend) {
+      return;
+    }
+    const viaChannels = notification.via(notifiable);
+    await Promise.all(
+      viaChannels.map(async (channelName) => {
+        try {
+          const channel = this.channel(channelName);
+          await channel.send(notifiable, notification);
+        } catch (error) {
+          console.error(
+            `Failed to send notification via ${channelName}:`,
+            error
+          );
+          throw error;
+        }
+      })
+    );
+  }
+  /**
+   * Queue a notification for later delivery.
+   */
+  async queue(notifiable, notification, queueConfig) {
+    const job = this.createNotificationJob();
+    registerJob(job);
+    const payload = {
+      notifiableData: this.serializeNotifiable(notifiable),
+      notificationData: this.serializeNotification(notification),
+      notificationType: notification.type
+    };
+    if (queueConfig.delay) {
+      await job.dispatchAfter(queueConfig.delay, payload, {
+        queue: queueConfig.queue
+      });
+    } else {
+      await job.dispatch(payload, { queue: queueConfig.queue });
+    }
+  }
+  /**
+   * Send notification to multiple notifiables.
+   */
+  async sendToMany(notifiables, notification) {
+    await Promise.all(
+      notifiables.map((notifiable) => this.send(notifiable, notification))
+    );
+  }
+  /**
+   * Send notification immediately to multiple notifiables.
+   */
+  async sendNowToMany(notifiables, notification) {
+    await Promise.all(
+      notifiables.map((notifiable) => this.sendNow(notifiable, notification))
+    );
+  }
+  /**
+   * Serialize notifiable for queue storage.
+   */
+  serializeNotifiable(notifiable) {
+    return {
+      type: notifiable.constructor?.name ?? "Unknown",
+      data: { ...notifiable }
+    };
+  }
+  /**
+   * Serialize notification for queue storage.
+   */
+  serializeNotification(notification) {
+    return {
+      type: notification.type,
+      id: notification.id,
+      data: { ...notification }
+    };
+  }
+  /**
+   * Create the notification job class.
+   */
+  createNotificationJob() {
+    const manager = this;
+    class BoundSendNotificationJob extends SendNotificationJob {
+      static notificationManager = manager;
+    }
+    return BoundSendNotificationJob;
+  }
+};
+var SendNotificationJob = class extends Job {
+  static jobName = "SendNotificationJob";
+  static queue = "notifications";
+  static maxAttempts = 3;
+  // Will be set by NotificationManager
+  static notificationManager = null;
+  async handle(payload) {
+    const manager = this.constructor.notificationManager;
+    if (!manager) {
+      throw new Error("NotificationManager not set on SendNotificationJob");
+    }
+    const notifiable = {
+      ...payload.notifiableData.data,
+      routeNotificationFor(channel) {
+        const key = `${channel}Route`;
+        const value = payload.notifiableData.data[key];
+        if (typeof value === "string") return value;
+        if (channel === "mail") {
+          const email = payload.notifiableData.data["email"];
+          return typeof email === "string" ? email : null;
+        }
+        return null;
+      }
+    };
+    const notification = {
+      ...payload.notificationData.data,
+      id: payload.notificationData.id,
+      type: payload.notificationType,
+      via: () => {
+        const viaChannels = payload.notificationData.data._viaChannels;
+        return viaChannels ?? [];
+      },
+      shouldSend: () => true,
+      toMail: payload.notificationData.data.toMail,
+      toDatabase: payload.notificationData.data.toDatabase,
+      toSlack: payload.notificationData.data.toSlack
+    };
+    await manager.sendNow(notifiable, notification);
+  }
+};
+var globalNotificationManager = null;
+function setNotificationManager(manager) {
+  globalNotificationManager = manager;
+}
+function getNotificationManager() {
+  if (!globalNotificationManager) {
+    throw new Error("NotificationManager not initialized. Call setNotificationManager() first.");
+  }
+  return globalNotificationManager;
+}
+function createNotificationManager(options) {
+  return new NotificationManager(options);
+}
+
+// src/notifications/channels/MailChannel.ts
+function parseAddress(input) {
+  if (!input) {
+    return void 0;
+  }
+  if (typeof input !== "string") {
+    return input;
+  }
+  const match = input.match(/^(.+)\s*<(.+)>$/);
+  if (match) {
+    return { name: match[1].trim(), email: match[2].trim() };
+  }
+  return { email: input };
+}
+function parseAddressList(input) {
+  if (!input) {
+    return void 0;
+  }
+  const items = Array.isArray(input) ? input : [input];
+  const parsed = items.map((item) => parseAddress(item)).filter((item) => Boolean(item));
+  return parsed.length > 0 ? parsed : void 0;
+}
+var MailChannel = class {
+  constructor(mailManager, options = {}) {
+    this.mailManager = mailManager;
+    this.options = options;
+  }
+  name = "mail";
+  /**
+   * Send the notification via mail.
+   */
+  async send(notifiable, notification) {
+    const message = notification.toMail?.(notifiable);
+    if (!message) {
+      return;
+    }
+    const to = notifiable.routeNotificationFor("mail");
+    if (!to) {
+      return;
+    }
+    const transport = this.mailManager.transport(this.options.transport);
+    const toAddresses = parseAddressList(to);
+    if (!toAddresses || toAddresses.length === 0) {
+      return;
+    }
+    await transport.send({
+      to: toAddresses,
+      from: parseAddress(message.from ?? this.options.from),
+      replyTo: parseAddress(message.replyTo),
+      cc: parseAddressList(message.cc),
+      bcc: parseAddressList(message.bcc),
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: message.attachments?.map((a) => ({
+        filename: a.filename,
+        content: a.content,
+        path: a.path,
+        contentType: a.contentType
+      }))
+    });
+  }
+};
+
+// src/notifications/channels/DatabaseChannel.ts
+var DatabaseChannel = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "database";
+  stored = [];
+  /**
+   * Send the notification to the database.
+   */
+  async send(notifiable, notification) {
+    const data = notification.toDatabase?.(notifiable);
+    if (!data) {
+      return;
+    }
+    const record = {
+      id: notification.id,
+      type: notification.type,
+      notifiableId: this.getNotifiableId(notifiable),
+      notifiableType: this.getNotifiableType(notifiable),
+      data,
+      readAt: null,
+      createdAt: notification.createdAt
+    };
+    if (this.options.store) {
+      await this.options.store(notifiable, record);
+    } else {
+      this.stored.push(record);
+      if (notifiable.notifications) {
+        notifiable.notifications.push(record);
+      }
+    }
+  }
+  /**
+   * Get the notifiable ID.
+   */
+  getNotifiableId(notifiable) {
+    const withId = notifiable;
+    if (withId.id !== void 0) {
+      return withId.id;
+    }
+    return String(notifiable);
+  }
+  /**
+   * Get the notifiable type.
+   */
+  getNotifiableType(notifiable) {
+    return notifiable.constructor?.name ?? "Unknown";
+  }
+  /**
+   * Get all stored notifications (for testing).
+   */
+  getStored() {
+    return [...this.stored];
+  }
+  /**
+   * Get stored notifications for a notifiable.
+   */
+  getStoredFor(notifiable) {
+    const id = this.getNotifiableId(notifiable);
+    const type = this.getNotifiableType(notifiable);
+    return this.stored.filter(
+      (n) => n.notifiableId === id && n.notifiableType === type
+    );
+  }
+  /**
+   * Clear stored notifications (for testing).
+   */
+  clear() {
+    this.stored = [];
+  }
+};
+
+// src/notifications/channels/SlackChannel.ts
+var SlackChannel = class {
+  constructor(webhookUrl, options = {}) {
+    this.webhookUrl = webhookUrl;
+    this.options = options;
+  }
+  name = "slack";
+  /**
+   * Send the notification to Slack.
+   */
+  async send(notifiable, notification) {
+    const message = notification.toSlack?.(notifiable);
+    if (!message) {
+      return;
+    }
+    const webhookUrl = notifiable.routeNotificationFor("slack") ?? this.webhookUrl;
+    if (!webhookUrl) {
+      return;
+    }
+    const payload = this.buildPayload(message);
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Slack webhook failed: ${response.status} ${text}`);
+    }
+  }
+  /**
+   * Build the Slack webhook payload.
+   */
+  buildPayload(message) {
+    const payload = {};
+    if (message.text) {
+      payload.text = message.text;
+    }
+    if (message.blocks && message.blocks.length > 0) {
+      payload.blocks = message.blocks;
+    }
+    if (message.attachments && message.attachments.length > 0) {
+      payload.attachments = message.attachments;
+    }
+    if (message.channel) {
+      payload.channel = message.channel;
+    }
+    if (message.username ?? this.options.username) {
+      payload.username = message.username ?? this.options.username;
+    }
+    if (message.icon_emoji ?? this.options.iconEmoji) {
+      payload.icon_emoji = message.icon_emoji ?? this.options.iconEmoji;
+    }
+    if (message.icon_url ?? this.options.iconUrl) {
+      payload.icon_url = message.icon_url ?? this.options.iconUrl;
+    }
+    return payload;
+  }
+};
+
+// src/notifications/channels/MemoryChannel.ts
+var MemoryChannel = class {
+  name = "memory";
+  /**
+   * All sent notifications.
+   */
+  sent = [];
+  /**
+   * Send (store) the notification.
+   */
+  async send(notifiable, notification) {
+    this.sent.push({
+      notifiable,
+      notification,
+      channels: notification.via(notifiable),
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Assert that a notification was sent to a notifiable.
+   */
+  assertSentTo(notifiable, notificationType) {
+    const found = this.sent.some((record) => {
+      const matchesNotifiable = record.notifiable === notifiable;
+      const matchesType = notificationType ? record.notification.type === notificationType : true;
+      return matchesNotifiable && matchesType;
+    });
+    if (!found) {
+      const typeMsg = notificationType ? ` of type "${notificationType}"` : "";
+      throw new Error(`Expected notification${typeMsg} to be sent to notifiable`);
+    }
+  }
+  /**
+   * Assert that a notification was not sent to a notifiable.
+   */
+  assertNotSentTo(notifiable, notificationType) {
+    const found = this.sent.some((record) => {
+      const matchesNotifiable = record.notifiable === notifiable;
+      const matchesType = notificationType ? record.notification.type === notificationType : true;
+      return matchesNotifiable && matchesType;
+    });
+    if (found) {
+      const typeMsg = notificationType ? ` of type "${notificationType}"` : "";
+      throw new Error(
+        `Expected notification${typeMsg} not to be sent to notifiable`
+      );
+    }
+  }
+  /**
+   * Assert the total count of sent notifications.
+   */
+  assertCount(count) {
+    if (this.sent.length !== count) {
+      throw new Error(
+        `Expected ${count} notifications to be sent, but ${this.sent.length} were sent`
+      );
+    }
+  }
+  /**
+   * Assert that a notification type was sent.
+   */
+  assertSent(notificationType) {
+    const found = this.sent.some(
+      (record) => record.notification.type === notificationType
+    );
+    if (!found) {
+      throw new Error(
+        `Expected notification of type "${notificationType}" to be sent`
+      );
+    }
+  }
+  /**
+   * Assert that a notification type was not sent.
+   */
+  assertNotSent(notificationType) {
+    const found = this.sent.some(
+      (record) => record.notification.type === notificationType
+    );
+    if (found) {
+      throw new Error(
+        `Expected notification of type "${notificationType}" not to be sent`
+      );
+    }
+  }
+  /**
+   * Assert that no notifications were sent.
+   */
+  assertNothingSent() {
+    if (this.sent.length > 0) {
+      throw new Error(
+        `Expected no notifications to be sent, but ${this.sent.length} were sent`
+      );
+    }
+  }
+  /**
+   * Get notifications sent to a specific notifiable.
+   */
+  getSentTo(notifiable) {
+    return this.sent.filter((record) => record.notifiable === notifiable);
+  }
+  /**
+   * Get notifications of a specific type.
+   */
+  getSentOfType(notificationType) {
+    return this.sent.filter(
+      (record) => record.notification.type === notificationType
+    );
+  }
+  /**
+   * Check if a notification was sent to a notifiable.
+   */
+  hasSentTo(notifiable, notificationType) {
+    return this.sent.some((record) => {
+      const matchesNotifiable = record.notifiable === notifiable;
+      const matchesType = notificationType ? record.notification.type === notificationType : true;
+      return matchesNotifiable && matchesType;
+    });
+  }
+  /**
+   * Check if a notification type was sent.
+   */
+  hasSent(notificationType) {
+    return this.sent.some(
+      (record) => record.notification.type === notificationType
+    );
+  }
+  /**
+   * Get the count of sent notifications.
+   */
+  count() {
+    return this.sent.length;
+  }
+  /**
+   * Get the last sent notification.
+   */
+  last() {
+    return this.sent[this.sent.length - 1];
+  }
+  /**
+   * Get the first sent notification.
+   */
+  first() {
+    return this.sent[0];
+  }
+  /**
+   * Clear all sent notifications.
+   */
+  clear() {
+    this.sent = [];
+  }
+};
+export {
+  DatabaseChannel,
+  MailChannel,
+  MemoryChannel,
+  Notification,
+  NotificationManager,
+  SlackChannel,
+  createNotificationManager,
+  getNotificationManager,
+  setNotificationManager
+};