@hookflo/tern 1.0.5 → 2.0.0

package/dist/normalization/transformer/validator.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidator = void 0;
+class SchemaValidator {
+    validateSchema(userSchema, baseTemplate) {
+        const errors = [];
+        // Ensure required base fields exist and are enabled or have defaults
+        for (const baseField of baseTemplate.fields) {
+            if (!baseField.required)
+                continue;
+            const userField = userSchema.fields.find((f) => f.id === baseField.id);
+            if (!userField) {
+                errors.push(`Missing required field in schema: ${baseField.id}`);
+                continue;
+            }
+            if (!userField.enabled && baseField.defaultValue === undefined) {
+                errors.push(`Required field disabled without default: ${baseField.id}`);
+            }
+            if (userField.type !== baseField.type) {
+                errors.push(`Type mismatch for field ${baseField.id}: expected ${baseField.type}, got ${userField.type}`);
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    validateOutput(output, userSchema, baseTemplate) {
+        const errors = [];
+        for (const field of userSchema.fields) {
+            if (!field.enabled)
+                continue;
+            const value = output[field.name];
+            if (value === undefined) {
+                if (field.required)
+                    errors.push(`Missing required field in output: ${field.name}`);
+                continue;
+            }
+            if (!this.matchesType(value, field.type)) {
+                errors.push(`Type mismatch for output field ${field.name}`);
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    matchesType(value, type) {
+        if (type === 'number')
+            return typeof value === 'number' && !Number.isNaN(value);
+        if (type === 'string')
+            return typeof value === 'string';
+        if (type === 'boolean')
+            return typeof value === 'boolean';
+        if (type === 'object')
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        if (type === 'array')
+            return Array.isArray(value);
+        return true;
+    }
+}
+exports.SchemaValidator = SchemaValidator;

package/dist/normalization/types.d.ts

@@ -0,0 +1,79 @@
+export type TemplateCategory = 'payment' | 'auth' | 'ecommerce';
+export interface TemplateField {
+    id: string;
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required: boolean;
+    description?: string;
+    defaultValue?: unknown;
+}
+export interface BaseTemplate {
+    id: string;
+    category: TemplateCategory;
+    version: string;
+    fields: TemplateField[];
+}
+export interface UserSchemaField {
+    id: string;
+    name: string;
+    type: TemplateField['type'];
+    required: boolean;
+    enabled: boolean;
+    defaultValue?: unknown;
+}
+export interface FieldMapping {
+    schemaFieldId: string;
+    providerPath: string;
+    transform?: string;
+}
+export interface ProviderMapping {
+    provider: string;
+    fieldMappings: FieldMapping[];
+}
+export interface UserSchema {
+    id: string;
+    userId: string;
+    baseTemplateId: string;
+    category: TemplateCategory;
+    fields: UserSchemaField[];
+    providerMappings: ProviderMapping[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface NormalizedPayloadMeta {
+    provider: string;
+    schemaId: string;
+    schemaVersion: string;
+    transformedAt: Date;
+}
+export interface NormalizedResult {
+    normalized: Record<string, unknown>;
+    meta: NormalizedPayloadMeta;
+}
+export interface CreateSchemaInput {
+    userId: string;
+    baseTemplateId: string;
+    category: TemplateCategory;
+    fields: UserSchemaField[];
+    providerMappings: ProviderMapping[];
+}
+export interface UpdateSchemaInput {
+    fields?: UserSchemaField[];
+    providerMappings?: ProviderMapping[];
+}
+export interface ProviderInfoField {
+    path: string;
+    type?: TemplateField['type'];
+    description?: string;
+}
+export interface ProviderInfo {
+    id: string;
+    name: string;
+    category: TemplateCategory;
+    samplePaths?: ProviderInfoField[];
+}
+export interface TransformParams {
+    rawPayload: unknown;
+    provider: string;
+    schemaId: string;
+}

package/dist/normalization/types.js

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

package/dist/platforms/algorithms.d.ts

@@ -1,4 +1,4 @@
-import { PlatformAlgorithmConfig, WebhookPlatform, SignatureConfig } from "../types";
+import { PlatformAlgorithmConfig, WebhookPlatform, SignatureConfig } from '../types';
 export declare const platformAlgorithmConfigs: Record<WebhookPlatform, PlatformAlgorithmConfig>;
 export declare function getPlatformAlgorithmConfig(platform: WebhookPlatform): PlatformAlgorithmConfig;
 export declare function platformUsesAlgorithm(platform: WebhookPlatform, algorithm: string): boolean;

package/dist/platforms/algorithms.js

@@ -7,138 +7,139 @@ exports.getPlatformsUsingAlgorithm = getPlatformsUsingAlgorithm;
 exports.validateSignatureConfig = validateSignatureConfig;
 exports.platformAlgorithmConfigs = {
     github: {
-        platform: "github",
+        platform: 'github',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "x-hub-signature-256",
-            headerFormat: "prefixed",
-            prefix: "sha256=",
+            algorithm: 'hmac-sha256',
+            headerName: 'x-hub-signature-256',
+            headerFormat: 'prefixed',
+            prefix: 'sha256=',
             timestampHeader: undefined,
-            payloadFormat: "raw",
+            payloadFormat: 'raw',
         },
-        description: "GitHub webhooks use HMAC-SHA256 with sha256= prefix",
+        description: 'GitHub webhooks use HMAC-SHA256 with sha256= prefix',
     },
     stripe: {
-        platform: "stripe",
+        platform: 'stripe',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "stripe-signature",
-            headerFormat: "comma-separated",
+            algorithm: 'hmac-sha256',
+            headerName: 'stripe-signature',
+            headerFormat: 'comma-separated',
             timestampHeader: undefined,
-            payloadFormat: "timestamped",
+            payloadFormat: 'timestamped',
             customConfig: {
-                signatureFormat: "t={timestamp},v1={signature}",
+                signatureFormat: 't={timestamp},v1={signature}',
             },
         },
-        description: "Stripe webhooks use HMAC-SHA256 with comma-separated format",
+        description: 'Stripe webhooks use HMAC-SHA256 with comma-separated format',
     },
     clerk: {
-        platform: "clerk",
+        platform: 'clerk',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "svix-signature",
-            headerFormat: "raw",
-            timestampHeader: "svix-timestamp",
-            timestampFormat: "unix",
-            payloadFormat: "custom",
+            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",
-                idHeader: "svix-id",
+                signatureFormat: 'v1={signature}',
+                payloadFormat: '{id}.{timestamp}.{body}',
+                encoding: 'base64',
+                idHeader: 'svix-id',
             },
         },
-        description: "Clerk webhooks use HMAC-SHA256 with base64 encoding",
+        description: 'Clerk webhooks use HMAC-SHA256 with base64 encoding',
     },
     dodopayments: {
-        platform: "dodopayments",
+        platform: 'dodopayments',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "webhook-signature",
-            headerFormat: "raw",
-            timestampHeader: "webhook-timestamp",
-            timestampFormat: "unix",
-            payloadFormat: "custom",
+            algorithm: 'hmac-sha256',
+            headerName: 'webhook-signature',
+            headerFormat: 'raw',
+            timestampHeader: 'webhook-timestamp',
+            timestampFormat: 'unix',
+            payloadFormat: 'custom',
             customConfig: {
-                signatureFormat: "v1={signature}",
-                payloadFormat: "{id}.{timestamp}.{body}",
-                idHeader: "webhook-id",
+                signatureFormat: 'v1={signature}',
+                payloadFormat: '{id}.{timestamp}.{body}',
+                encoding: 'base64',
+                idHeader: 'webhook-id',
             },
         },
-        description: "Dodo Payments webhooks use HMAC-SHA256 with svix-style format (Standard Webhooks)",
+        description: 'Dodo Payments webhooks use HMAC-SHA256 with svix-style format (Standard Webhooks)',
     },
     shopify: {
-        platform: "shopify",
+        platform: 'shopify',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "x-shopify-hmac-sha256",
-            headerFormat: "raw",
-            timestampHeader: "x-shopify-shop-domain",
-            payloadFormat: "raw",
+            algorithm: 'hmac-sha256',
+            headerName: 'x-shopify-hmac-sha256',
+            headerFormat: 'raw',
+            timestampHeader: 'x-shopify-shop-domain',
+            payloadFormat: 'raw',
         },
-        description: "Shopify webhooks use HMAC-SHA256",
+        description: 'Shopify webhooks use HMAC-SHA256',
     },
     vercel: {
-        platform: "vercel",
+        platform: 'vercel',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "x-vercel-signature",
-            headerFormat: "raw",
-            timestampHeader: "x-vercel-timestamp",
-            timestampFormat: "unix",
-            payloadFormat: "raw",
+            algorithm: 'hmac-sha256',
+            headerName: 'x-vercel-signature',
+            headerFormat: 'raw',
+            timestampHeader: 'x-vercel-timestamp',
+            timestampFormat: 'unix',
+            payloadFormat: 'raw',
         },
-        description: "Vercel webhooks use HMAC-SHA256",
+        description: 'Vercel webhooks use HMAC-SHA256',
     },
     polar: {
-        platform: "polar",
+        platform: 'polar',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "x-polar-signature",
-            headerFormat: "raw",
-            timestampHeader: "x-polar-timestamp",
-            timestampFormat: "unix",
-            payloadFormat: "raw",
+            algorithm: 'hmac-sha256',
+            headerName: 'x-polar-signature',
+            headerFormat: 'raw',
+            timestampHeader: 'x-polar-timestamp',
+            timestampFormat: 'unix',
+            payloadFormat: 'raw',
         },
-        description: "Polar webhooks use HMAC-SHA256",
+        description: 'Polar webhooks use HMAC-SHA256',
     },
     supabase: {
-        platform: "supabase",
+        platform: 'supabase',
         signatureConfig: {
-            algorithm: "custom",
-            headerName: "x-webhook-token",
-            headerFormat: "raw",
-            payloadFormat: "raw",
+            algorithm: 'custom',
+            headerName: 'x-webhook-token',
+            headerFormat: 'raw',
+            payloadFormat: 'raw',
             customConfig: {
-                type: "token-based",
-                idHeader: "x-webhook-id",
+                type: 'token-based',
+                idHeader: 'x-webhook-id',
             },
         },
-        description: "Supabase webhooks use token-based authentication",
+        description: 'Supabase webhooks use token-based authentication',
     },
     custom: {
-        platform: "custom",
+        platform: 'custom',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "x-webhook-token",
-            headerFormat: "raw",
-            payloadFormat: "raw",
+            algorithm: 'hmac-sha256',
+            headerName: 'x-webhook-token',
+            headerFormat: 'raw',
+            payloadFormat: 'raw',
             customConfig: {
-                type: "token-based",
-                idHeader: "x-webhook-id",
+                type: 'token-based',
+                idHeader: 'x-webhook-id',
             },
         },
-        description: "Custom webhook configuration",
+        description: 'Custom webhook configuration',
     },
     unknown: {
-        platform: "unknown",
+        platform: 'unknown',
         signatureConfig: {
-            algorithm: "hmac-sha256",
-            headerName: "x-webhook-signature",
-            headerFormat: "raw",
-            payloadFormat: "raw",
+            algorithm: 'hmac-sha256',
+            headerName: 'x-webhook-signature',
+            headerFormat: 'raw',
+            payloadFormat: 'raw',
         },
-        description: "Unknown platform - using default HMAC-SHA256",
+        description: 'Unknown platform - using default HMAC-SHA256',
     },
 };
 function getPlatformAlgorithmConfig(platform) {
@@ -158,14 +159,14 @@ function validateSignatureConfig(config) {
         return false;
     }
     switch (config.algorithm) {
-        case "hmac-sha256":
-        case "hmac-sha1":
-        case "hmac-sha512":
+        case 'hmac-sha256':
+        case 'hmac-sha1':
+        case 'hmac-sha512':
             return true;
-        case "rsa-sha256":
-        case "ed25519":
+        case 'rsa-sha256':
+        case 'ed25519':
             return !!config.customConfig?.publicKey;
-        case "custom":
+        case 'custom':
             return !!config.customConfig;
         default:
             return false;

package/dist/test.js

@@ -118,18 +118,23 @@ async function runTests() {
     try {
         const webhookId = 'test-webhook-id-123';
         const timestamp = Math.floor(Date.now() / 1000);
+        // Create a proper secret format for Standard Webhooks (whsec_ + base64 encoded secret)
+        const base64Secret = Buffer.from(testSecret).toString('base64');
+        const dodoSecret = `whsec_${base64Secret}`;
         // Create svix-style signature: {webhook-id}.{webhook-timestamp}.{payload}
         const signedContent = `${webhookId}.${timestamp}.${testBody}`;
-        const hmac = (0, crypto_1.createHmac)('sha256', testSecret);
+        // Use the base64-decoded secret for HMAC (like the Standard Webhooks library)
+        const secretBytes = new Uint8Array(Buffer.from(base64Secret, 'base64'));
+        const hmac = (0, crypto_1.createHmac)('sha256', secretBytes);
         hmac.update(signedContent);
-        const signature = hmac.digest('hex');
+        const signature = `v1,${hmac.digest('base64')}`;
         const dodoRequest = createMockRequest({
             'webhook-signature': signature,
             'webhook-id': webhookId,
             'webhook-timestamp': timestamp.toString(),
             'content-type': 'application/json',
         });
-        const dodoResult = await index_1.WebhookVerificationService.verifyWithPlatformConfig(dodoRequest, 'dodopayments', testSecret);
+        const dodoResult = await index_1.WebhookVerificationService.verifyWithPlatformConfig(dodoRequest, 'dodopayments', dodoSecret);
         console.log('   ✅ Dodo Payments:', dodoResult.isValid ? 'PASSED' : 'FAILED');
         if (!dodoResult.isValid) {
             console.log('   ❌ Error:', dodoResult.error);

package/dist/verifiers/algorithms.d.ts

@@ -1,5 +1,5 @@
-import { WebhookVerifier } from "./base";
-import { WebhookVerificationResult, SignatureConfig, WebhookPlatform } from "../types";
+import { WebhookVerifier } from './base';
+import { WebhookVerificationResult, SignatureConfig, WebhookPlatform } from '../types';
 export declare abstract class AlgorithmBasedVerifier extends WebhookVerifier {
     protected config: SignatureConfig;
     protected platform: WebhookPlatform;