@hookflo/tern 4.3.0-beta.0 → 4.3.0-beta.1

package/README.md

@@ -79,6 +79,27 @@ const result = await WebhookVerificationService.verifyAny(request, {
 console.log(`Verified ${result.platform} webhook`);
 ```
 
+### Twilio example
+
+```typescript
+import { WebhookVerificationService } from '@hookflo/tern';
+
+export async function POST(request: Request) {
+  const result = await WebhookVerificationService.verify(request, {
+    platform: 'twilio',
+    secret: process.env.TWILIO_AUTH_TOKEN!,
+    // Optional when behind proxies/CDNs if request.url differs from the public Twilio URL:
+    twilioBaseUrl: 'https://yourdomain.com/api/webhooks/twilio',
+  });
+
+  if (!result.isValid) {
+    return Response.json({ error: result.error }, { status: 400 });
+  }
+
+  return Response.json({ ok: true });
+}
+```
+
 ### Core SDK (runtime-agnostic)
 
 Use Tern without framework adapters in any runtime that supports the Web `Request` API.
@@ -171,6 +192,9 @@ app.post('/webhooks/stripe', createWebhookHandler({
 
 ## Supported Platforms
 
+> ⚠️ Normalization is no longer supported in Tern and has been removed from the public verification APIs.
+
+
 | Platform | Algorithm | Status |
 |---|---|---|
 | **Stripe** | HMAC-SHA256 | ✅ Tested |
@@ -189,6 +213,10 @@ app.post('/webhooks/stripe', createWebhookHandler({
 | **Grafana** | HMAC-SHA256 | ✅ Tested |
 | **Doppler** | HMAC-SHA256 | ✅ Tested |
 | **Sanity** | HMAC-SHA256 | ✅ Tested |
+| **Svix** | HMAC-SHA256 | ⚠️ Untested for now |
+| **Linear** | HMAC-SHA256 | ⚠️ Untested for now |
+| **PagerDuty** | HMAC-SHA256 | ⚠️ Untested for now |
+| **Twilio** | HMAC-SHA1 | ⚠️ Untested for now |
 | **Razorpay** | HMAC-SHA256 | 🔄 Pending |
 | **Vercel** | HMAC-SHA256 | 🔄 Pending |
 
@@ -403,6 +431,9 @@ interface WebhookVerificationResult {
 
 ## Troubleshooting
 
+- **Twilio invalid signature behind proxies/CDNs**: if your runtime `request.url` differs from the public Twilio webhook URL, pass `twilioBaseUrl` in `WebhookVerificationService.verify(...)` for platform `twilio`.
+
+
 **`Module not found: Can't resolve "@hookflo/tern/nextjs"`**
 
 ```bash

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

@@ -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 HonoContextLike {
@@ -11,7 +11,7 @@ export interface HonoWebhookHandlerOptions<TContext extends HonoContextLike = Ho
     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/hono.js

@@ -35,7 +35,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 c.json({
                     error: result.error,

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/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>;
 }