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

package/dist/notifications/index.d.ts

@@ -0,0 +1,271 @@
+import { _ as NotificationChannel, X as Notifiable, Y as Notification, q as DatabaseNotification, p as DatabaseChannelOptions, as as SlackMessage, ai as SentNotification } from '../Application-DtWDHXr1.js';
+export { Z as NotificationAttachment, $ as NotificationChannelFactory, a0 as NotificationClass, a1 as NotificationMailMessage, N as NotificationManager, a2 as NotificationManagerOptions, aq as SlackAttachment, ar as SlackBlock, aG as createNotificationManager, aP as getNotificationManager, a_ as setNotificationManager } from '../Application-DtWDHXr1.js';
+import { M as MailManager } from '../MailManager-DpMvYiP9.js';
+import 'hono';
+import '../api-token-JOif2CtG.js';
+import 'vite';
+import '../EventManager-CmIoLt7r.js';
+import '../CacheManager-BkvHEOZX.js';
+import '../LogManager-7mxnkaPM.js';
+import '../I18nManager-Dtgzsf5n.js';
+import '../BroadcastManager-AkIWUGJo.js';
+import '../index-9_Jzj5jo.js';
+import '../app-key-CsBfRC_Q.js';
+import '../StorageManager-oZTHqaza.js';
+import '../HealthManager-DUyMIzsZ.js';
+import '../Scheduler-BstvSca7.js';
+import '../Gate-CNkBYf8m.js';
+
+/**
+ * Mail notification channel.
+ *
+ * Sends notifications via email using the MailManager.
+ *
+ * @example
+ * ```typescript
+ * const mailChannel = new MailChannel(mailManager)
+ * notifications.registerChannel('mail', mailChannel)
+ *
+ * // In notification class:
+ * toMail(notifiable: Notifiable): NotificationMailMessage {
+ *   return {
+ *     subject: 'Order Shipped',
+ *     html: '<p>Your order has shipped!</p>',
+ *   }
+ * }
+ * ```
+ */
+declare class MailChannel implements NotificationChannel {
+    private mailManager;
+    private options;
+    readonly name = "mail";
+    constructor(mailManager: MailManager, options?: MailChannelOptions);
+    /**
+     * Send the notification via mail.
+     */
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+}
+/**
+ * Mail channel options.
+ */
+interface MailChannelOptions {
+    /**
+     * Default from address.
+     */
+    from?: string;
+    /**
+     * Transport name to use.
+     */
+    transport?: string;
+}
+
+/**
+ * Database notification channel.
+ *
+ * Stores notifications in the database for in-app notifications.
+ *
+ * @example
+ * ```typescript
+ * const dbChannel = new DatabaseChannel({
+ *   store: async (notifiable, notification) => {
+ *     await db.insert(notifications).values(notification)
+ *   },
+ * })
+ * notifications.registerChannel('database', dbChannel)
+ *
+ * // In notification class:
+ * toDatabase(notifiable: Notifiable): Record<string, unknown> {
+ *   return {
+ *     orderId: this.order.id,
+ *     message: 'Your order has shipped',
+ *   }
+ * }
+ * ```
+ */
+declare class DatabaseChannel implements NotificationChannel {
+    private options;
+    readonly name = "database";
+    protected stored: DatabaseNotification[];
+    constructor(options?: DatabaseChannelOptions);
+    /**
+     * Send the notification to the database.
+     */
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+    /**
+     * Get the notifiable ID.
+     */
+    protected getNotifiableId(notifiable: Notifiable): string | number;
+    /**
+     * Get the notifiable type.
+     */
+    protected getNotifiableType(notifiable: Notifiable): string;
+    /**
+     * Get all stored notifications (for testing).
+     */
+    getStored(): DatabaseNotification[];
+    /**
+     * Get stored notifications for a notifiable.
+     */
+    getStoredFor(notifiable: Notifiable): DatabaseNotification[];
+    /**
+     * Clear stored notifications (for testing).
+     */
+    clear(): void;
+}
+
+/**
+ * Slack notification channel.
+ *
+ * Sends notifications to Slack via incoming webhooks.
+ *
+ * @example
+ * ```typescript
+ * const slackChannel = new SlackChannel('https://hooks.slack.com/services/...')
+ * notifications.registerChannel('slack', slackChannel)
+ *
+ * // In notification class:
+ * toSlack(notifiable: Notifiable): SlackMessage {
+ *   return {
+ *     text: `Order #${this.order.id} has been shipped!`,
+ *     blocks: [
+ *       {
+ *         type: 'section',
+ *         text: {
+ *           type: 'mrkdwn',
+ *           text: `*Order Shipped*\nOrder #${this.order.id} is on its way!`,
+ *         },
+ *       },
+ *     ],
+ *   }
+ * }
+ * ```
+ */
+declare class SlackChannel implements NotificationChannel {
+    private webhookUrl;
+    private options;
+    readonly name = "slack";
+    constructor(webhookUrl: string, options?: SlackChannelOptions);
+    /**
+     * Send the notification to Slack.
+     */
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+    /**
+     * Build the Slack webhook payload.
+     */
+    protected buildPayload(message: SlackMessage): SlackWebhookPayload;
+}
+/**
+ * Slack channel options.
+ */
+interface SlackChannelOptions {
+    /**
+     * Default username for messages.
+     */
+    username?: string;
+    /**
+     * Default icon emoji for messages.
+     */
+    iconEmoji?: string;
+    /**
+     * Default icon URL for messages.
+     */
+    iconUrl?: string;
+}
+/**
+ * Slack webhook payload.
+ */
+interface SlackWebhookPayload {
+    text?: string;
+    blocks?: unknown[];
+    attachments?: unknown[];
+    channel?: string;
+    username?: string;
+    icon_emoji?: string;
+    icon_url?: string;
+}
+
+/**
+ * Memory notification channel for testing.
+ *
+ * Stores all sent notifications in memory for assertions.
+ *
+ * @example
+ * ```typescript
+ * const memoryChannel = new MemoryChannel()
+ * notifications.registerChannel('memory', memoryChannel)
+ *
+ * await notifications.send(user, new OrderShipped(order))
+ *
+ * memoryChannel.assertSentTo(user, 'OrderShipped')
+ * memoryChannel.assertCount(1)
+ * ```
+ */
+declare class MemoryChannel implements NotificationChannel {
+    readonly name = "memory";
+    /**
+     * All sent notifications.
+     */
+    sent: SentNotification[];
+    /**
+     * Send (store) the notification.
+     */
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+    /**
+     * Assert that a notification was sent to a notifiable.
+     */
+    assertSentTo(notifiable: Notifiable, notificationType?: string): void;
+    /**
+     * Assert that a notification was not sent to a notifiable.
+     */
+    assertNotSentTo(notifiable: Notifiable, notificationType?: string): void;
+    /**
+     * Assert the total count of sent notifications.
+     */
+    assertCount(count: number): void;
+    /**
+     * Assert that a notification type was sent.
+     */
+    assertSent(notificationType: string): void;
+    /**
+     * Assert that a notification type was not sent.
+     */
+    assertNotSent(notificationType: string): void;
+    /**
+     * Assert that no notifications were sent.
+     */
+    assertNothingSent(): void;
+    /**
+     * Get notifications sent to a specific notifiable.
+     */
+    getSentTo(notifiable: Notifiable): SentNotification[];
+    /**
+     * Get notifications of a specific type.
+     */
+    getSentOfType(notificationType: string): SentNotification[];
+    /**
+     * Check if a notification was sent to a notifiable.
+     */
+    hasSentTo(notifiable: Notifiable, notificationType?: string): boolean;
+    /**
+     * Check if a notification type was sent.
+     */
+    hasSent(notificationType: string): boolean;
+    /**
+     * Get the count of sent notifications.
+     */
+    count(): number;
+    /**
+     * Get the last sent notification.
+     */
+    last(): SentNotification | undefined;
+    /**
+     * Get the first sent notification.
+     */
+    first(): SentNotification | undefined;
+    /**
+     * Clear all sent notifications.
+     */
+    clear(): void;
+}
+
+export { DatabaseChannel, DatabaseChannelOptions, DatabaseNotification, MailChannel, type MailChannelOptions, MemoryChannel, Notifiable, Notification, NotificationChannel, SentNotification, SlackChannel, type SlackChannelOptions, SlackMessage };