@hookflo/tern 4.2.9-beta → 4.3.0-beta-1

package/dist/adapters/cloudflare.d.ts

@@ -1,4 +1,4 @@
-import { WebhookPlatform, NormalizeOptions } from '../types';
+import { WebhookPlatform } 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> {
@@ -6,7 +6,7 @@ export interface CloudflareWebhookHandlerOptions<TEnv = Record<string, unknown>,
     secret?: string;
     secretEnv?: string;
     toleranceInSeconds?: number;
-    normalize?: boolean | NormalizeOptions;
+    twilioBaseUrl?: string;
     queue?: QueueOption;
     alerts?: AlertConfig;
     alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;

package/dist/adapters/cloudflare.js

@@ -39,7 +39,12 @@ function createWebhookHandler(options) {
                 }
                 return response;
             }
-            const result = await index_1.WebhookVerificationService.verifyWithPlatformConfig(request, options.platform, secret, options.toleranceInSeconds, options.normalize);
+            const result = await index_1.WebhookVerificationService.verify(request, {
+                platform: options.platform,
+                secret,
+                toleranceInSeconds: options.toleranceInSeconds,
+                twilioBaseUrl: options.twilioBaseUrl,
+            });
             if (!result.isValid) {
                 return Response.json({ error: result.error, errorCode: result.errorCode, platform: result.platform, metadata: result.metadata }, { status: 400 });
             }

package/dist/adapters/express.d.ts

@@ -1,4 +1,4 @@
-import { WebhookPlatform, WebhookVerificationResult, NormalizeOptions } from '../types';
+import { WebhookPlatform, WebhookVerificationResult } from '../types';
 import { QueueOption } from '../upstash/types';
 import { MinimalNodeRequest } from './shared';
 import type { AlertConfig, SendAlertOptions } from '../notifications/types';
@@ -14,7 +14,7 @@ export interface ExpressWebhookMiddlewareOptions {
     platform: WebhookPlatform;
     secret: string;
     toleranceInSeconds?: number;
-    normalize?: boolean | NormalizeOptions;
+    twilioBaseUrl?: string;
     queue?: QueueOption;
     alerts?: AlertConfig;
     alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;

package/dist/adapters/express.js

@@ -48,7 +48,12 @@ function createWebhookMiddleware(options) {
                 }
                 return;
             }
