@hookflo/tern 1.0.6 → 2.0.2-experimental.0

package/dist/normalization/templates/base/payment.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paymentBaseTemplate = void 0;
+exports.paymentBaseTemplate = {
+    id: 'payment_v1',
+    category: 'payment',
+    version: '1.0.0',
+    fields: [
+        {
+            id: 'event_type', name: 'event_type', type: 'string', required: true, description: 'Type of payment event',
+        },
+        {
+            id: 'amount', name: 'amount', type: 'number', required: true, description: 'Amount in the smallest currency unit',
+        },
+        {
+            id: 'currency', name: 'currency', type: 'string', required: true, description: 'Three-letter currency code',
+        },
+        {
+            id: 'transaction_id', name: 'transaction_id', type: 'string', required: true, description: 'Unique transaction identifier',
+        },
+        {
+            id: 'customer_id', name: 'customer_id', type: 'string', required: false, description: 'Customer identifier',
+        },
+    ],
+};

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

@@ -0,0 +1,6 @@
+import { BaseTemplate, TemplateCategory } from '../types';
+export declare const templateRegistry: {
+    getById(id: string): BaseTemplate | undefined;
+    listByCategory(category: TemplateCategory): BaseTemplate[];
+    listAll(): BaseTemplate[];
+};

package/dist/normalization/templates/registry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateRegistry = void 0;
+const payment_1 = require("./base/payment");
+const auth_1 = require("./base/auth");
+const ecommerce_1 = require("./base/ecommerce");
+const templates = {
+    [payment_1.paymentBaseTemplate.id]: payment_1.paymentBaseTemplate,
+    [auth_1.authBaseTemplate.id]: auth_1.authBaseTemplate,
+    [ecommerce_1.ecommerceBaseTemplate.id]: ecommerce_1.ecommerceBaseTemplate,
+};
+exports.templateRegistry = {
+    getById(id) {
+        return templates[id];
+    },
+    listByCategory(category) {
+        return Object.values(templates).filter((t) => t.category === category);
+    },
+    listAll() {
+        return Object.values(templates);
+    },
+};

package/dist/normalization/transformer/engine.d.ts

@@ -0,0 +1,11 @@
+import { NormalizedResult, TransformParams } from '../types';
+import { StorageAdapter } from '../storage/interface';
+import { SchemaValidator } from './validator';
+export declare class NormalizationEngine {
+    private readonly storage;
+    private readonly validator;
+    constructor(storage: StorageAdapter, validator?: SchemaValidator);
+    transform(params: TransformParams): Promise<NormalizedResult>;
+    private extractValue;
+    private applyTransform;
+}

package/dist/normalization/transformer/engine.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizationEngine = void 0;
+const registry_1 = require("../templates/registry");
+const validator_1 = require("./validator");
+class NormalizationEngine {
+    constructor(storage, validator = new validator_1.SchemaValidator()) {
+        this.storage = storage;
+        this.validator = validator;
+    }
+    async transform(params) {
+        const { rawPayload, provider, schemaId } = params;
+        const schema = await this.storage.getSchema(schemaId);
+        if (!schema)
+            throw new Error(`Schema not found: ${schemaId}`);
+        const baseTemplate = await this.storage.getBaseTemplate(schema.baseTemplateId) || registry_1.templateRegistry.getById(schema.baseTemplateId);
+        if (!baseTemplate)
+            throw new Error(`Base template not found: ${schema.baseTemplateId}`);
+        const validation = this.validator.validateSchema(schema, baseTemplate);
+        if (!validation.valid) {
+            throw new Error(`Invalid schema: ${validation.errors.join('; ')}`);
+        }
+        const providerMapping = schema.providerMappings.find((m) => m.provider === provider);
+        if (!providerMapping)
+            throw new Error(`No mapping found for provider: ${provider}`);
+        const normalized = {};
+        for (const field of schema.fields) {
+            if (!field.enabled)
+                continue;
+            const mapping = providerMapping.fieldMappings.find((m) => m.schemaFieldId === field.id);
+            if (mapping) {
+                const value = this.extractValue(rawPayload, mapping.providerPath);
+                const finalValue = this.applyTransform(value, mapping.transform);
+                normalized[field.name] = finalValue ?? field.defaultValue;
+            }
+            else if (field.required) {
+                if (field.defaultValue !== undefined) {
+                    normalized[field.name] = field.defaultValue;
+                }
+                else {
+                    throw new Error(`Required field ${field.name} has no mapping`);
+                }
+            }
+        }
+        const outValidation = this.validator.validateOutput(normalized, schema, baseTemplate);
+        if (!outValidation.valid) {
+            throw new Error(`Normalized output invalid: ${outValidation.errors.join('; ')}`);
+        }
+        return {
+            normalized,
+            meta: {
+                provider,
+                schemaId,
+                schemaVersion: schema.baseTemplateId,
+                transformedAt: new Date(),
+            },
+        };
+    }
+    extractValue(obj, path) {
+        if (!path)
+            return undefined;
+        return path.split('.').reduce((acc, key) => (acc == null ? undefined : acc[key]), obj);
+    }
+    applyTransform(value, transform) {
+        if (transform == null)
+            return value;
+        if (value == null)
+            return value;
+        if (transform === 'toUpperCase')
+            return String(value).toUpperCase();
+        if (transform === 'toLowerCase')
+            return String(value).toLowerCase();
+        if (transform === 'toNumber')
+            return typeof value === 'number' ? value : Number(value);
+        if (transform.startsWith('divide:')) {
+            const denominator = Number(transform.split(':')[1]);
+            return Number(value) / denominator;
+        }
+        if (transform.startsWith('multiply:')) {
+            const factor = Number(transform.split(':')[1]);
+            return Number(value) * factor;
+        }
+        return value;
+    }
+}
+exports.NormalizationEngine = NormalizationEngine;

package/dist/normalization/transformer/validator.d.ts

@@ -0,0 +1,12 @@
+import { BaseTemplate, UserSchema } from '../types';
+export declare class SchemaValidator {
+    validateSchema(userSchema: UserSchema, baseTemplate: BaseTemplate): {
+        valid: boolean;
+        errors: string[];
+    };
+    validateOutput(output: Record<string, unknown>, userSchema: UserSchema, baseTemplate: BaseTemplate): {
+        valid: boolean;
+        errors: string[];
+    };
+    private matchesType;
+}

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,139 +7,153 @@ 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}",
-                encoding: "base64",
-                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',
+    },
+    gitlab: {
+        platform: 'gitlab',
+        signatureConfig: {
+            algorithm: 'custom',
+            headerName: 'X-Gitlab-Token',
+            headerFormat: 'raw',
+            payloadFormat: 'raw',
+            customConfig: {
+                type: 'token-based',
+                idHeader: 'X-Gitlab-Token',
+            },
+        },
+        description: 'GitLab webhooks use HMAC-SHA256 with X-Gitlab-Token header',
     },
     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) {
@@ -159,14 +173,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;