@hookflo/tern 4.1.1 → 4.2.0

package/dist/adapters/cloudflare.d.ts

@@ -1,5 +1,6 @@
 import { WebhookPlatform, NormalizeOptions } from '../types';
 import { QueueOption } from '../upstash/types';
+import type { AlertConfig, SendAlertOptions } from '../notifications/types';
 export interface CloudflareWebhookHandlerOptions<TEnv = Record<string, unknown>, TPayload = any, TMetadata extends Record<string, unknown> = Record<string, unknown>, TResponse = unknown> {
     platform: WebhookPlatform;
     secret?: string;
@@ -7,6 +8,8 @@ export interface CloudflareWebhookHandlerOptions<TEnv = Record<string, unknown>,
     toleranceInSeconds?: number;
     normalize?: boolean | NormalizeOptions;
     queue?: QueueOption;
+    alerts?: AlertConfig;
+    alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;
     onError?: (error: Error) => void;
     handler: (payload: TPayload, env: TEnv, metadata: TMetadata) => Promise<TResponse> | TResponse;
 }

package/dist/adapters/cloudflare.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWebhookHandler = createWebhookHandler;
 const index_1 = require("../index");
 const queue_1 = require("../upstash/queue");
+const dispatch_1 = require("../notifications/dispatch");
 function createWebhookHandler(options) {
     return async (request, env) => {
         try {
@@ -13,18 +14,41 @@ function createWebhookHandler(options) {
             }
             if (options.queue) {
                 const queueConfig = (0, queue_1.resolveQueueConfig)(options.queue);
-                return (0, queue_1.handleQueuedRequest)(request, {
+                const response = await (0, queue_1.handleQueuedRequest)(request, {
                     platform: options.platform,
                     secret,
                     queueConfig,
                     handler: (payload, metadata) => options.handler(payload, env, metadata),
                     toleranceInSeconds: options.toleranceInSeconds ?? 300,
                 });
+                if (response.ok) {
+                    let eventId;
+                    try {
+                        const body = await response.clone().json();
+                        eventId = typeof body.eventId === 'string' ? body.eventId : undefined;
+                    }
+                    catch {
+                        eventId = undefined;
+                    }
+                    await (0, dispatch_1.dispatchWebhookAlert)({
+                        alerts: options.alerts,
+                        source: options.platform,
+                        eventId,
+                        alert: options.alert,
+                    });
+                }
+                return response;
             }
             const result = await index_1.WebhookVerificationService.verifyWithPlatformConfig(request, options.platform, secret, options.toleranceInSeconds, options.normalize);
             if (!result.isValid) {
                 return Response.json({ error: result.error, errorCode: result.errorCode, platform: result.platform, metadata: result.metadata }, { status: 400 });
             }
+            await (0, dispatch_1.dispatchWebhookAlert)({
+                alerts: options.alerts,
+                source: options.platform,
+                eventId: result.eventId,
+                alert: options.alert,
+            });
             const data = await options.handler(result.payload, env, (result.metadata || {}));
             return Response.json(data);
         }

package/dist/adapters/express.d.ts

@@ -1,6 +1,7 @@
 import { WebhookPlatform, WebhookVerificationResult, NormalizeOptions } from '../types';
 import { QueueOption } from '../upstash/types';
 import { MinimalNodeRequest } from './shared';
+import type { AlertConfig, SendAlertOptions } from '../notifications/types';
 export interface ExpressLikeResponse {
     status: (code: number) => ExpressLikeResponse;
     json: (payload: unknown) => unknown;
@@ -15,6 +16,8 @@ export interface ExpressWebhookMiddlewareOptions {
     toleranceInSeconds?: number;
     normalize?: boolean | NormalizeOptions;
     queue?: QueueOption;
+    alerts?: AlertConfig;
+    alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;
     onError?: (error: Error) => void;
     strictRawBody?: boolean;
 }

package/dist/adapters/express.js

@@ -4,6 +4,7 @@ exports.createWebhookMiddleware = createWebhookMiddleware;
 const index_1 = require("../index");
 const queue_1 = require("../upstash/queue");
 const shared_1 = require("./shared");
+const dispatch_1 = require("../notifications/dispatch");
 function createWebhookMiddleware(options) {
     return async (req, res, next) => {
         try {
@@ -36,6 +37,15 @@ function createWebhookMiddleware(options) {
                     }
                 }
                 res.status(queueResponse.status).json(body ?? {});
+                if (queueResponse.ok) {
+                    const queueResult = body && typeof body === 'object' ? body : undefined;
+                    await (0, dispatch_1.dispatchWebhookAlert)({
+                        alerts: options.alerts,
+                        source: options.platform,
+                        eventId: typeof queueResult?.eventId === 'string' ? queueResult.eventId : undefined,
+                        alert: options.alert,
+                    });
+                }
                 return;
             }
             const result = await index_1.WebhookVerificationService.verifyWithPlatformConfig(webRequest, options.platform, options.secret, options.toleranceInSeconds, options.normalize);
@@ -49,6 +59,12 @@ function createWebhookMiddleware(options) {
                 return;
             }
             req.webhook = result;
+            await (0, dispatch_1.dispatchWebhookAlert)({
+                alerts: options.alerts,
+                source: options.platform,
+                eventId: result.eventId,
+                alert: options.alert,
+            });
             next();
         }
         catch (error) {

package/dist/adapters/nextjs.d.ts

@@ -1,11 +1,14 @@
 import { WebhookPlatform, NormalizeOptions } from '../types';
 import { QueueOption } from '../upstash/types';
+import type { AlertConfig, SendAlertOptions } from '../notifications/types';
 export interface NextWebhookHandlerOptions<TPayload = any, TMetadata extends Record<string, unknown> = Record<string, unknown>, TResponse = unknown> {
     platform: WebhookPlatform;
     secret: string;
     toleranceInSeconds?: number;
     normalize?: boolean | NormalizeOptions;
     queue?: QueueOption;
+    alerts?: AlertConfig;
+    alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;
     onError?: (error: Error) => void;
     handler: (payload: TPayload, metadata: TMetadata) => Promise<TResponse> | TResponse;
 }

package/dist/adapters/nextjs.js

@@ -3,23 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWebhookHandler = createWebhookHandler;
 const index_1 = require("../index");
 const queue_1 = require("../upstash/queue");
+const dispatch_1 = require("../notifications/dispatch");
 function createWebhookHandler(options) {
     return async (request) => {
         try {
             if (options.queue) {
                 const queueConfig = (0, queue_1.resolveQueueConfig)(options.queue);
-                return (0, queue_1.handleQueuedRequest)(request, {
+                const response = await (0, queue_1.handleQueuedRequest)(request, {
                     platform: options.platform,
                     secret: options.secret,
                     queueConfig,
                     handler: options.handler,
                     toleranceInSeconds: options.toleranceInSeconds ?? 300,
                 });
+                if (response.ok) {
+                    let eventId;
+                    try {
+                        const body = await response.clone().json();
+                        eventId = typeof body.eventId === 'string' ? body.eventId : undefined;
+                    }
+                    catch {
+                        eventId = undefined;
+                    }
+                    await (0, dispatch_1.dispatchWebhookAlert)({
+                        alerts: options.alerts,
+                        source: options.platform,
+                        eventId,
+                        alert: options.alert,
+                    });
+                }
+                return response;
             }
             const result = await index_1.WebhookVerificationService.verifyWithPlatformConfig(request, options.platform, options.secret, options.toleranceInSeconds, options.normalize);
             if (!result.isValid) {
                 return Response.json({ error: result.error, errorCode: result.errorCode, platform: result.platform, metadata: result.metadata }, { status: 400 });
             }
+            await (0, dispatch_1.dispatchWebhookAlert)({
+                alerts: options.alerts,
+                source: options.platform,
+                eventId: result.eventId,
+                alert: options.alert,
+            });
             const data = await options.handler(result.payload, (result.metadata || {}));
             return Response.json(data);
         }

package/dist/alerts.d.ts

@@ -0,0 +1,7 @@
+export * from './notifications';
+export declare const alertInternals: {
+    resolveDestinations: typeof import("./notifications/utils").resolveDestinations;
+    normalizeAlertOptions: typeof import("./notifications/utils").normalizeAlertOptions;
+    buildSlackPayload: typeof import("./notifications/channels/slack").buildSlackPayload;
+    buildDiscordPayload: typeof import("./notifications/channels/discord").buildDiscordPayload;
+};

package/dist/alerts.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alertInternals = void 0;
+const notifications_1 = require("./notifications");
+__exportStar(require("./notifications"), exports);
+// Backward-compatible alias used by previous version internals.
+exports.alertInternals = notifications_1.notificationInternals;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { WebhookConfig, WebhookVerificationResult, WebhookPlatform, SignatureConfig, MultiPlatformSecrets, NormalizeOptions } from './types';
 import type { QueueOption } from './upstash/types';
+import type { AlertConfig, SendAlertOptions } from './notifications/types';
 export declare class WebhookVerificationService {
     static verify<TPayload = unknown>(request: Request, config: WebhookConfig): Promise<WebhookVerificationResult<TPayload>>;
     private static getVerifier;
@@ -20,6 +21,8 @@ export declare class WebhookVerificationService {
         platform: WebhookPlatform;
         secret: string;
         queue: QueueOption;
+        alerts?: AlertConfig;
+        alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;
         handler: (payload: unknown, metadata: Record<string, unknown>) => Promise<unknown> | unknown;
         toleranceInSeconds?: number;
     }): Promise<Response>;
@@ -31,4 +34,5 @@ export { createAlgorithmVerifier } from './verifiers/algorithms';
 export { createCustomVerifier } from './verifiers/custom-algorithms';
 export { normalizePayload, getPlatformNormalizationCategory, getPlatformsByCategory, } from './normalization/simple';
 export * from './adapters';
+export * from './alerts';
 export default WebhookVerificationService;

package/dist/index.js

@@ -42,6 +42,7 @@ const algorithms_1 = require("./verifiers/algorithms");
 const custom_algorithms_1 = require("./verifiers/custom-algorithms");
 const algorithms_2 = require("./platforms/algorithms");
 const simple_1 = require("./normalization/simple");
+const dispatch_1 = require("./notifications/dispatch");
 class WebhookVerificationService {
     static async verify(request, config) {
         const verifier = this.getVerifier(config);
@@ -324,13 +325,30 @@ class WebhookVerificationService {
     static async handleWithQueue(request, options) {
         const { resolveQueueConfig, handleQueuedRequest } = await Promise.resolve().then(() => __importStar(require('./upstash/queue')));
         const queueConfig = resolveQueueConfig(options.queue);
-        return handleQueuedRequest(request, {
+        const response = await handleQueuedRequest(request, {
             platform: options.platform,
             secret: options.secret,
             queueConfig,
             handler: options.handler,
             toleranceInSeconds: options.toleranceInSeconds ?? 300,
         });
+        if (response.ok) {
+            let eventId;
+            try {
+                const body = await response.clone().json();
+                eventId = typeof body.eventId === 'string' ? body.eventId : undefined;
+            }
+            catch {
+                eventId = undefined;
+            }
+            await (0, dispatch_1.dispatchWebhookAlert)({
+                alerts: options.alerts,
+                source: options.platform,
+                eventId,
+                alert: options.alert,
+            });
+        }
+        return response;
     }
     static async verifyTokenBased(request, webhookId, webhookToken) {
         return this.verifyTokenAuth(request, webhookId, webhookToken);
@@ -352,4 +370,5 @@ Object.defineProperty(exports, "normalizePayload", { enumerable: true, get: func
 Object.defineProperty(exports, "getPlatformNormalizationCategory", { enumerable: true, get: function () { return simple_2.getPlatformNormalizationCategory; } });
 Object.defineProperty(exports, "getPlatformsByCategory", { enumerable: true, get: function () { return simple_2.getPlatformsByCategory; } });
 __exportStar(require("./adapters"), exports);
+__exportStar(require("./alerts"), exports);
 exports.default = WebhookVerificationService;

package/dist/notifications/channels/discord/build-payload.d.ts

@@ -0,0 +1,17 @@
+import type { AlertPayloadBuilderInput } from "../../types";
+export declare function buildDiscordPayload(input: AlertPayloadBuilderInput): {
+    embeds: {
+        title: string;
+        description: string;
+        color: number;
+        fields: {
+            name: string;
+            value: string;
+            inline?: boolean;
+        }[];
+        footer: {
+            text: string;
+        } | undefined;
+        timestamp: string;
+    }[];
+};

package/dist/notifications/channels/discord/build-payload.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDiscordPayload = buildDiscordPayload;
+const utils_1 = require("../../utils");
+const constants_1 = require("../../constants");
+function buildDiscordPayload(input) {
+    const isDLQ = input.dlq;
+    const fallbackTitle = isDLQ ? "Dead Letter Queue — Event Failed" : "Webhook Received";
+    const title = input.title?.trim() ? input.title : fallbackTitle;
+    const fallbackDescription = isDLQ
+        ? "Event exhausted all retries. Manual replay required."
+        : "Event verified and queued for processing.";
+    const description = input.message?.trim() ? input.message : fallbackDescription;
+    const fields = [];
+    if (input.source) {
+        fields.push({ name: "Platform", value: input.source, inline: true });
+    }
+    fields.push({
+        name: "Severity",
+        value: input.severity.toLowerCase(),
+        inline: true,
+    });
+    if (isDLQ) {
+        fields.push({ name: "Queue", value: "dlq", inline: true });
+    }
+    if (input.eventId) {
+        fields.push({
+            name: isDLQ ? "DLQ ID" : "Event ID",
+            value: `\`${input.eventId}\``,
+            inline: false,
+        });
+    }
+    const metadataString = (0, utils_1.compactMetadata)(input.metadata);
+    if (metadataString) {
+        fields.push({ name: "Details", value: `\`\`\`${metadataString}\`\`\`` });
+    }
+    const replayLine = input.replayUrl
+        ? `\n\n[${input.replayLabel ?? "Replay Event"}](${input.replayUrl})`
+        : "";
+    const footerText = input.branding === false ? undefined : "Alert from Tern · tern.hookflo.com";
+    return {
+        embeds: [
+            {
+                title,
+                description: `${description}${replayLine}`,
+                color: parseInt(constants_1.severityColorMap[input.severity].replace("#", ""), 16),
+                fields,
+                footer: footerText ? { text: footerText } : undefined,
+                timestamp: new Date().toISOString(),
+            },
+        ],
+    };
+}

package/dist/notifications/channels/discord/index.d.ts

@@ -0,0 +1 @@
+export { buildDiscordPayload } from './build-payload';

package/dist/notifications/channels/discord/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDiscordPayload = void 0;
+var build_payload_1 = require("./build-payload");
+Object.defineProperty(exports, "buildDiscordPayload", { enumerable: true, get: function () { return build_payload_1.buildDiscordPayload; } });

package/dist/notifications/channels/slack/build-payload.d.ts

@@ -0,0 +1,5 @@
+import type { AlertPayloadBuilderInput } from "../../types";
+export declare function buildSlackPayload(input: AlertPayloadBuilderInput): {
+    text: string;
+    blocks: Record<string, unknown>[];
+};

package/dist/notifications/channels/slack/build-payload.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSlackPayload = buildSlackPayload;
+const utils_1 = require("../../utils");
+const constants_1 = require("../../constants");
+function buildSlackPayload(input) {
+    const isDLQ = input.dlq;
+    const fallbackTitle = isDLQ ? "Dead Letter Queue — Event Failed" : "Webhook Received";
+    const title = input.title?.trim() ? input.title : fallbackTitle;
+    const fallbackMessage = isDLQ
+        ? "Event exhausted all retries. Manual replay required."
+        : "Event verified and queued for processing.";
+    const message = input.message?.trim() ? input.message : fallbackMessage;
+    const fields = [
+        input.source
+            ? { type: "mrkdwn", text: `*Platform*\n${input.source}` }
+            : null,
+        {
+            type: "mrkdwn",
+            text: `*Severity*\n${input.severity.toLowerCase()}`,
+        },
+        isDLQ ? { type: "mrkdwn", text: "*Queue*\ndlq" } : null,
+        input.eventId
+            ? {
+                type: "mrkdwn",
+                text: `*${isDLQ ? "DLQ ID" : "Event ID"}*\n\`${input.eventId}\``,
+            }
+            : null,
+    ].filter(Boolean);
+    const blocks = [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `*${title}*\n${message}`,
+            },
+            fields,
+        },
+    ];
+    const metadataString = (0, utils_1.compactMetadata)(input.metadata);
+    if (metadataString) {
+        blocks.push({
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `\`\`\`${metadataString}\`\`\``,
+            },
+        });
+    }
+    if (input.replayUrl) {
+        blocks.push({
+            type: "actions",
+            elements: [
+                {
+                    type: "button",
+                    text: {
+                        type: "plain_text",
+                        text: input.replayLabel ?? "Replay Event",
+                        emoji: false,
+                    },
+                    url: input.replayUrl,
+                    style: "danger",
+                },
+            ],
+        });
+    }
+    if (input.branding !== false) {
+        blocks.push({
+            type: "context",
+            elements: [
+                {
+                    type: "mrkdwn",
+                    text: `Alert from <${constants_1.TERN_BRAND_URL}|Tern>`,
+                },
+            ],
+        });
+    }
+    return {
+        text: title,
+        blocks,
+    };
+}

package/dist/notifications/channels/slack/index.d.ts

@@ -0,0 +1 @@
+export { buildSlackPayload } from './build-payload';

package/dist/notifications/channels/slack/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSlackPayload = void 0;
+var build_payload_1 = require("./build-payload");
+Object.defineProperty(exports, "buildSlackPayload", { enumerable: true, get: function () { return build_payload_1.buildSlackPayload; } });

package/dist/notifications/constants.d.ts

@@ -0,0 +1,8 @@
+import type { AlertSeverity } from './types';
+export declare const TERN_BRAND_URL = "https://tern.hookflo.com";
+export declare const DEFAULT_DLQ_TITLE = "Dead Letter Queue \u2014 Event Failed";
+export declare const DEFAULT_ALERT_TITLE = "Webhook Received";
+export declare const DEFAULT_REPLAY_LABEL = "Replay DLQ Event";
+export declare const DEFAULT_DLQ_MESSAGE = "Event exhausted all retries. Manual replay required.";
+export declare const DEFAULT_ALERT_MESSAGE = "Event verified and queued for processing.";
+export declare const severityColorMap: Record<AlertSeverity, string>;

package/dist/notifications/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.severityColorMap = exports.DEFAULT_ALERT_MESSAGE = exports.DEFAULT_DLQ_MESSAGE = exports.DEFAULT_REPLAY_LABEL = exports.DEFAULT_ALERT_TITLE = exports.DEFAULT_DLQ_TITLE = exports.TERN_BRAND_URL = void 0;
+exports.TERN_BRAND_URL = 'https://tern.hookflo.com';
+exports.DEFAULT_DLQ_TITLE = 'Dead Letter Queue — Event Failed';
+exports.DEFAULT_ALERT_TITLE = 'Webhook Received';
+exports.DEFAULT_REPLAY_LABEL = 'Replay DLQ Event';
+exports.DEFAULT_DLQ_MESSAGE = 'Event exhausted all retries. Manual replay required.';
+exports.DEFAULT_ALERT_MESSAGE = 'Event verified and queued for processing.';
+exports.severityColorMap = {
+    info: '#3B82F6',
+    warning: '#F59E0B',
+    error: '#EF4444',
+    critical: '#7C3AED',
+};

package/dist/notifications/dispatch.d.ts

@@ -0,0 +1,8 @@
+import type { AlertConfig, SendAlertOptions } from './types';
+export interface DispatchWebhookAlertInput {
+    alerts?: AlertConfig;
+    source?: string;
+    eventId?: string;
+    alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;
+}
+export declare function dispatchWebhookAlert(input: DispatchWebhookAlertInput): Promise<void>;

package/dist/notifications/dispatch.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchWebhookAlert = dispatchWebhookAlert;
+const send_alert_1 = require("./send-alert");
+async function dispatchWebhookAlert(input) {
+    if (!input.alerts)
+        return;
+    await (0, send_alert_1.sendAlert)(input.alerts, {
+        ...(input.alert || {}),
+        source: input.source,
+        eventId: input.eventId,
+    });
+}

package/dist/notifications/index.d.ts

@@ -0,0 +1,10 @@
+import { normalizeAlertOptions, resolveDestinations } from './utils';
+import { buildSlackPayload } from './channels/slack';
+import { buildDiscordPayload } from './channels/discord';
+export * from './types';
+export declare const notificationInternals: {
+    resolveDestinations: typeof resolveDestinations;
+    normalizeAlertOptions: typeof normalizeAlertOptions;
+    buildSlackPayload: typeof buildSlackPayload;
+    buildDiscordPayload: typeof buildDiscordPayload;
+};

package/dist/notifications/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationInternals = void 0;
+const utils_1 = require("./utils");
+const slack_1 = require("./channels/slack");
+const discord_1 = require("./channels/discord");
+__exportStar(require("./types"), exports);
+exports.notificationInternals = {
+    resolveDestinations: utils_1.resolveDestinations,
+    normalizeAlertOptions: utils_1.normalizeAlertOptions,
+    buildSlackPayload: slack_1.buildSlackPayload,
+    buildDiscordPayload: discord_1.buildDiscordPayload,
+};

package/dist/notifications/send-alert.d.ts

@@ -0,0 +1,2 @@
+import type { AlertConfig, SendAlertOptions, SendAlertSummary } from './types';
+export declare function sendAlert(config: AlertConfig, options: SendAlertOptions): Promise<SendAlertSummary>;

package/dist/notifications/send-alert.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendAlert = sendAlert;
+const utils_1 = require("./utils");
+const slack_1 = require("./channels/slack");
+const discord_1 = require("./channels/discord");
+async function postWebhook(webhookUrl, body) {
+    try {
+        const response = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                status: response.status,
+                error: `Webhook call failed with ${response.status}`,
+            };
+        }
+        return { ok: true, status: response.status };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error.message,
+        };
+    }
+}
+function buildPayload(channel, options) {
+    const normalized = (0, utils_1.normalizeAlertOptions)(options);
+    return channel === 'slack' ? (0, slack_1.buildSlackPayload)(normalized) : (0, discord_1.buildDiscordPayload)(normalized);
+}
+async function sendAlert(config, options) {
+    const destinations = (0, utils_1.resolveDestinations)(config);
+    if (destinations.length === 0) {
+        return {
+            success: false,
+            total: 0,
+            delivered: 0,
+            results: [{
+                    channel: 'slack',
+                    webhookUrl: '',
+                    ok: false,
+                    error: 'No valid alert webhook destinations configured',
+                }],
+        };
+    }
+    const results = await Promise.all(destinations.map(async (destination) => {
+        const payload = buildPayload(destination.channel, options);
+        const response = await postWebhook(destination.webhookUrl, payload);
+        return {
+            channel: destination.channel,
+            webhookUrl: destination.webhookUrl,
+            ok: response.ok,
+            status: response.status,
+            error: response.error,
+        };
+    }));
+    const delivered = results.filter((result) => result.ok).length;
+    return {
+        success: delivered === results.length,
+        total: results.length,
+        delivered,
+        results,
+    };
+}