-            const result = await index_1.WebhookVerificationService.verifyWithPlatformConfig(webRequest, options.platform, options.secret, options.toleranceInSeconds, options.normalize);
+            const result = await index_1.WebhookVerificationService.verify(webRequest, {
+                platform: options.platform,
+                secret: options.secret,
+                toleranceInSeconds: options.toleranceInSeconds,
+                twilioBaseUrl: options.twilioBaseUrl,
+            });
             if (!result.isValid) {
                 res.status(400).json({
                     error: result.error,

package/dist/adapters/hono.d.ts

@@ -0,0 +1,21 @@
+import { WebhookPlatform } from '../types';
+import { QueueOption } from '../upstash/types';
+import type { AlertConfig, SendAlertOptions } from '../notifications/types';
+export interface HonoContextLike {
+    req: {
+        raw: Request;
+    };
+    json: (payload: unknown, status?: number) => Response;
+}
+export interface HonoWebhookHandlerOptions<TContext extends HonoContextLike = HonoContextLike, TPayload = any, TMetadata extends Record<string, unknown> = Record<string, unknown>, TResponse = unknown> {
+    platform: WebhookPlatform;
+    secret: string;
+    toleranceInSeconds?: number;
+    twilioBaseUrl?: string;
+    queue?: QueueOption;
+    alerts?: AlertConfig;
+    alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;
+    onError?: (error: Error) => void;
+    handler: (payload: TPayload, metadata: TMetadata, c: TContext) => Promise<TResponse> | TResponse;
+}
+export declare function createWebhookHandler<TContext extends HonoContextLike = HonoContextLike, TPayload = any, TMetadata extends Record<string, unknown> = Record<string, unknown>, TResponse = unknown>(options: HonoWebhookHandlerOptions<TContext, TPayload, TMetadata, TResponse>): (c: TContext) => Promise<Response>;

package/dist/adapters/hono.js

@@ -0,0 +1,74 @@
+"use strict";
+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 (c) => {
+        try {
+            const request = c.req.raw;
+            if (options.queue) {
+                const queueConfig = (0, queue_1.resolveQueueConfig)(options.queue);
+                const response = await (0, queue_1.handleQueuedRequest)(request, {
+                    platform: options.platform,
+                    secret: options.secret,
+                    queueConfig,
+                    handler: (payload, metadata) => options.handler(payload, metadata, c),
+                    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.verify(request, {
+                platform: options.platform,
+                secret: options.secret,
+                toleranceInSeconds: options.toleranceInSeconds,
+                twilioBaseUrl: options.twilioBaseUrl,
+            });
+            if (!result.isValid) {
+                return c.json({
+                    error: result.error,
+                    errorCode: result.errorCode,
+                    platform: result.platform,
+                    metadata: result.metadata,
+                }, 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 || {}), c);
+            if (data instanceof Response) {
+                return data;
+            }
+            return c.json(data);
+        }
+        catch (error) {
+            if (options.onError) {
+                options.onError(error);
+            }
+            else {
+                console.error('[tern/hono]', error);
+            }
+            return c.json({ error: error.message }, 500);
+        }
+    };
+}

package/dist/adapters/index.d.ts

@@ -2,3 +2,4 @@ export { createWebhookMiddleware, ExpressWebhookMiddlewareOptions, ExpressLikeRe
 export { createWebhookHandler as createNextjsWebhookHandler, NextWebhookHandlerOptions, } from './nextjs';
 export { createWebhookHandler as createCloudflareWebhookHandler, CloudflareWebhookHandlerOptions, } from './cloudflare';
 export { toWebRequest, extractRawBody } from './shared';
+export { createWebhookHandler as createHonoWebhookHandler, HonoWebhookHandlerOptions, HonoContextLike, } from './hono';

package/dist/adapters/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractRawBody = exports.toWebRequest = exports.createCloudflareWebhookHandler = exports.createNextjsWebhookHandler = exports.createWebhookMiddleware = void 0;
+exports.createHonoWebhookHandler = exports.extractRawBody = exports.toWebRequest = exports.createCloudflareWebhookHandler = exports.createNextjsWebhookHandler = exports.createWebhookMiddleware = void 0;
 var express_1 = require("./express");
 Object.defineProperty(exports, "createWebhookMiddleware", { enumerable: true, get: function () { return express_1.createWebhookMiddleware; } });
 var nextjs_1 = require("./nextjs");
@@ -10,3 +10,5 @@ Object.defineProperty(exports, "createCloudflareWebhookHandler", { enumerable: t
 var shared_1 = require("./shared");
 Object.defineProperty(exports, "toWebRequest", { enumerable: true, get: function () { return shared_1.toWebRequest; } });
 Object.defineProperty(exports, "extractRawBody", { enumerable: true, get: function () { return shared_1.extractRawBody; } });
+var hono_1 = require("./hono");
+Object.defineProperty(exports, "createHonoWebhookHandler", { enumerable: true, get: function () { return hono_1.createWebhookHandler; } });

package/dist/adapters/nextjs.d.ts

@@ -1,11 +1,11 @@
-import { WebhookPlatform, NormalizeOptions } from '../types';
+import { WebhookPlatform } 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;
+    twilioBaseUrl?: string;
     queue?: QueueOption;
     alerts?: AlertConfig;
     alert?: Omit<SendAlertOptions, 'dlq' | 'dlqId' | 'source' | 'eventId'>;

package/dist/adapters/nextjs.js

@@ -34,7 +34,12 @@ function createWebhookHandler(options) {
                 }
                 return response;
             }
-            const result = await index_1.WebhookVerificationService.verifyWithPlatformConfig(request, options.platform, options.secret, options.toleranceInSeconds, options.normalize);
+            const result = await index_1.WebhookVerificationService.verify(request, {
+                platform: options.platform,
+                secret: options.secret,
+                toleranceInSeconds: options.toleranceInSeconds,
+                twilioBaseUrl: options.twilioBaseUrl,
+            });
             if (!result.isValid) {
                 return Response.json({ error: result.error, errorCode: result.errorCode, platform: result.platform, metadata: result.metadata }, { status: 400 });
             }

package/dist/adapters/shared.js

@@ -90,8 +90,11 @@ function toHeadersInit(headers) {
     return normalized;
 }
 async function toWebRequest(request) {
-    const protocol = request.protocol || 'https';
-    const host = request.get?.('host')
+    const forwardedProto = getHeaderValue(request.headers, 'x-forwarded-proto')?.split(',')[0]?.trim();
+    const protocol = forwardedProto || request.protocol || 'https';
+    const forwardedHost = getHeaderValue(request.headers, 'x-forwarded-host')?.split(',')[0]?.trim();
+    const host = forwardedHost
+        || request.get?.('host')
         || getHeaderValue(request.headers, 'host')
         || 'localhost';
     const path = request.originalUrl || request.url || '/';

package/dist/hono.d.ts

@@ -0,0 +1,2 @@
+export { createWebhookHandler } from './adapters/hono';
+export type { HonoContextLike, HonoWebhookHandlerOptions, } from './adapters/hono';

package/dist/hono.js

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

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { WebhookConfig, WebhookVerificationResult, WebhookPlatform, SignatureConfig, MultiPlatformSecrets, NormalizeOptions } from './types';
+import { WebhookConfig, WebhookVerificationResult, WebhookPlatform, SignatureConfig, MultiPlatformSecrets } from './types';
 import type { QueueOption } from './upstash/types';
 import type { AlertConfig, SendAlertOptions } from './notifications/types';
 export declare class WebhookVerificationService {
@@ -6,8 +6,8 @@ export declare class WebhookVerificationService {
     private static getVerifier;
     private static createAlgorithmBasedVerifier;
     private static getLegacyVerifier;
-    static verifyWithPlatformConfig<TPayload = unknown>(request: Request, platform: WebhookPlatform, secret: string, toleranceInSeconds?: number, normalize?: boolean | NormalizeOptions): Promise<WebhookVerificationResult<TPayload>>;
-    static verifyAny<TPayload = unknown>(request: Request, secrets: MultiPlatformSecrets, toleranceInSeconds?: number, normalize?: boolean | NormalizeOptions): Promise<WebhookVerificationResult<TPayload>>;
+    static verifyWithPlatformConfig<TPayload = unknown>(request: Request, platform: WebhookPlatform, secret: string, toleranceInSeconds?: number): Promise<WebhookVerificationResult<TPayload>>;
+    static verifyAny<TPayload = unknown>(request: Request, secrets: MultiPlatformSecrets, toleranceInSeconds?: number): Promise<WebhookVerificationResult<TPayload>>;
     private static resolveCanonicalEventId;
     private static safeCompare;
     private static pickString;
@@ -32,7 +32,6 @@ export * from './types';
 export { getPlatformAlgorithmConfig, platformUsesAlgorithm, getPlatformsUsingAlgorithm, validateSignatureConfig, } from './platforms/algorithms';
 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

@@ -36,12 +36,11 @@ 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.getPlatformsByCategory = exports.getPlatformNormalizationCategory = exports.normalizePayload = exports.createCustomVerifier = exports.createAlgorithmVerifier = exports.validateSignatureConfig = exports.getPlatformsUsingAlgorithm = exports.platformUsesAlgorithm = exports.getPlatformAlgorithmConfig = exports.WebhookVerificationService = void 0;
+exports.createCustomVerifier = exports.createAlgorithmVerifier = exports.validateSignatureConfig = exports.getPlatformsUsingAlgorithm = exports.platformUsesAlgorithm = exports.getPlatformAlgorithmConfig = exports.WebhookVerificationService = void 0;
 const crypto_1 = require("crypto");
 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) {
@@ -51,9 +50,6 @@ class WebhookVerificationService {
         if (result.isValid) {
             result.platform = config.platform;
             result.eventId = this.resolveCanonicalEventId(config.platform, result.metadata, result.payload) ?? undefined;
-            if (config.normalize) {
-                result.payload = (0, simple_1.normalizePayload)(config.platform, result.payload, config.normalize);
-            }
         }
         return result;
     }
@@ -70,12 +66,21 @@ class WebhookVerificationService {
         if (!signatureConfig) {
             throw new Error('Signature config is required for algorithm-based verification');
         }
+        const effectiveSignatureConfig = {
+            ...signatureConfig,
+            customConfig: {
+                ...(signatureConfig.customConfig || {}),
+                ...(config.platform === 'twilio' && config.twilioBaseUrl
+                    ? { twilioBaseUrl: config.twilioBaseUrl }
+                    : {}),
+            },
+        };
         // Use custom verifiers for special cases (token-based, etc.)
-        if (signatureConfig.algorithm === 'custom') {
-            return (0, custom_algorithms_1.createCustomVerifier)(secret, signatureConfig, toleranceInSeconds);
+        if (effectiveSignatureConfig.algorithm === 'custom') {
+            return (0, custom_algorithms_1.createCustomVerifier)(secret, effectiveSignatureConfig, toleranceInSeconds);
         }
         // Use algorithm-based verifiers for standard algorithms
-        return (0, algorithms_1.createAlgorithmVerifier)(secret, signatureConfig, config.platform, toleranceInSeconds);
+        return (0, algorithms_1.createAlgorithmVerifier)(secret, effectiveSignatureConfig, config.platform, toleranceInSeconds);
     }
     static getLegacyVerifier(config) {
         // For legacy support, we'll use the algorithm-based approach
@@ -87,29 +92,28 @@ class WebhookVerificationService {
         return this.createAlgorithmBasedVerifier(configWithSignature);
     }
     // New method to create verifier using platform algorithm config
-    static async verifyWithPlatformConfig(request, platform, secret, toleranceInSeconds = 300, normalize = false) {
+    static async verifyWithPlatformConfig(request, platform, secret, toleranceInSeconds = 300) {
         const platformConfig = (0, algorithms_2.getPlatformAlgorithmConfig)(platform);
         const config = {
             platform,
             secret,
             toleranceInSeconds,
-            signatureConfig: platformConfig.signatureConfig,
-            normalize,
+            signatureConfig: platformConfig.signatureConfig
         };
         return this.verify(request, config);
     }
-    static async verifyAny(request, secrets, toleranceInSeconds = 300, normalize = false) {
+    static async verifyAny(request, secrets, toleranceInSeconds = 300) {
         const requestClone = request.clone();
         const detectedPlatform = this.detectPlatform(requestClone);
         if (detectedPlatform !== 'unknown' && secrets[detectedPlatform]) {
-            return this.verifyWithPlatformConfig(requestClone, detectedPlatform, secrets[detectedPlatform], toleranceInSeconds, normalize);
+            return this.verifyWithPlatformConfig(requestClone, detectedPlatform, secrets[detectedPlatform], toleranceInSeconds);
         }
         const failedAttempts = [];
         const verificationResults = await Promise.all(Object.entries(secrets)
             .filter(([, secret]) => Boolean(secret))
             .map(async ([platform, secret]) => {
             const normalizedPlatform = platform.toLowerCase();
-            const result = await this.verifyWithPlatformConfig(requestClone, normalizedPlatform, secret, toleranceInSeconds, normalize);
+            const result = await this.verifyWithPlatformConfig(requestClone, normalizedPlatform, secret, toleranceInSeconds);
             return {
                 platform: normalizedPlatform,
                 result,
@@ -189,6 +193,10 @@ class WebhookVerificationService {
             case 'workos':
             case 'sentry':
             case 'vercel':
+            case 'linear':
+            case 'pagerduty':
+            case 'twilio':
+            case 'svix':
                 return this.pickString(payload?.id) || null;
             case 'doppler':
                 return this.pickString(payload?.event?.id, metadata?.id) || null;
@@ -220,7 +228,13 @@ class WebhookVerificationService {
         if (headers.has('x-hub-signature-256'))
             return 'github';
         if (headers.has('svix-signature'))
-            return 'clerk';
+            return headers.has('svix-id') ? 'svix' : 'clerk';
+        if (headers.has('linear-signature'))
+            return 'linear';
+        if (headers.has('x-pagerduty-signature'))
+            return 'pagerduty';
+        if (headers.has('x-twilio-signature'))
+            return 'twilio';
         if (headers.has('workos-signature'))
             return 'workos';
         if (headers.has('webhook-signature')) {
@@ -365,10 +379,6 @@ var algorithms_4 = require("./verifiers/algorithms");
 Object.defineProperty(exports, "createAlgorithmVerifier", { enumerable: true, get: function () { return algorithms_4.createAlgorithmVerifier; } });
 var custom_algorithms_2 = require("./verifiers/custom-algorithms");
 Object.defineProperty(exports, "createCustomVerifier", { enumerable: true, get: function () { return custom_algorithms_2.createCustomVerifier; } });
-var simple_2 = require("./normalization/simple");
-Object.defineProperty(exports, "normalizePayload", { enumerable: true, get: function () { return simple_2.normalizePayload; } });
-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/platforms/algorithms.js

@@ -51,6 +51,27 @@ exports.platformAlgorithmConfigs = {
         },
         description: "Clerk webhooks use HMAC-SHA256 with base64 encoding",
     },
+    svix: {
+        platform: 'svix',
+        signatureConfig: {
+            algorithm: 'hmac-sha256',
+            headerName: 'svix-signature',
+            headerFormat: 'raw',
+            timestampHeader: 'svix-timestamp',
+            timestampFormat: 'unix',
+            payloadFormat: 'custom',
+            customConfig: {
+                signatureFormat: 'v1={signature}',
+                payloadFormat: '{id}.{timestamp}.{body}',
+                encoding: 'base64',
+                secretEncoding: 'base64',
+                idHeader: 'svix-id',
+                idHeaderAliases: ['webhook-id'],
+                timestampHeaderAliases: ['webhook-timestamp'],
+            },
+        },
+        description: 'Svix webhooks use HMAC-SHA256 with Standard Webhooks format',
+    },
     dodopayments: {
         platform: "dodopayments",
         signatureConfig: {
@@ -287,6 +308,50 @@ exports.platformAlgorithmConfigs = {
         },
         description: "Sanity webhooks use Stripe-compatible HMAC-SHA256 with base64 encoded signature and plain UTF-8 secret",
     },
+    linear: {
+        platform: 'linear',
+        signatureConfig: {
+            algorithm: 'hmac-sha256',
+            headerName: 'linear-signature',
+            headerFormat: 'raw',
+            payloadFormat: 'raw',
+            customConfig: {
+                replayToleranceMs: 60000,
+            },
+        },
+        description: 'Linear webhooks use HMAC-SHA256 on the raw body with a 60s timestamp replay window',
+    },
+    pagerduty: {
+        platform: 'pagerduty',
+        signatureConfig: {
+            algorithm: 'hmac-sha256',
+            headerName: 'x-pagerduty-signature',
+            headerFormat: 'raw',
+            payloadFormat: 'raw',
+            prefix: 'v1=',
+            customConfig: {
+                signatureFormat: 'v1={signature}',
+                comparePrefixed: true,
+            },
+        },
+        description: 'PagerDuty webhooks use HMAC-SHA256 with v1=<hex> signatures',
+    },
+    twilio: {
+        platform: 'twilio',
+        signatureConfig: {
+            algorithm: 'hmac-sha1',
+            headerName: 'x-twilio-signature',
+            headerFormat: 'raw',
+            payloadFormat: 'custom',
+            customConfig: {
+                payloadFormat: '{url}',
+                encoding: 'base64',
+                secretEncoding: 'utf8',
+                validateBodySHA256: true,
+            },
+        },
+        description: 'Twilio webhooks use HMAC-SHA1 with base64 signatures (URL canonicalization required)',
+    },
     custom: {
         platform: "custom",
         signatureConfig: {

package/dist/types.d.ts

@@ -1,8 +1,9 @@
-export type WebhookPlatform = 'custom' | 'clerk' | 'github' | 'stripe' | 'shopify' | 'vercel' | 'polar' | 'dodopayments' | 'gitlab' | 'paddle' | 'razorpay' | 'lemonsqueezy' | 'workos' | 'woocommerce' | 'replicateai' | 'falai' | 'sentry' | 'grafana' | 'doppler' | 'sanity' | 'unknown';
+export type WebhookPlatform = 'custom' | 'clerk' | 'svix' | 'github' | 'stripe' | 'shopify' | 'vercel' | 'polar' | 'dodopayments' | 'gitlab' | 'paddle' | 'razorpay' | 'lemonsqueezy' | 'workos' | 'woocommerce' | 'replicateai' | 'falai' | 'sentry' | 'grafana' | 'doppler' | 'sanity' | 'linear' | 'pagerduty' | 'twilio' | 'unknown';
 export declare enum WebhookPlatformKeys {
     GitHub = "github",
     Stripe = "stripe",
     Clerk = "clerk",
+    Svix = "svix",
     DodoPayments = "dodopayments",
     Shopify = "shopify",
     Vercel = "vercel",
@@ -19,6 +20,9 @@ export declare enum WebhookPlatformKeys {
     Grafana = "grafana",
     Doppler = "doppler",
     Sanity = "sanity",
+    Linear = "linear",
+    PagerDuty = "pagerduty",
+    Twilio = "twilio",
     Custom = "custom",
     Unknown = "unknown"
 }
@@ -35,69 +39,6 @@ export interface SignatureConfig {
     customConfig?: Record<string, any>;
 }
 export type WebhookErrorCode = 'MISSING_SIGNATURE' | 'INVALID_SIGNATURE' | 'TIMESTAMP_EXPIRED' | 'MISSING_TOKEN' | 'INVALID_TOKEN' | 'PLATFORM_NOT_SUPPORTED' | 'NORMALIZATION_ERROR' | 'VERIFICATION_ERROR';
-export type NormalizationCategory = 'payment' | 'auth' | 'ecommerce' | 'infrastructure';
-export interface BaseNormalizedWebhook {
-    category: NormalizationCategory;
-    event: string;
-    _platform: WebhookPlatform | string;
-    _raw: unknown;
-    occurred_at?: string;
-}
-export type PaymentWebhookEvent = 'payment.succeeded' | 'payment.failed' | 'payment.refunded' | 'subscription.created' | 'subscription.cancelled' | 'payment.unknown';
-export interface PaymentWebhookNormalized extends BaseNormalizedWebhook {
-    category: 'payment';
-    event: PaymentWebhookEvent;
-    amount?: number;
-    currency?: string;
-    customer_id?: string;
-    transaction_id?: string;
-    subscription_id?: string;
-    refund_amount?: number;
-    failure_reason?: string;
-    metadata?: Record<string, string>;
-}
-export type AuthWebhookEvent = 'user.created' | 'user.updated' | 'user.deleted' | 'session.started' | 'session.ended' | 'auth.unknown';
-export interface AuthWebhookNormalized extends BaseNormalizedWebhook {
-    category: 'auth';
-    event: AuthWebhookEvent;
-    user_id?: string;
-    email?: string;
-    phone?: string;
-    metadata?: Record<string, string>;
-}
-export interface EcommerceWebhookNormalized extends BaseNormalizedWebhook {
-    category: 'ecommerce';
-    event: string;
-    order_id?: string;
-    customer_id?: string;
-    amount?: number;
-    currency?: string;
-    metadata?: Record<string, string>;
-}
-export interface InfrastructureWebhookNormalized extends BaseNormalizedWebhook {
-    category: 'infrastructure';
-    event: string;
-    project_id?: string;
-    deployment_id?: string;
-    status?: 'queued' | 'building' | 'ready' | 'error' | 'unknown';
-    metadata?: Record<string, string>;
-}
-export interface UnknownNormalizedWebhook extends BaseNormalizedWebhook {
-    event: string;
-    warning?: string;
-}
-export type NormalizedPayloadByCategory = {
-    payment: PaymentWebhookNormalized;
-    auth: AuthWebhookNormalized;
-    ecommerce: EcommerceWebhookNormalized;
-    infrastructure: InfrastructureWebhookNormalized;
-};
-export type AnyNormalizedWebhook = PaymentWebhookNormalized | AuthWebhookNormalized | EcommerceWebhookNormalized | InfrastructureWebhookNormalized | UnknownNormalizedWebhook;
-export interface NormalizeOptions {
-    enabled?: boolean;
-    category?: NormalizationCategory;
-    includeRaw?: boolean;
-}
 export interface WebhookVerificationResult<TPayload = unknown> {
     isValid: boolean;
     error?: string;
@@ -116,7 +57,7 @@ export interface WebhookConfig {
     secret: string;
     toleranceInSeconds?: number;
     signatureConfig?: SignatureConfig;
-    normalize?: boolean | NormalizeOptions;
+    twilioBaseUrl?: string;
 }
 export interface MultiPlatformSecrets {
     [platform: string]: string | undefined;

package/dist/types.js

@@ -6,6 +6,7 @@ var WebhookPlatformKeys;
     WebhookPlatformKeys["GitHub"] = "github";
     WebhookPlatformKeys["Stripe"] = "stripe";
     WebhookPlatformKeys["Clerk"] = "clerk";
+    WebhookPlatformKeys["Svix"] = "svix";
     WebhookPlatformKeys["DodoPayments"] = "dodopayments";
     WebhookPlatformKeys["Shopify"] = "shopify";
     WebhookPlatformKeys["Vercel"] = "vercel";
@@ -22,6 +23,9 @@ var WebhookPlatformKeys;
     WebhookPlatformKeys["Grafana"] = "grafana";
     WebhookPlatformKeys["Doppler"] = "doppler";
     WebhookPlatformKeys["Sanity"] = "sanity";
+    WebhookPlatformKeys["Linear"] = "linear";
+    WebhookPlatformKeys["PagerDuty"] = "pagerduty";
+    WebhookPlatformKeys["Twilio"] = "twilio";
     WebhookPlatformKeys["Custom"] = "custom";
     WebhookPlatformKeys["Unknown"] = "unknown";
 })(WebhookPlatformKeys || (exports.WebhookPlatformKeys = WebhookPlatformKeys = {}));

package/dist/verifiers/algorithms.d.ts

@@ -5,11 +5,17 @@ export declare abstract class AlgorithmBasedVerifier extends WebhookVerifier {
     protected platform: WebhookPlatform;
     constructor(secret: string, config: SignatureConfig, platform: WebhookPlatform, toleranceInSeconds?: number);
     abstract verify(request: Request): Promise<WebhookVerificationResult>;
+    protected getMissingSignatureMessage(): string;
+    protected getMissingTimestampMessage(): string;
+    protected getTimestampExpiredMessage(): string;
+    protected getInvalidSignatureMessage(): string;
+    protected getVerificationErrorMessage(error: Error): string;
     protected parseDelimitedHeader(headerValue: string): Record<string, string>;
     protected extractSignatures(request: Request): string[];
     protected extractTimestamp(request: Request): number | null;
     protected extractTimestampFromSignature(request: Request): number | null;
     protected requiresTimestamp(): boolean;
+    protected resolveTwilioSignatureUrl(request: Request): string;
     protected formatPayload(rawBody: string, request: Request): string;
     protected formatCustomPayload(rawBody: string, request: Request): string;
     protected verifyHMAC(payload: string, signature: string, algorithm?: string): boolean;
@@ -18,6 +24,8 @@ export declare abstract class AlgorithmBasedVerifier extends WebhookVerifier {
     protected extractMetadata(request: Request): Record<string, any>;
 }
 export declare class GenericHMACVerifier extends AlgorithmBasedVerifier {
+    private validateLinearReplayWindow;
+    private validateTwilioBodyHash;
     private resolveSentryPayloadCandidates;
     verify(request: Request): Promise<WebhookVerificationResult>;
 }