@spfn/notification 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/{index-D_XTwHmO.d.ts → index-BAe1ZBYQ.d.ts}

@@ -119,6 +119,50 @@ interface InternalSendSMSParams {
     message: string;
 }
 
+/**
+ * @spfn/notification - Slack Channel Types
+ */
+
+/**
+ * Parameters for sending Slack message
+ */
+interface SendSlackParams {
+    /**
+     * Webhook URL (overrides env/config default)
+     */
+    webhookUrl?: string;
+    /**
+     * Plain text message
+     */
+    text?: string;
+    /**
+     * Slack Block Kit blocks
+     */
+    blocks?: unknown[];
+    /**
+     * Template name
+     */
+    template?: string;
+    /**
+     * Template data for variable substitution
+     */
+    data?: Record<string, unknown>;
+}
+/**
+ * Slack provider interface
+ */
+interface SlackProvider extends ChannelProvider<InternalSendSlackParams> {
+    name: 'webhook' | string;
+}
+/**
+ * Internal send Slack params (after template rendering)
+ */
+interface InternalSendSlackParams {
+    webhookUrl: string;
+    text?: string;
+    blocks?: unknown[];
+}
+
 /**
  * @spfn/notification - Template Types
  */
@@ -167,4 +211,4 @@ interface RenderedTemplate {
  */
 type TemplateData = Record<string, unknown>;
 
-export type { EmailProvider as E, NotificationChannel as N, RenderedTemplate as R, SendEmailParams as S, TemplateDefinition as T, SendResult as a, SendSMSParams as b, SMSProvider as c, TemplateData as d, EmailTemplateContent as e, SmsTemplateContent as f, SlackTemplateContent as g };
+export type { EmailProvider as E, NotificationChannel as N, RenderedTemplate as R, SendEmailParams as S, TemplateDefinition as T, SendResult as a, SendSMSParams as b, SMSProvider as c, SendSlackParams as d, SlackProvider as e, TemplateData as f, EmailTemplateContent as g, SmsTemplateContent as h, SlackTemplateContent as i };

package/dist/index.d.ts

@@ -1 +1 @@
-export { e as EmailTemplateContent, N as NotificationChannel, S as SendEmailParams, a as SendResult, b as SendSMSParams, g as SlackTemplateContent, f as SmsTemplateContent, d as TemplateData, T as TemplateDefinition } from './index-D_XTwHmO.js';
+export { g as EmailTemplateContent, N as NotificationChannel, S as SendEmailParams, a as SendResult, b as SendSMSParams, d as SendSlackParams, i as SlackTemplateContent, h as SmsTemplateContent, f as TemplateData, T as TemplateDefinition } from './index-BAe1ZBYQ.js';

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 export { NotificationConfig, configureNotification, getAppName, getEmailFrom, getEmailReplyTo, getNotificationConfig, getSmsDefaultCountryCode } from './config/index.js';
-import { S as SendEmailParams, a as SendResult, E as EmailProvider, b as SendSMSParams, c as SMSProvider, T as TemplateDefinition, d as TemplateData, N as NotificationChannel$1, R as RenderedTemplate } from './index-D_XTwHmO.js';
-export { e as EmailTemplateContent, g as SlackTemplateContent, f as SmsTemplateContent } from './index-D_XTwHmO.js';
+import { S as SendEmailParams, a as SendResult, E as EmailProvider, b as SendSMSParams, c as SMSProvider, d as SendSlackParams, e as SlackProvider, T as TemplateDefinition, f as TemplateData, N as NotificationChannel$1, R as RenderedTemplate } from './index-BAe1ZBYQ.js';
+export { g as EmailTemplateContent, i as SlackTemplateContent, h as SmsTemplateContent } from './index-BAe1ZBYQ.js';
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
 import * as _spfn_core_job from '@spfn/core/job';
 import '@spfn/core/env';
@@ -47,6 +47,27 @@ declare function sendSMSBulk(items: SendSMSParams[]): Promise<{
     failureCount: number;
 }>;
 
+/**
+ * @spfn/notification - Slack Channel
+ */
+
+/**
+ * Register custom Slack provider
+ */
+declare function registerSlackProvider(provider: SlackProvider): void;
+/**
+ * Send Slack message
+ */
+declare function sendSlack(params: SendSlackParams): Promise<SendResult>;
+/**
+ * Send bulk Slack messages
+ */
+declare function sendSlackBulk(items: SendSlackParams[]): Promise<{
+    results: SendResult[];
+    successCount: number;
+    failureCount: number;
+}>;
+
 /**
  * @spfn/notification - Schedule Service
  *
@@ -680,4 +701,58 @@ declare const notificationJobRouter: _spfn_core_job.JobRouter<{
     }, void>;
 }>;
 
-export { type CancelResult, EmailProvider, type FindNotificationsOptions, NOTIFICATION_CHANNELS, NOTIFICATION_STATUSES, type NewNotification, type Notification, NotificationChannel$1 as NotificationChannel, type NotificationStats, type NotificationStatus, SMSProvider, type ScheduleOptions, type ScheduleResult, SendEmailParams, SendResult, SendSMSParams, TemplateData, TemplateDefinition, cancelNotification, cancelNotificationsByReference, cancelScheduledNotification, countNotifications, createNotificationRecord, createScheduledNotification, findNotificationByJobId, findNotifications, findScheduledNotifications, getNotificationStats, getTemplate, getTemplateNames, hasTemplate, markNotificationFailed, markNotificationPending, markNotificationSent, notificationJobRouter, notifications, registerBuiltinTemplates, registerEmailProvider, registerFilter, registerSMSProvider, registerTemplate, renderTemplate, scheduleEmail, scheduleSMS, sendEmail, sendEmailBulk, sendSMS, sendSMSBulk, sendScheduledEmailJob, sendScheduledSmsJob, updateNotificationJobId };
+/**
+ * @spfn/notification - Error → Slack Integration
+ *
+ * Factory for creating an onError callback that sends error notifications to Slack.
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from '@spfn/core/server';
+ * import { createErrorSlackNotifier } from '@spfn/notification/server';
+ *
+ * await createServer({
+ *     middleware: {
+ *         onError: createErrorSlackNotifier({ minStatusCode: 500 }),
+ *     },
+ * });
+ * ```
+ */
+interface ErrorContext {
+    statusCode: number;
+    path: string;
+    method: string;
+    requestId?: string;
+    timestamp: string;
+    userId?: string;
+    request: {
+        headers: Record<string, string>;
+        query: Record<string, string>;
+    };
+}
+interface ErrorSlackOptions {
+    /**
+     * Minimum status code to trigger notification
+     * @default 500
+     */
+    minStatusCode?: number;
+    /**
+     * Webhook URL override (defaults to env/config)
+     */
+    webhookUrl?: string;
+    /**
+     * Custom message formatter
+     */
+    formatMessage?: (err: Error, ctx: ErrorContext) => {
+        text?: string;
+        blocks?: unknown[];
+    };
+}
+/**
+ * Create an onError callback that sends Slack notifications
+ *
+ * Returns a function matching ErrorHandler's onError signature.
+ */
+declare function createErrorSlackNotifier(options?: ErrorSlackOptions): (err: Error, ctx: ErrorContext) => Promise<void>;
+
+export { type CancelResult, EmailProvider, type ErrorSlackOptions, type FindNotificationsOptions, NOTIFICATION_CHANNELS, NOTIFICATION_STATUSES, type NewNotification, type Notification, NotificationChannel$1 as NotificationChannel, type NotificationStats, type NotificationStatus, SMSProvider, type ScheduleOptions, type ScheduleResult, SendEmailParams, SendResult, SendSMSParams, SendSlackParams, SlackProvider, TemplateData, TemplateDefinition, cancelNotification, cancelNotificationsByReference, cancelScheduledNotification, countNotifications, createErrorSlackNotifier, createNotificationRecord, createScheduledNotification, findNotificationByJobId, findNotifications, findScheduledNotifications, getNotificationStats, getTemplate, getTemplateNames, hasTemplate, markNotificationFailed, markNotificationPending, markNotificationSent, notificationJobRouter, notifications, registerBuiltinTemplates, registerEmailProvider, registerFilter, registerSMSProvider, registerSlackProvider, registerTemplate, renderTemplate, scheduleEmail, scheduleSMS, sendEmail, sendEmailBulk, sendSMS, sendSMSBulk, sendScheduledEmailJob, sendScheduledSmsJob, sendSlack, sendSlackBulk, updateNotificationJobId };

package/dist/server.js

@@ -892,6 +892,125 @@ async function sendSMSBulk(items) {
   return { results, successCount, failureCount };
 }
 
+// src/channels/slack/providers/webhook.ts
+var webhookProvider = {
+  name: "webhook",
+  async send(params) {
+    try {
+      const res = await fetch(params.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          text: params.text,
+          blocks: params.blocks
+        })
+      });
+      return {
+        success: res.ok,
+        error: res.ok ? void 0 : await res.text()
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        success: false,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/channels/slack/index.ts
+var providers3 = {
+  "webhook": webhookProvider
+};
+function registerSlackProvider(provider) {
+  providers3[provider.name] = provider;
+}
+function getProvider3() {
+  return providers3["webhook"];
+}
+function resolveWebhookUrl(params) {
+  return params.webhookUrl || env.SPFN_NOTIFICATION_SLACK_WEBHOOK_URL;
+}
+async function sendSlack(params) {
+  const webhookUrl = resolveWebhookUrl(params);
+  if (!webhookUrl) {
+    return {
+      success: false,
+      error: "Slack webhook URL is required. Set SPFN_NOTIFICATION_SLACK_WEBHOOK_URL or pass webhookUrl."
+    };
+  }
+  let text2 = params.text;
+  let blocks = params.blocks;
+  if (params.template) {
+    if (!hasTemplate(params.template)) {
+      return {
+        success: false,
+        error: `Template not found: ${params.template}`
+      };
+    }
+    const rendered = renderTemplate(params.template, params.data || {}, "slack");
+    if (rendered.slack) {
+      text2 = rendered.slack.text;
+      blocks = rendered.slack.blocks;
+    }
+  }
+  if (!text2 && !blocks) {
+    return {
+      success: false,
+      error: "Slack message requires text or blocks"
+    };
+  }
+  const internalParams = {
+    webhookUrl,
+    text: text2,
+    blocks
+  };
+  const provider = getProvider3();
+  let historyId;
+  if (isHistoryEnabled()) {
+    try {
+      const record = await createNotificationRecord({
+        channel: "slack",
+        recipient: webhookUrl,
+        templateName: params.template,
+        templateData: params.data,
+        content: text2,
+        providerName: provider.name
+      });
+      historyId = record.id;
+    } catch {
+    }
+  }
+  const result = await provider.send(internalParams);
+  if (historyId && isHistoryEnabled()) {
+    try {
+      if (result.success) {
+        await markNotificationSent(historyId, result.messageId);
+      } else {
+        await markNotificationFailed(historyId, result.error || "Unknown error");
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+async function sendSlackBulk(items) {
+  const results = [];
+  let successCount = 0;
+  let failureCount = 0;
+  for (const item of items) {
+    const result = await sendSlack(item);
+    results.push(result);
+    if (result.success) {
+      successCount++;
+    } else {
+      failureCount++;
+    }
+  }
+  return { results, successCount, failureCount };
+}
+
 // src/jobs/send-scheduled-email.ts
 import { job } from "@spfn/core/job";
 
@@ -3759,6 +3878,101 @@ var notificationJobRouter = defineJobRouter({
   sendScheduledSms: sendScheduledSmsJob
 });
 
+// src/integrations/error-slack.ts
+function formatHeaders(headers) {
+  const entries = Object.entries(headers);
+  if (entries.length === 0) {
+    return "(none)";
+  }
+  return entries.map(([k, v]) => `${k}: ${v}`).join("\n");
+}
+function formatQuery(query) {
+  const entries = Object.entries(query);
+  if (entries.length === 0) {
+    return "(none)";
+  }
+  return entries.map(([k, v]) => `${k}=${v}`).join("\n");
+}
+function shortStack(err, maxLines = 3) {
+  if (!err.stack) {
+    return "(no stack)";
+  }
+  const lines = err.stack.split("\n").slice(1);
+  return lines.slice(0, maxLines).map((line) => line.trim()).join("\n");
+}
+function defaultFormat(err, ctx) {
+  const emoji = ctx.statusCode >= 500 ? ":rotating_light:" : ":warning:";
+  const title = `${emoji} *${err.name || "Error"}* \u2014 ${ctx.statusCode}`;
+  const fields = [
+    { type: "mrkdwn", text: `*Method*
+${ctx.method}` },
+    { type: "mrkdwn", text: `*Path*
+${ctx.path}` },
+    { type: "mrkdwn", text: `*User*
+${ctx.userId ?? "(anonymous)"}` },
+    { type: "mrkdwn", text: `*Request ID*
+${ctx.requestId ?? "(none)"}` }
+  ];
+  const blocks = [
+    // Title
+    {
+      type: "header",
+      text: { type: "plain_text", text: `${err.name || "Error"} \u2014 ${ctx.statusCode}`, emoji: true }
+    },
+    // Error message
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `> ${err.message}` }
+    },
+    // Fields: method, path, user, requestId
+    {
+      type: "section",
+      fields
+    },
+    // Timestamp
+    {
+      type: "context",
+      elements: [
+        { type: "mrkdwn", text: `*Time:* ${ctx.timestamp}` }
+      ]
+    },
+    { type: "divider" },
+    // Headers
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `*Request Headers*
+\`\`\`${formatHeaders(ctx.request.headers)}\`\`\`` }
+    },
+    // Query
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `*Query Params*
+\`\`\`${formatQuery(ctx.request.query)}\`\`\`` }
+    },
+    { type: "divider" },
+    // Stack trace
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `*Stack Trace*
+\`\`\`${shortStack(err)}\`\`\`` }
+    }
+  ];
+  return { text: title, blocks };
+}
+function createErrorSlackNotifier(options = {}) {
+  const { minStatusCode = 500 } = options;
+  return async (err, ctx) => {
+    if (ctx.statusCode < minStatusCode) {
+      return;
+    }
+    const message = options.formatMessage?.(err, ctx) ?? defaultFormat(err, ctx);
+    await sendSlack({
+      ...message,
+      webhookUrl: options.webhookUrl
+    });
+  };
+}
+
 // src/server.ts
 registerBuiltinTemplates();
 export {
@@ -3769,6 +3983,7 @@ export {
   cancelScheduledNotification,
   configureNotification,
   countNotifications,
+  createErrorSlackNotifier,
   createNotificationRecord,
   createScheduledNotification,
   findNotificationByJobId,
@@ -3792,6 +4007,7 @@ export {
   registerEmailProvider,
   registerFilter,
   registerSMSProvider,
+  registerSlackProvider,
   registerTemplate,
   renderTemplate,
   scheduleEmail,
@@ -3802,6 +4018,8 @@ export {
   sendSMSBulk,
   sendScheduledEmailJob,
   sendScheduledSmsJob,
+  sendSlack,
+  sendSlackBulk,
   updateNotificationJobId
 };
 //# sourceMappingURL=server.js.map