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

package/dist/verifiers/algorithms.js

@@ -13,6 +13,40 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
         this.config = config;
         this.platform = platform;
     }
+    getMissingSignatureMessage() {
+        return `Missing signature header: ${this.config.headerName}. Ensure your webhook provider sends this header and your adapter forwards it unchanged.`;
+    }
+    getMissingTimestampMessage() {
+        const timestampHeader = this.config.timestampHeader || this.config.customConfig?.timestampHeader || 'timestamp';
+        return `Missing required timestamp for webhook verification. Verify header '${timestampHeader}' is present and passed through by your framework/proxy.`;
+    }
+    getTimestampExpiredMessage() {
+        return 'Webhook timestamp expired. Check server clock drift and increase tolerance only if your provider allows it.';
+    }
+    getInvalidSignatureMessage() {
+        const genericHint = `Invalid signature for ${this.platform}. Confirm webhook secret, raw request body handling, and signature header formatting.`;
+        switch (this.platform) {
+            case 'twilio':
+                return `${genericHint} Twilio also requires the exact public URL used for signing (including query params like bodySHA256). Use twilioBaseUrl if your runtime URL is rewritten behind a proxy.`;
+            case 'stripe':
+                return `${genericHint} Stripe signatures require the exact raw body and Stripe-Signature timestamp/value pair.`;
+            case 'github':
+                return `${genericHint} GitHub signatures must include the sha256= prefix from x-hub-signature-256.`;
+            case 'svix':
+            case 'clerk':
+            case 'dodopayments':
+            case 'replicateai':
+            case 'polar':
+                return `${genericHint} Standard Webhooks payload must be signed as id.timestamp.body and secrets may need whsec_ base64 decoding.`;
+            case 'pagerduty':
+                return `${genericHint} PagerDuty expects v1=<hex> signature values from x-pagerduty-signature.`;
+            default:
+                return genericHint;
+        }
+    }
+    getVerificationErrorMessage(error) {
+        return `${this.platform} verification error: ${error.message}. Check webhook secret configuration and ensure your framework preserves raw body + headers.`;
+    }
     parseDelimitedHeader(headerValue) {
         const parts = headerValue.split(/[;,]/);
         const values = {};
@@ -63,9 +97,34 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
                         }
                         // Accept "v1=<signature>" variants used by some providers/docs.
                         if (sig.startsWith("v1=")) {
-                            const [, value] = sig.split("=", 2);
-                            if (value) {
-                                normalized.push(value.trim());
+                            if (this.config.customConfig?.comparePrefixed) {
+                                for (const fragment of sig.split(',')) {
+                                    const candidate = fragment.trim();
+                                    if (candidate.startsWith('v1=')) {
+                                        normalized.push(candidate);
+                                    }
+                                }
+                            }
+                            else {
+                                const [, value] = sig.split("=", 2);
+                                if (value) {
+                                    normalized.push(value.trim());
+                                }
+                            }
+                            continue;
+                        }
+                        for (const fragment of sig.split(',')) {
+                            const candidate = fragment.trim();
+                            if (candidate.startsWith('v1=')) {
+                                if (this.config.customConfig?.comparePrefixed) {
+                                    normalized.push(candidate);
+                                }
+                                else {
+                                    const [, value] = candidate.split('=', 2);
+                                    if (value) {
+                                        normalized.push(value.trim());
+                                    }
+                                }
                             }
                         }
                     }
