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

package/dist/server.js

@@ -95,6 +95,8 @@ function isHistoryEnabled() {
 }
 
 // src/channels/email/providers/aws-ses.ts
+import { logger } from "@spfn/core/logger";
+var log = logger.child("@spfn/notification:ses");
 var sesClient = null;
 async function getSESClient() {
   if (sesClient) {
@@ -109,6 +111,7 @@ async function getSESClient() {
         secretAccessKey: env.AWS_SECRET_ACCESS_KEY
       } : void 0
     });
+    log.debug("SES client created", { region: env.AWS_REGION });
     return sesClient;
   } catch {
     throw new Error(
@@ -156,6 +159,7 @@ var awsSesProvider = {
       };
     } catch (error) {
       const err = error;
+      log.error("SES send failed", err, { to: params.to, from: params.from });
       return {
         success: false,
         error: err.message
@@ -630,6 +634,8 @@ async function findScheduledNotifications(options = {}) {
 }
 
 // src/channels/email/index.ts
+import { logger as logger2 } from "@spfn/core/logger";
+var log2 = logger2.child("@spfn/notification:email");
 var providers = {
   "aws-ses": awsSesProvider
 };
@@ -651,6 +657,7 @@ async function sendEmail(params) {
   let html = params.html;
   if (params.template) {
     if (!hasTemplate(params.template)) {
+      log2.warn(`Template not found: ${params.template}`);
       return {
         success: false,
         error: `Template not found: ${params.template}`
@@ -664,12 +671,14 @@ async function sendEmail(params) {
     }
   }
   if (!subject) {
+    log2.warn("Email subject is required", { to: recipients });
     return {
       success: false,
       error: "Email subject is required"
     };
   }
   if (!text2 && !html) {
+    log2.warn("Email content (text or html) is required", { to: recipients, subject });
     return {
       success: false,
       error: "Email content (text or html) is required"
@@ -697,10 +706,16 @@ async function sendEmail(params) {
         providerName: provider.name
       });
       historyId = record.id;
-    } catch {
+    } catch (error) {
+      log2.warn("Failed to create notification history record", error);
     }
   }
   const result = await provider.send(internalParams);
+  if (result.success) {
+    log2.info("Email sent", { to: recipients, subject, messageId: result.messageId });
+  } else {
+    log2.error("Email send failed", { to: recipients, subject, error: result.error });
+  }
   if (historyId && isHistoryEnabled()) {
     try {
       if (result.success) {
@@ -708,7 +723,8 @@ async function sendEmail(params) {
       } else {
         await markNotificationFailed(historyId, result.error || "Unknown error");
       }
-    } catch {
+    } catch (error) {
+      log2.warn("Failed to update notification history record", error);
     }
   }
   return result;
@@ -730,6 +746,8 @@ async function sendEmailBulk(items) {
 }
 
 // src/channels/sms/providers/aws-sns.ts
+import { logger as logger3 } from "@spfn/core/logger";
+var log3 = logger3.child("@spfn/notification:sns");
 var snsClient = null;
 async function getSNSClient() {
   if (snsClient) {
@@ -744,6 +762,7 @@ async function getSNSClient() {
         secretAccessKey: env.AWS_SECRET_ACCESS_KEY
       } : void 0
     });
+    log3.debug("SNS client created", { region: env.AWS_REGION });
     return snsClient;
   } catch {
     throw new Error(
@@ -774,6 +793,7 @@ var awsSnsProvider = {
       };
     } catch (error) {
       const err = error;
+      log3.error("SNS send failed", err, { to: params.to });
       return {
         success: false,
         error: err.message
@@ -796,6 +816,8 @@ function normalizePhoneNumber(phone, defaultCountryCode) {
 }
 
 // src/channels/sms/index.ts
+import { logger as logger4 } from "@spfn/core/logger";
+var log4 = logger4.child("@spfn/notification:sms");
 var providers2 = {
   "aws-sns": awsSnsProvider
 };
@@ -815,6 +837,7 @@ async function sendSMS(params) {
   let message = params.message;
   if (params.template) {
     if (!hasTemplate(params.template)) {
+      log4.warn(`Template not found: ${params.template}`);
       return {
         success: false,
         error: `Template not found: ${params.template}`
@@ -826,6 +849,7 @@ async function sendSMS(params) {
     }
   }
   if (!message) {
+    log4.warn("SMS message is required", { to: recipients });
     return {
       success: false,
       error: "SMS message is required"
@@ -851,10 +875,16 @@ async function sendSMS(params) {
           providerName: provider.name
         });
         historyId = record.id;
-      } catch {
+      } catch (error) {
+        log4.warn("Failed to create notification history record", error);
       }
     }
     const result = await provider.send(internalParams);
+    if (result.success) {
+      log4.info("SMS sent", { to: normalizedPhone, messageId: result.messageId });
+    } else {
+      log4.error("SMS send failed", { to: normalizedPhone, error: result.error });
+    }
     if (historyId && isHistoryEnabled()) {
       try {
         if (result.success) {
@@ -862,7 +892,8 @@ async function sendSMS(params) {
         } else {
           await markNotificationFailed(historyId, result.error || "Unknown error");
         }
-      } catch {
+      } catch (error) {
+        log4.warn("Failed to update notification history record", error);
       }
     }
     results.push(result);
@@ -892,6 +923,140 @@ async function sendSMSBulk(items) {
   return { results, successCount, failureCount };
 }
 
+// src/channels/slack/providers/webhook.ts
+import { logger as logger5 } from "@spfn/core/logger";
+var log5 = logger5.child("@spfn/notification:slack-webhook");
+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;
+      log5.error("Webhook request failed", err);
+      return {
+        success: false,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/channels/slack/index.ts
+import { logger as logger6 } from "@spfn/core/logger";
+var log6 = logger6.child("@spfn/notification:slack");
+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) {
+    log6.warn("Slack webhook URL is required");
+    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)) {
+      log6.warn(`Template not found: ${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) {
+    log6.warn("Slack message requires text or 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 (error) {
+      log6.warn("Failed to create notification history record", error);
+    }
+  }
+  const result = await provider.send(internalParams);
+  if (result.success) {
+    log6.info("Slack message sent");
+  } else {
+    log6.error("Slack send failed", { error: result.error });
+  }
+  if (historyId && isHistoryEnabled()) {
+    try {
+      if (result.success) {
+        await markNotificationSent(historyId, result.messageId);
+      } else {
+        await markNotificationFailed(historyId, result.error || "Unknown error");
+      }
+    } catch (error) {
+      log6.warn("Failed to update notification history record", error);
+    }
+  }
+  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 +3924,127 @@ var notificationJobRouter = defineJobRouter({
   sendScheduledSms: sendScheduledSmsJob
 });
 
+// src/integrations/error-slack.ts
+import { hostname } from "os";
+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");
+}
+var throttleMap = /* @__PURE__ */ new Map();
+function throttleKey(err, ctx) {
+  return `${err.name}:${ctx.statusCode}:${ctx.path}`;
+}
+function getEnvLabel() {
+  const env2 = process.env.NODE_ENV || "unknown";
+  const host = hostname();
+  const dbUrl = process.env.DATABASE_URL || "";
+  const dbName = dbUrl.match(/\/([^/?]+)(\?|$)/)?.[1] || "(unknown)";
+  return `${env2} | ${host} | db:${dbName}`;
+}
+function defaultFormat(err, ctx, suppressed = 0) {
+  const envLabel = getEnvLabel();
+  const emoji = ctx.statusCode >= 500 ? ":rotating_light:" : ":warning:";
+  const title = `${emoji} *${err.name || "Error"}* \u2014 ${ctx.statusCode} [${envLabel}]`;
+  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 + suppressed count
+    {
+      type: "context",
+      elements: [
+        { type: "mrkdwn", text: `*Time:* ${ctx.timestamp}` },
+        ...suppressed > 0 ? [{ type: "mrkdwn", text: `_+${suppressed} suppressed since last notification_` }] : []
+      ]
+    },
+    { 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 = {}) {
+  console.warn(
+    "[@spfn/notification] createErrorSlackNotifier() is deprecated. Use createMonitorErrorHandler() from @spfn/monitor/server instead."
+  );
+  const { minStatusCode = 500, throttleMs = 6e4 } = options;
+  return async (err, ctx) => {
+    if (ctx.statusCode < minStatusCode) {
+      return;
+    }
+    const key = throttleKey(err, ctx);
+    const now = Date.now();
+    const entry = throttleMap.get(key);
+    if (entry && now - entry.lastSent < throttleMs) {
+      entry.suppressed++;
+      return;
+    }
+    const suppressed = entry?.suppressed ?? 0;
+    throttleMap.set(key, { lastSent: now, suppressed: 0 });
+    const message = options.formatMessage?.(err, ctx) ?? defaultFormat(err, ctx, suppressed);
+    await sendSlack({
+      ...message,
+      webhookUrl: options.webhookUrl
+    });
+  };
+}
+
 // src/server.ts
 registerBuiltinTemplates();
 export {
@@ -3769,6 +4055,7 @@ export {
   cancelScheduledNotification,
   configureNotification,
   countNotifications,
+  createErrorSlackNotifier,
   createNotificationRecord,
   createScheduledNotification,
   findNotificationByJobId,
@@ -3792,6 +4079,7 @@ export {
   registerEmailProvider,
   registerFilter,
   registerSMSProvider,
+  registerSlackProvider,
   registerTemplate,
   renderTemplate,
   scheduleEmail,
@@ -3802,6 +4090,8 @@ export {
   sendSMSBulk,
   sendScheduledEmailJob,
   sendScheduledSmsJob,
+  sendSlack,
+  sendSlackBulk,
   updateNotificationJobId
 };
 //# sourceMappingURL=server.js.map