@@ -77,7 +136,9 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
     extractTimestamp(request) {
         if (!this.config.timestampHeader)
             return null;
-        const timestampHeader = request.headers.get(this.config.timestampHeader);
+        const timestampHeader = request.headers.get(this.config.timestampHeader)
+            || this.config.customConfig?.timestampHeaderAliases?.map((alias) => request.headers.get(alias)).find(Boolean)
+            || null;
         if (!timestampHeader)
             return null;
         switch (this.config.timestampFormat) {
@@ -108,7 +169,7 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
             return true;
         // These platforms have timestampHeader in config but timestamp
         // is optional in their spec — validate only if present, never mandate
-        const optionalTimestampPlatforms = ['vercel', 'sentry', 'grafana'];
+        const optionalTimestampPlatforms = ['vercel', 'sentry', 'grafana', 'twilio'];
         if (optionalTimestampPlatforms.includes(this.platform))
             return false;
         // For all other platforms: infer from config
@@ -125,6 +186,16 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
             return true;
         return false;
     }
+    resolveTwilioSignatureUrl(request) {
+        const overrideBaseUrl = this.config.customConfig?.twilioBaseUrl;
+        if (!overrideBaseUrl) {
+            return request.url;
+        }
+        const requestUrl = new URL(request.url);
+        const baseUrl = new URL(overrideBaseUrl);
+        baseUrl.search = requestUrl.search;
+        return baseUrl.toString();
+    }
     formatPayload(rawBody, request) {
         switch (this.config.payloadFormat) {
             case "timestamped": {
@@ -152,7 +223,7 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
         }
         const customFormat = this.config.customConfig.payloadFormat;
         if (customFormat.includes("{id}") && customFormat.includes("{timestamp}")) {
-            const id = request.headers.get(this.config.customConfig.idHeader || "x-webhook-id");
+            const id = request.headers.get(this.config.customConfig.idHeader || "x-webhook-id") || this.config.customConfig?.idHeaderAliases?.map((alias) => request.headers.get(alias)).find(Boolean);
             const timestamp = request.headers.get(this.config.timestampHeader ||
                 this.config.customConfig?.timestampHeader ||
                 "x-webhook-timestamp");
@@ -167,6 +238,11 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
                 .replace("{timestamp}", timestamp.trim() || "")
                 .replace("{body}", rawBody);
         }
+        if (customFormat.includes('{url}')) {
+            return customFormat
+                .replace('{url}', this.platform === 'twilio' ? this.resolveTwilioSignatureUrl(request) : request.url)
+                .replace('{body}', rawBody);
+        }
         if (customFormat.includes("{timestamp}") &&
             customFormat.includes("{body}")) {
             const timestamp = this.extractTimestampFromSignature(request) ||
@@ -250,6 +326,40 @@ class AlgorithmBasedVerifier extends base_1.WebhookVerifier {
 }
 exports.AlgorithmBasedVerifier = AlgorithmBasedVerifier;
 class GenericHMACVerifier extends AlgorithmBasedVerifier {
+    validateLinearReplayWindow(rawBody) {
+        if (this.platform !== 'linear')
+            return null;
+        try {
+            const parsed = JSON.parse(rawBody);
+            const rawTimestamp = parsed.webhookTimestamp;
+            const timestampMs = Number(rawTimestamp);
+            if (!Number.isFinite(timestampMs)) {
+                return 'Missing or invalid Linear webhookTimestamp';
+            }
+            const replayToleranceMs = this.config.customConfig?.replayToleranceMs || 60000;
+            if (Math.abs(Date.now() - timestampMs) > replayToleranceMs) {
+                return 'Linear webhook timestamp is outside the replay window';
+            }
+        }
+        catch {
+            return 'Linear webhook replay check requires JSON payload';
+        }
+        return null;
+    }
+    validateTwilioBodyHash(rawBody, request) {
+        if (this.platform !== 'twilio' || !this.config.customConfig?.validateBodySHA256) {
+            return null;
+        }
+        const url = new URL(this.resolveTwilioSignatureUrl(request));
+        const bodySha = url.searchParams.get('bodySHA256');
+        if (!bodySha)
+            return null;
+        const computed = (0, crypto_1.createHash)('sha256').update(rawBody).digest('hex');
+        if (!this.safeCompare(computed, bodySha)) {
+            return 'Twilio bodySHA256 query param does not match payload hash';
+        }
+        return null;
+    }
     resolveSentryPayloadCandidates(rawBody, request) {
         const candidates = [
             this.formatPayload(rawBody, request),
@@ -283,12 +393,30 @@ class GenericHMACVerifier extends AlgorithmBasedVerifier {
             if (signatures.length === 0) {
                 return {
                     isValid: false,
-                    error: `Missing signature header: ${this.config.headerName}`,
+                    error: this.getMissingSignatureMessage(),
                     errorCode: "MISSING_SIGNATURE",
                     platform: this.platform,
                 };
             }
             const rawBody = await request.text();
+            const linearReplayError = this.validateLinearReplayWindow(rawBody);
+            if (linearReplayError) {
+                return {
+                    isValid: false,
+                    error: linearReplayError,
+                    errorCode: 'TIMESTAMP_EXPIRED',
+                    platform: this.platform,
+                };
+            }
+            const twilioBodyHashError = this.validateTwilioBodyHash(rawBody, request);
+            if (twilioBodyHashError) {
+                return {
+                    isValid: false,
+                    error: twilioBodyHashError,
+                    errorCode: 'INVALID_SIGNATURE',
+                    platform: this.platform,
+                };
+            }
             let timestamp = null;
             if (this.config.headerFormat === "comma-separated") {
                 timestamp = this.extractTimestampFromSignature(request);
@@ -299,7 +427,7 @@ class GenericHMACVerifier extends AlgorithmBasedVerifier {
             if (this.requiresTimestamp() && !timestamp) {
                 return {
                     isValid: false,
-                    error: 'Missing required timestamp for webhook verification',
+                    error: this.getMissingTimestampMessage(),
                     errorCode: 'MISSING_SIGNATURE',
                     platform: this.platform,
                 };
@@ -307,7 +435,7 @@ class GenericHMACVerifier extends AlgorithmBasedVerifier {
             if (timestamp && !this.isTimestampValid(timestamp)) {
                 return {
                     isValid: false,
-                    error: "Webhook timestamp expired",
+                    error: this.getTimestampExpiredMessage(),
                     errorCode: "TIMESTAMP_EXPIRED",
                     platform: this.platform,
                 };
@@ -322,7 +450,7 @@ class GenericHMACVerifier extends AlgorithmBasedVerifier {
                     if (this.config.customConfig?.encoding === "base64") {
                         isValid = this.verifyHMACWithBase64(payload, signature, algorithm);
                     }
-                    else if (this.config.headerFormat === "prefixed") {
+                    else if (this.config.headerFormat === "prefixed" || this.config.customConfig?.comparePrefixed) {
                         isValid = this.verifyHMACWithPrefix(payload, signature, algorithm);
                     }
                     else {
@@ -339,7 +467,7 @@ class GenericHMACVerifier extends AlgorithmBasedVerifier {
             if (!isValid) {
                 return {
                     isValid: false,
-                    error: "Invalid signature",
+                    error: this.getInvalidSignatureMessage(),
                     errorCode: "INVALID_SIGNATURE",
                     platform: this.platform,
                 };
@@ -368,7 +496,7 @@ class GenericHMACVerifier extends AlgorithmBasedVerifier {
         catch (error) {
             return {
                 isValid: false,
-                error: `${this.platform} verification error: ${error.message}`,
+                error: this.getVerificationErrorMessage(error),
                 errorCode: "VERIFICATION_ERROR",
                 platform: this.platform,
             };
@@ -477,7 +605,7 @@ class Ed25519Verifier extends AlgorithmBasedVerifier {
             if (signatures.length === 0) {
                 return {
                     isValid: false,
-                    error: `Missing signature header: ${this.config.headerName}`,
+                    error: this.getMissingSignatureMessage(),
                     errorCode: "MISSING_SIGNATURE",
                     platform: this.platform,
                 };
@@ -491,7 +619,7 @@ class Ed25519Verifier extends AlgorithmBasedVerifier {
                 if (!timestampStr) {
                     return {
                         isValid: false,
-                        error: 'Missing required timestamp for webhook verification',
+                        error: this.getMissingTimestampMessage(),
                         errorCode: 'MISSING_SIGNATURE',
                         platform: this.platform,
                     };
@@ -500,7 +628,7 @@ class Ed25519Verifier extends AlgorithmBasedVerifier {
                 if (!this.isTimestampValid(timestamp)) {
                     return {
                         isValid: false,
-                        error: "Webhook timestamp expired",
+                        error: this.getTimestampExpiredMessage(),
                         errorCode: "TIMESTAMP_EXPIRED",
                         platform: this.platform,
                     };
@@ -560,7 +688,7 @@ class Ed25519Verifier extends AlgorithmBasedVerifier {
             if (!isValid) {
                 return {
                     isValid: false,
-                    error: "Invalid signature",
+                    error: this.getInvalidSignatureMessage(),
                     errorCode: "INVALID_SIGNATURE",
                     platform: this.platform,
                 };
@@ -589,7 +717,7 @@ class Ed25519Verifier extends AlgorithmBasedVerifier {
         catch (error) {
             return {
                 isValid: false,
-                error: `${this.platform} verification error: ${error.message}`,
+                error: this.getVerificationErrorMessage(error),
                 errorCode: "VERIFICATION_ERROR",
                 platform: this.platform,
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hookflo/tern",
-  "version": "4.3.0-beta.0",
+  "version": "4.3.0-beta.1",
   "description": "A robust, scalable webhook verification framework supporting multiple platforms and signature algorithms",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/normalization/index.d.ts

@@ -1,20 +0,0 @@
-import { BaseTemplate, CreateSchemaInput, NormalizedResult, ProviderInfo, TemplateCategory, TransformParams, UpdateSchemaInput, UserSchema } from './types';
-import { StorageAdapter } from './storage/interface';
-export declare class Normalizer {
-    private readonly storage;
-    private engine;
-    constructor(storage?: StorageAdapter);
-    getBaseTemplates(): Promise<BaseTemplate[]>;
-    getProviders(category?: TemplateCategory): Promise<ProviderInfo[]>;
-    createSchema(input: CreateSchemaInput): Promise<UserSchema>;
-    updateSchema(schemaId: string, updates: UpdateSchemaInput): Promise<void>;
-    getSchema(id: string): Promise<UserSchema | null>;
-    transform(params: TransformParams): Promise<NormalizedResult>;
-    validateSchema(schema: UserSchema): Promise<{
-        valid: boolean;
-        errors: string[];
-    }>;
-}
-export * from './types';
-export * from './storage/interface';
-export { InMemoryStorageAdapter } from './storage/memory';

package/dist/normalization/index.js

@@ -1,78 +0,0 @@
-"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.InMemoryStorageAdapter = exports.Normalizer = void 0;
-const registry_1 = require("./providers/registry");
-const registry_2 = require("./templates/registry");
-const memory_1 = require("./storage/memory");
-const engine_1 = require("./transformer/engine");
-const validator_1 = require("./transformer/validator");
-class Normalizer {
-    constructor(storage = new memory_1.InMemoryStorageAdapter()) {
-        this.storage = storage;
-        this.engine = new engine_1.NormalizationEngine(storage, new validator_1.SchemaValidator());
-    }
-    async getBaseTemplates() {
-        return this.storage.listBaseTemplates();
-    }
-    async getProviders(category) {
-        return registry_1.providerRegistry.list(category);
-    }
-    async createSchema(input) {
-        const schema = {
-            id: generateId(),
-            userId: input.userId,
-            baseTemplateId: input.baseTemplateId,
-            category: input.category,
-            fields: input.fields,
-            providerMappings: input.providerMappings,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        };
-        await this.storage.saveSchema(schema);
-        return schema;
-    }
-    async updateSchema(schemaId, updates) {
-        await this.storage.updateSchema(schemaId, updates);
-    }
-    async getSchema(id) {
-        return this.storage.getSchema(id);
-    }
-    async transform(params) {
-        return this.engine.transform(params);
-    }
-    async validateSchema(schema) {
-        const base = (await this.storage.getBaseTemplate(schema.baseTemplateId))
-            ?? registry_2.templateRegistry.getById(schema.baseTemplateId);
-        if (!base) {
-            return {
-                valid: false,
-                errors: [`Base template not found: ${schema.baseTemplateId}`],
-            };
-        }
-        const validator = new validator_1.SchemaValidator();
-        return validator.validateSchema(schema, base);
-    }
-}
-exports.Normalizer = Normalizer;
-function generateId() {
-    // Simple non-crypto unique ID generator for framework default
-    return (`sch_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`);
-}
-__exportStar(require("./types"), exports);
-__exportStar(require("./storage/interface"), exports);
-var memory_2 = require("./storage/memory");
-Object.defineProperty(exports, "InMemoryStorageAdapter", { enumerable: true, get: function () { return memory_2.InMemoryStorageAdapter; } });

package/dist/normalization/providers/payment/paypal.d.ts

@@ -1,2 +0,0 @@
-import { ProviderMapping } from '../../types';
-export declare const paypalDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/paypal.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paypalDefaultMapping = void 0;
-exports.paypalDefaultMapping = {
-    provider: 'paypal',
-    fieldMappings: [
-        { schemaFieldId: 'event_type', providerPath: 'event_type' },
-        { schemaFieldId: 'amount', providerPath: 'resource.amount.value', transform: 'toNumber' },
-        { schemaFieldId: 'currency', providerPath: 'resource.amount.currency_code', transform: 'toUpperCase' },
-        { schemaFieldId: 'transaction_id', providerPath: 'resource.id' },
-    ],
-};

package/dist/normalization/providers/payment/razorpay.d.ts

@@ -1,2 +0,0 @@
-import { ProviderMapping } from '../../types';
-export declare const razorpayDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/razorpay.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.razorpayDefaultMapping = void 0;
-exports.razorpayDefaultMapping = {
-    provider: 'razorpay',
-    fieldMappings: [
-        { schemaFieldId: 'event_type', providerPath: 'event' },
-        { schemaFieldId: 'amount', providerPath: 'payload.payment.entity.amount' },
-        { schemaFieldId: 'currency', providerPath: 'payload.payment.entity.currency', transform: 'toUpperCase' },
-        { schemaFieldId: 'transaction_id', providerPath: 'payload.payment.entity.id' },
-        { schemaFieldId: 'customer_id', providerPath: 'payload.payment.entity.contact' },
-    ],
-};

package/dist/normalization/providers/payment/stripe.d.ts

@@ -1,2 +0,0 @@
-import { ProviderMapping } from '../../types';
-export declare const stripeDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/stripe.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripeDefaultMapping = void 0;
-exports.stripeDefaultMapping = {
-    provider: 'stripe',
-    fieldMappings: [
-        { schemaFieldId: 'event_type', providerPath: 'type' },
-        { schemaFieldId: 'amount', providerPath: 'data.object.amount_received' },
-        { schemaFieldId: 'currency', providerPath: 'data.object.currency', transform: 'toUpperCase' },
-        { schemaFieldId: 'transaction_id', providerPath: 'data.object.id' },
-        { schemaFieldId: 'customer_id', providerPath: 'data.object.customer' },
-    ],
-};

package/dist/normalization/providers/registry.d.ts

@@ -1,5 +0,0 @@
-import { ProviderInfo } from '../types';
-export declare const providerRegistry: {
-    list(category?: ProviderInfo["category"]): ProviderInfo[];
-    getById(id: string): ProviderInfo | undefined;
-};

package/dist/normalization/providers/registry.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.providerRegistry = void 0;
-const providers = [
-    { id: 'stripe', name: 'Stripe', category: 'payment' },
-    { id: 'razorpay', name: 'Razorpay', category: 'payment' },
-    { id: 'paypal', name: 'PayPal', category: 'payment' },
-    { id: 'clerk', name: 'Clerk', category: 'auth' },
-    { id: 'shopify', name: 'Shopify', category: 'ecommerce' },
-    { id: 'woocommerce', name: 'WooCommerce', category: 'ecommerce' },
-];
-exports.providerRegistry = {
-    list(category) {
-        if (!category)
-            return providers;
-        return providers.filter((p) => p.category === category);
-    },
-    getById(id) {
-        return providers.find((p) => p.id === id);
-    },
-};

package/dist/normalization/simple.d.ts

@@ -1,4 +0,0 @@
-import { AnyNormalizedWebhook, NormalizeOptions, NormalizationCategory, WebhookPlatform } from '../types';
-export declare function getPlatformNormalizationCategory(platform: WebhookPlatform): NormalizationCategory | null;
-export declare function getPlatformsByCategory(category: NormalizationCategory): WebhookPlatform[];
-export declare function normalizePayload(platform: WebhookPlatform, payload: any, normalize?: boolean | NormalizeOptions): AnyNormalizedWebhook | unknown;

package/dist/normalization/simple.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPlatformNormalizationCategory = getPlatformNormalizationCategory;
-exports.getPlatformsByCategory = getPlatformsByCategory;
-exports.normalizePayload = normalizePayload;
-function readPath(payload, path) {
-    return path.split('.').reduce((acc, key) => {
-        if (acc === undefined || acc === null) {
-            return undefined;
-        }
-        return acc[key];
-    }, payload);
-}
-const platformNormalizers = {
-    stripe: {
-        platform: 'stripe',
-        category: 'payment',
-        normalize: (payload) => ({
-            category: 'payment',
-            event: readPath(payload, 'type') === 'payment_intent.succeeded'
-                ? 'payment.succeeded'
-                : 'payment.unknown',
-            amount: readPath(payload, 'data.object.amount_received')
-                ?? readPath(payload, 'data.object.amount'),
-            currency: String(readPath(payload, 'data.object.currency') ?? '').toUpperCase() || undefined,
-            customer_id: readPath(payload, 'data.object.customer'),
-            transaction_id: readPath(payload, 'data.object.id'),
-            metadata: {},
-            occurred_at: new Date().toISOString(),
-        }),
-    },
-    polar: {
-        platform: 'polar',
-        category: 'payment',
-        normalize: (payload) => ({
-            category: 'payment',
-            event: readPath(payload, 'event') === 'payment.completed'
-                ? 'payment.succeeded'
-                : 'payment.unknown',
-            amount: readPath(payload, 'payload.amount_cents'),
-            currency: String(readPath(payload, 'payload.currency_code') ?? '').toUpperCase() || undefined,
-            customer_id: readPath(payload, 'payload.customer_id'),
-            transaction_id: readPath(payload, 'payload.transaction_id'),
-            metadata: {},
-            occurred_at: new Date().toISOString(),
-        }),
-    },
-    clerk: {
-        platform: 'clerk',
-        category: 'auth',
-        normalize: (payload) => ({
-            category: 'auth',
-            event: readPath(payload, 'type') || 'auth.unknown',
-            user_id: readPath(payload, 'data.id'),
-            email: readPath(payload, 'data.email_addresses.0.email_address'),
-            metadata: {},
-            occurred_at: new Date().toISOString(),
-        }),
-    },
-    vercel: {
-        platform: 'vercel',
-        category: 'infrastructure',
-        normalize: (payload) => ({
-            category: 'infrastructure',
-            event: readPath(payload, 'type') || 'deployment.unknown',
-            project_id: readPath(payload, 'payload.project.id'),
-            deployment_id: readPath(payload, 'payload.deployment.id'),
-            status: 'unknown',
-            metadata: {},
-            occurred_at: new Date().toISOString(),
-        }),
-    },
-};
-function getPlatformNormalizationCategory(platform) {
-    return platformNormalizers[platform]?.category || null;
-}
-function getPlatformsByCategory(category) {
-    return Object.values(platformNormalizers)
-        .filter((spec) => !!spec)
-        .filter((spec) => spec.category === category)
-        .map((spec) => spec.platform);
-}
-function resolveNormalizeOptions(normalize) {
-    if (typeof normalize === 'boolean') {
-        return {
-            enabled: normalize,
-            category: undefined,
-            includeRaw: true,
-        };
-    }
-    return {
-        enabled: normalize?.enabled ?? true,
-        category: normalize?.category,
-        includeRaw: normalize?.includeRaw ?? true,
-    };
-}
-function buildUnknownNormalizedPayload(platform, payload, category, includeRaw, warning) {
-    return {
-        category: category || 'infrastructure',
-        event: payload?.type ?? payload?.event ?? 'unknown',
-        _platform: platform,
-        _raw: includeRaw ? payload : undefined,
-        warning,
-        occurred_at: new Date().toISOString(),
-    };
-}
-function normalizePayload(platform, payload, normalize) {
-    const options = resolveNormalizeOptions(normalize);
-    if (!options.enabled) {
-        return payload;
-    }
-    const spec = platformNormalizers[platform];
-    const inferredCategory = spec?.category;
-    if (!spec) {
-        return buildUnknownNormalizedPayload(platform, payload, options.category, options.includeRaw);
-    }
-    if (options.category && options.category !== inferredCategory) {
-        return buildUnknownNormalizedPayload(platform, payload, inferredCategory, options.includeRaw, `Requested normalization category '${options.category}' does not match platform category '${inferredCategory}'`);
-    }
-    const normalized = spec.normalize(payload);
-    return {
-        ...normalized,
-        _platform: platform,
-        _raw: options.includeRaw ? payload : undefined,
-    };
-}

package/dist/normalization/storage/interface.d.ts

@@ -1,13 +0,0 @@
-import { BaseTemplate, UpdateSchemaInput, UserSchema } from '../types';
-export interface StorageAdapter {
-    saveSchema(schema: UserSchema): Promise<void>;
-    getSchema(id: string): Promise<UserSchema | null>;
-    updateSchema(id: string, updates: UpdateSchemaInput): Promise<void>;
-    deleteSchema(id: string): Promise<void>;
-    listSchemas(userId: string): Promise<UserSchema[]>;
-    getBaseTemplate(id: string): Promise<BaseTemplate | null>;
-    listBaseTemplates(): Promise<BaseTemplate[]>;
-}
-export interface NormalizationStorageOptions {
-    adapter: StorageAdapter;
-}

package/dist/normalization/storage/interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/normalization/storage/memory.d.ts

@@ -1,12 +0,0 @@
-import { BaseTemplate, UpdateSchemaInput, UserSchema } from '../types';
-import { StorageAdapter } from './interface';
-export declare class InMemoryStorageAdapter implements StorageAdapter {
-    private schemas;
-    saveSchema(schema: UserSchema): Promise<void>;
-    getSchema(id: string): Promise<UserSchema | null>;
-    updateSchema(id: string, updates: UpdateSchemaInput): Promise<void>;
-    deleteSchema(id: string): Promise<void>;
-    listSchemas(userId: string): Promise<UserSchema[]>;
-    getBaseTemplate(id: string): Promise<BaseTemplate | null>;
-    listBaseTemplates(): Promise<BaseTemplate[]>;
-}