@blokjs/trigger-webhook 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# @blokjs/trigger-webhook
+
+## 0.2.0
+
+### Minor Changes
+
+- Initial public release of Blok packages.
+
+  This release includes:
+
+  - Core packages: @blokjs/shared, @blokjs/helper, @blokjs/runner
+  - Node packages: @blokjs/api-call, @blokjs/if-else, @blokjs/react
+  - Trigger packages: pubsub, queue, webhook, websocket, worker, cron, grpc
+  - CLI tool: blokctl
+  - Editor support: @blokjs/lsp-server, @blokjs/syntax
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/shared@0.2.0
+  - @blokjs/helper@0.2.0
+  - @blokjs/runner@0.2.0

package/dist/WebhookTrigger.d.ts

@@ -0,0 +1,129 @@
+/**
+ * WebhookTrigger - Handle webhook events from external services
+ *
+ * Extends TriggerBase to process webhook events from:
+ * - GitHub (push, pull_request, issues, etc.)
+ * - Stripe (payment_intent, checkout.session, etc.)
+ * - Shopify (orders, products, customers)
+ * - Custom webhooks
+ *
+ * Features:
+ * - Signature verification for security
+ * - Event type filtering
+ * - Retry support
+ * - Dead letter handling
+ */
+import type { HelperResponse, WebhookTriggerOpts } from "@blok/helper";
+import { DefaultLogger, type GlobalOptions, type BlokService, TriggerBase, type TriggerResponse } from "@blok/runner";
+/**
+ * Webhook event structure
+ */
+export interface WebhookEvent {
+    /** Unique event ID */
+    id: string;
+    /** Source service (github, stripe, shopify, custom) */
+    source: string;
+    /** Event type (e.g., push, payment_intent.succeeded) */
+    eventType: string;
+    /** Event payload */
+    payload: unknown;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Signature (if provided) */
+    signature?: string;
+    /** Timestamp */
+    timestamp: Date;
+    /** Raw request body */
+    rawBody: string;
+}
+/**
+ * Signature verification result
+ */
+export interface VerificationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Webhook source handlers
+ */
+export interface WebhookSourceHandler {
+    /** Extract event type from request */
+    getEventType(headers: Record<string, string>, body: unknown): string;
+    /** Get signature from request */
+    getSignature(headers: Record<string, string>): string | undefined;
+    /** Verify signature */
+    verifySignature(rawBody: string, signature: string, secret: string): VerificationResult;
+    /** Get event ID */
+    getEventId(headers: Record<string, string>, body: unknown): string;
+}
+/**
+ * Workflow model with webhook trigger configuration
+ */
+interface WebhookWorkflowModel {
+    path: string;
+    config: {
+        name: string;
+        version: string;
+        trigger?: {
+            webhook?: WebhookTriggerOpts;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+}
+/**
+ * Built-in source handlers
+ */
+declare const sourceHandlers: Record<string, WebhookSourceHandler>;
+/**
+ * WebhookTrigger - Handle webhook events
+ */
+export declare abstract class WebhookTrigger extends TriggerBase {
+    protected nodeMap: GlobalOptions;
+    protected readonly tracer: import("@opentelemetry/api").Tracer;
+    protected readonly logger: DefaultLogger;
+    protected webhookWorkflows: WebhookWorkflowModel[];
+    protected abstract nodes: Record<string, BlokService<unknown>>;
+    protected abstract workflows: Record<string, HelperResponse>;
+    constructor();
+    /**
+     * Load nodes into the node map
+     */
+    loadNodes(): void;
+    /**
+     * Load workflows into the workflow map
+     */
+    loadWorkflows(): void;
+    /**
+     * Initialize webhook trigger (call after loading workflows)
+     */
+    listen(): Promise<number>;
+    /**
+     * Stop the webhook trigger
+     */
+    stop(): Promise<void>;
+    protected onHmrWorkflowChange(): Promise<void>;
+    /**
+     * Process an incoming webhook request
+     * Call this from your HTTP endpoint handler
+     */
+    handleWebhook(source: string, rawBody: string, headers: Record<string, string>): Promise<TriggerResponse | null>;
+    /**
+     * Get all workflows that have webhook triggers
+     */
+    protected getWebhookWorkflows(): WebhookWorkflowModel[];
+    /**
+     * Find workflow matching the webhook event
+     */
+    protected findMatchingWorkflow(event: WebhookEvent): WebhookWorkflowModel | null;
+    /**
+     * Execute a workflow for a webhook event
+     */
+    protected executeWorkflow(event: WebhookEvent, workflow: WebhookWorkflowModel, _config: WebhookTriggerOpts): Promise<TriggerResponse>;
+    /**
+     * Register a custom source handler
+     */
+    static registerSourceHandler(source: string, handler: WebhookSourceHandler): void;
+}
+export default WebhookTrigger;
+export { sourceHandlers };

package/dist/WebhookTrigger.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * WebhookTrigger - Handle webhook events from external services
+ *
+ * Extends TriggerBase to process webhook events from:
+ * - GitHub (push, pull_request, issues, etc.)
+ * - Stripe (payment_intent, checkout.session, etc.)
+ * - Shopify (orders, products, customers)
+ * - Custom webhooks
+ *
+ * Features:
+ * - Signature verification for security
+ * - Event type filtering
+ * - Retry support
+ * - Dead letter handling
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceHandlers = exports.WebhookTrigger = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const runner_1 = require("@blok/runner");
+const api_1 = require("@opentelemetry/api");
+const uuid_1 = require("uuid");
+/**
+ * Built-in source handlers
+ */
+const sourceHandlers = {
+    github: {
+        getEventType: (headers) => headers["x-github-event"] || "unknown",
+        getSignature: (headers) => headers["x-hub-signature-256"] || headers["x-hub-signature"],
+        verifySignature: (rawBody, signature, secret) => {
+            const hmac = node_crypto_1.default.createHmac("sha256", secret);
+            const digest = `sha256=${hmac.update(rawBody).digest("hex")}`;
+            const sigBuffer = Buffer.from(signature);
+            const digestBuffer = Buffer.from(digest);
+            // Length check first to avoid timing attack on length
+            if (sigBuffer.length !== digestBuffer.length) {
+                return { valid: false, error: "Invalid GitHub signature" };
+            }
+            const valid = node_crypto_1.default.timingSafeEqual(sigBuffer, digestBuffer);
+            return { valid, error: valid ? undefined : "Invalid GitHub signature" };
+        },
+        getEventId: (headers) => headers["x-github-delivery"] || (0, uuid_1.v4)(),
+    },
+    stripe: {
+        getEventType: (_, body) => body?.type || "unknown",
+        getSignature: (headers) => headers["stripe-signature"],
+        verifySignature: (rawBody, signature, secret) => {
+            // Stripe signature format: t=timestamp,v1=signature
+            const parts = signature.split(",").reduce((acc, part) => {
+                const [key, value] = part.split("=");
+                acc[key] = value;
+                return acc;
+            }, {});
+            const timestamp = parts.t;
+            const expectedSig = parts.v1;
+            if (!timestamp || !expectedSig) {
+                return { valid: false, error: "Invalid Stripe signature format" };
+            }
+            const payload = `${timestamp}.${rawBody}`;
+            const hmac = node_crypto_1.default.createHmac("sha256", secret);
+            const computedSig = hmac.update(payload).digest("hex");
+            const sigBuffer = Buffer.from(expectedSig);
+            const computedBuffer = Buffer.from(computedSig);
+            if (sigBuffer.length !== computedBuffer.length) {
+                return { valid: false, error: "Invalid Stripe signature" };
+            }
+            const valid = node_crypto_1.default.timingSafeEqual(sigBuffer, computedBuffer);
+            return { valid, error: valid ? undefined : "Invalid Stripe signature" };
+        },
+        getEventId: (_, body) => body?.id || (0, uuid_1.v4)(),
+    },
+    shopify: {
+        getEventType: (headers) => headers["x-shopify-topic"] || "unknown",
+        getSignature: (headers) => headers["x-shopify-hmac-sha256"],
+        verifySignature: (rawBody, signature, secret) => {
+            const hmac = node_crypto_1.default.createHmac("sha256", secret);
+            const digest = hmac.update(rawBody, "utf8").digest("base64");
+            const sigBuffer = Buffer.from(signature, "base64");
+            const digestBuffer = Buffer.from(digest, "base64");
+            if (sigBuffer.length !== digestBuffer.length) {
+                return { valid: false, error: "Invalid Shopify signature" };
+            }
+            const valid = node_crypto_1.default.timingSafeEqual(sigBuffer, digestBuffer);
+            return { valid, error: valid ? undefined : "Invalid Shopify signature" };
+        },
+        getEventId: (headers) => headers["x-shopify-webhook-id"] || (0, uuid_1.v4)(),
+    },
+    custom: {
+        getEventType: (headers, body) => headers["x-event-type"] || body?.event || "custom",
+        getSignature: (headers) => headers["x-signature"] || headers["x-webhook-signature"],
+        verifySignature: (rawBody, signature, secret) => {
+            // Default: HMAC-SHA256
+            const hmac = node_crypto_1.default.createHmac("sha256", secret);
+            const digest = hmac.update(rawBody).digest("hex");
+            const valid = signature === digest || signature === `sha256=${digest}`;
+            return { valid, error: valid ? undefined : "Invalid signature" };
+        },
+        getEventId: (headers, body) => headers["x-event-id"] || body?.id || (0, uuid_1.v4)(),
+    },
+};
+exports.sourceHandlers = sourceHandlers;
+/**
+ * WebhookTrigger - Handle webhook events
+ */
+class WebhookTrigger extends runner_1.TriggerBase {
+    nodeMap = {};
+    tracer = api_1.trace.getTracer(process.env.PROJECT_NAME || "trigger-webhook-workflow", process.env.PROJECT_VERSION || "0.0.1");
+    logger = new runner_1.DefaultLogger();
+    webhookWorkflows = [];
+    constructor() {
+        super();
+        this.loadNodes();
+        this.loadWorkflows();
+    }
+    /**
+     * Load nodes into the node map
+     */
+    loadNodes() {
+        this.nodeMap.nodes = new runner_1.NodeMap();
+        const nodeKeys = Object.keys(this.nodes);
+        for (const key of nodeKeys) {
+            this.nodeMap.nodes.addNode(key, this.nodes[key]);
+        }
+    }
+    /**
+     * Load workflows into the workflow map
+     */
+    loadWorkflows() {
+        this.nodeMap.workflows = this.workflows;
+    }
+    /**
+     * Initialize webhook trigger (call after loading workflows)
+     */
+    async listen() {
+        const startTime = this.startCounter();
+        // Find all workflows with webhook triggers
+        this.webhookWorkflows = this.getWebhookWorkflows();
+        if (this.webhookWorkflows.length === 0) {
+            this.logger.log("No workflows with webhook triggers found");
+        }
+        else {
+            this.logger.log(`Webhook trigger initialized. ${this.webhookWorkflows.length} workflow(s) registered`);
+        }
+        // Enable HMR in development mode
+        if (process.env.BLOK_HMR === "true" || process.env.NODE_ENV === "development") {
+            await this.enableHotReload();
+        }
+        return this.endCounter(startTime);
+    }
+    /**
+     * Stop the webhook trigger
+     */
+    async stop() {
+        this.webhookWorkflows = [];
+        this.logger.log("Webhook trigger stopped");
+    }
+    async onHmrWorkflowChange() {
+        this.loadWorkflows();
+        this.webhookWorkflows = this.getWebhookWorkflows();
+        this.logger.log(`[HMR] Webhook workflows reloaded. ${this.webhookWorkflows.length} workflow(s) registered`);
+    }
+    /**
+     * Process an incoming webhook request
+     * Call this from your HTTP endpoint handler
+     */
+    async handleWebhook(source, rawBody, headers) {
+        const handler = sourceHandlers[source] || sourceHandlers.custom;
+        // Parse body
+        let body;
+        try {
+            body = JSON.parse(rawBody);
+        }
+        catch {
+            body = rawBody;
+        }
+        // Create webhook event
+        const event = {
+            id: handler.getEventId(headers, body),
+            source,
+            eventType: handler.getEventType(headers, body),
+            payload: body,
+            headers,
+            signature: handler.getSignature(headers),
+            timestamp: new Date(),
+            rawBody,
+        };
+        // Find matching workflow
+        const workflow = this.findMatchingWorkflow(event);
+        if (!workflow) {
+            this.logger.log(`No matching workflow for webhook: ${source}/${event.eventType}`);
+            return null;
+        }
+        const config = workflow.config.trigger?.webhook;
+        // Verify signature if secret is configured
+        if (config.secret && event.signature) {
+            const verification = handler.verifySignature(rawBody, event.signature, config.secret);
+            if (!verification.valid) {
+                this.logger.error(`Webhook signature verification failed: ${verification.error}`);
+                throw new Error(`Signature verification failed: ${verification.error}`);
+            }
+        }
+        else if (config.secret && !event.signature) {
+            this.logger.error("Webhook signature missing but secret is configured");
+            throw new Error("Signature missing");
+        }
+        return this.executeWorkflow(event, workflow, config);
+    }
+    /**
+     * Get all workflows that have webhook triggers
+     */
+    getWebhookWorkflows() {
+        const workflows = [];
+        for (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {
+            const workflowConfig = workflow._config;
+            if (workflowConfig?.trigger) {
+                const triggerType = Object.keys(workflowConfig.trigger)[0];
+                if (triggerType === "webhook" && workflowConfig.trigger.webhook) {
+                    workflows.push({
+                        path,
+                        config: workflowConfig,
+                    });
+                }
+            }
+        }
+        return workflows;
+    }
+    /**
+     * Find workflow matching the webhook event
+     */
+    findMatchingWorkflow(event) {
+        for (const workflow of this.webhookWorkflows) {
+            const config = workflow.config.trigger?.webhook;
+            if (!config)
+                continue;
+            // Check source match
+            if (config.source !== event.source)
+                continue;
+            // Check event type match
+            if (config.events && config.events.length > 0) {
+                const matches = config.events.some((pattern) => {
+                    // Support wildcards (e.g., "push", "pull_request.*")
+                    if (pattern === "*")
+                        return true;
+                    if (pattern.endsWith(".*")) {
+                        const prefix = pattern.slice(0, -2);
+                        return event.eventType.startsWith(prefix);
+                    }
+                    return pattern === event.eventType;
+                });
+                if (!matches)
+                    continue;
+            }
+            return workflow;
+        }
+        return null;
+    }
+    /**
+     * Execute a workflow for a webhook event
+     */
+    async executeWorkflow(event, workflow, _config) {
+        const executionId = (0, uuid_1.v4)();
+        const defaultMeter = api_1.metrics.getMeter("default");
+        const webhookExecutions = defaultMeter.createCounter("webhook_executions", {
+            description: "Webhook executions",
+        });
+        const webhookErrors = defaultMeter.createCounter("webhook_errors", {
+            description: "Webhook execution errors",
+        });
+        return new Promise((resolve) => {
+            this.tracer.startActiveSpan(`webhook:${event.source}/${event.eventType}`, async (span) => {
+                try {
+                    const start = performance.now();
+                    // Initialize configuration for this workflow
+                    await this.configuration.init(workflow.path, this.nodeMap);
+                    // Create context
+                    const ctx = this.createContext(undefined, workflow.path, executionId);
+                    // Populate request with webhook event
+                    ctx.request = {
+                        body: event.payload,
+                        headers: event.headers,
+                        query: {},
+                        params: {
+                            source: event.source,
+                            eventType: event.eventType,
+                            eventId: event.id,
+                        },
+                    };
+                    // Store webhook context in vars
+                    if (!ctx.vars)
+                        ctx.vars = {};
+                    ctx.vars._webhook_event = {
+                        id: event.id,
+                        source: event.source,
+                        eventType: event.eventType,
+                        timestamp: event.timestamp.toISOString(),
+                        hasSignature: String(!!event.signature),
+                    };
+                    ctx.logger.log(`Processing webhook: ${event.source}/${event.eventType} (${event.id})`);
+                    // Execute workflow
+                    const response = await this.run(ctx);
+                    const end = performance.now();
+                    // Set span attributes
+                    span.setAttribute("success", true);
+                    span.setAttribute("event_id", event.id);
+                    span.setAttribute("source", event.source);
+                    span.setAttribute("event_type", event.eventType);
+                    span.setAttribute("workflow_path", workflow.path);
+                    span.setAttribute("elapsed_ms", end - start);
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    // Record metrics
+                    webhookExecutions.add(1, {
+                        env: process.env.NODE_ENV,
+                        source: event.source,
+                        event_type: event.eventType,
+                        workflow_name: this.configuration.name,
+                        success: "true",
+                    });
+                    ctx.logger.log(`Webhook processed in ${(end - start).toFixed(2)}ms: ${event.id}`);
+                    resolve(response);
+                }
+                catch (error) {
+                    const errorMessage = error.message;
+                    // Set span error
+                    span.setAttribute("success", false);
+                    span.recordException(error);
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: errorMessage });
+                    // Record error metrics
+                    webhookErrors.add(1, {
+                        env: process.env.NODE_ENV,
+                        source: event.source,
+                        event_type: event.eventType,
+                        workflow_name: this.configuration?.name || "unknown",
+                    });
+                    this.logger.error(`Webhook failed ${event.id}: ${errorMessage}`, error.stack);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            });
+        });
+    }
+    /**
+     * Register a custom source handler
+     */
+    static registerSourceHandler(source, handler) {
+        sourceHandlers[source] = handler;
+    }
+}
+exports.WebhookTrigger = WebhookTrigger;
+exports.default = WebhookTrigger;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WebhookTrigger.js","sourceRoot":"","sources":["../src/WebhookTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WebhookTrigger - Handle webhook events from external services\n *\n * Extends TriggerBase to process webhook events from:\n * - GitHub (push, pull_request, issues, etc.)\n * - Stripe (payment_intent, checkout.session, etc.)\n * - Shopify (orders, products, customers)\n * - Custom webhooks\n *\n * Features:\n * - Signature verification for security\n * - Event type filtering\n * - Retry support\n * - Dead letter handling\n */\n\nimport crypto from \"node:crypto\";\nimport type { HelperResponse, WebhookTriggerOpts } from \"@blok/helper\";\nimport {\n\tDefaultLogger,\n\ttype GlobalOptions,\n\ttype BlokService,\n\tNodeMap,\n\tTriggerBase,\n\ttype TriggerResponse,\n} from \"@blok/runner\";\nimport type { Context, RequestContext } from \"@blok/shared\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport { v4 as uuid } from \"uuid\";\n\n/**\n * Webhook event structure\n */\nexport interface WebhookEvent {\n\t/** Unique event ID */\n\tid: string;\n\t/** Source service (github, stripe, shopify, custom) */\n\tsource: string;\n\t/** Event type (e.g., push, payment_intent.succeeded) */\n\teventType: string;\n\t/** Event payload */\n\tpayload: unknown;\n\t/** Request headers */\n\theaders: Record<string, string>;\n\t/** Signature (if provided) */\n\tsignature?: string;\n\t/** Timestamp */\n\ttimestamp: Date;\n\t/** Raw request body */\n\trawBody: string;\n}\n\n/**\n * Signature verification result\n */\nexport interface VerificationResult {\n\tvalid: boolean;\n\terror?: string;\n}\n\n/**\n * Webhook source handlers\n */\nexport interface WebhookSourceHandler {\n\t/** Extract event type from request */\n\tgetEventType(headers: Record<string, string>, body: unknown): string;\n\t/** Get signature from request */\n\tgetSignature(headers: Record<string, string>): string | undefined;\n\t/** Verify signature */\n\tverifySignature(rawBody: string, signature: string, secret: string): VerificationResult;\n\t/** Get event ID */\n\tgetEventId(headers: Record<string, string>, body: unknown): string;\n}\n\n/**\n * Workflow model with webhook trigger configuration\n */\ninterface WebhookWorkflowModel {\n\tpath: string;\n\tconfig: {\n\t\tname: string;\n\t\tversion: string;\n\t\ttrigger?: {\n\t\t\twebhook?: WebhookTriggerOpts;\n\t\t\t[key: string]: unknown;\n\t\t};\n\t\t[key: string]: unknown;\n\t};\n}\n\n/**\n * Built-in source handlers\n */\nconst sourceHandlers: Record<string, WebhookSourceHandler> = {\n\tgithub: {\n\t\tgetEventType: (headers) => headers[\"x-github-event\"] || \"unknown\",\n\t\tgetSignature: (headers) => headers[\"x-hub-signature-256\"] || headers[\"x-hub-signature\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst digest = `sha256=${hmac.update(rawBody).digest(\"hex\")}`;\n\t\t\tconst sigBuffer = Buffer.from(signature);\n\t\t\tconst digestBuffer = Buffer.from(digest);\n\t\t\t// Length check first to avoid timing attack on length\n\t\t\tif (sigBuffer.length !== digestBuffer.length) {\n\t\t\t\treturn { valid: false, error: \"Invalid GitHub signature\" };\n\t\t\t}\n\t\t\tconst valid = crypto.timingSafeEqual(sigBuffer, digestBuffer);\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid GitHub signature\" };\n\t\t},\n\t\tgetEventId: (headers) => headers[\"x-github-delivery\"] || uuid(),\n\t},\n\n\tstripe: {\n\t\tgetEventType: (_, body) => (body as { type?: string })?.type || \"unknown\",\n\t\tgetSignature: (headers) => headers[\"stripe-signature\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\t// Stripe signature format: t=timestamp,v1=signature\n\t\t\tconst parts = signature.split(\",\").reduce(\n\t\t\t\t(acc, part) => {\n\t\t\t\t\tconst [key, value] = part.split(\"=\");\n\t\t\t\t\tacc[key] = value;\n\t\t\t\t\treturn acc;\n\t\t\t\t},\n\t\t\t\t{} as Record<string, string>,\n\t\t\t);\n\n\t\t\tconst timestamp = parts.t;\n\t\t\tconst expectedSig = parts.v1;\n\n\t\t\tif (!timestamp || !expectedSig) {\n\t\t\t\treturn { valid: false, error: \"Invalid Stripe signature format\" };\n\t\t\t}\n\n\t\t\tconst payload = `${timestamp}.${rawBody}`;\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst computedSig = hmac.update(payload).digest(\"hex\");\n\n\t\t\tconst sigBuffer = Buffer.from(expectedSig);\n\t\t\tconst computedBuffer = Buffer.from(computedSig);\n\t\t\tif (sigBuffer.length !== computedBuffer.length) {\n\t\t\t\treturn { valid: false, error: \"Invalid Stripe signature\" };\n\t\t\t}\n\t\t\tconst valid = crypto.timingSafeEqual(sigBuffer, computedBuffer);\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid Stripe signature\" };\n\t\t},\n\t\tgetEventId: (_, body) => (body as { id?: string })?.id || uuid(),\n\t},\n\n\tshopify: {\n\t\tgetEventType: (headers) => headers[\"x-shopify-topic\"] || \"unknown\",\n\t\tgetSignature: (headers) => headers[\"x-shopify-hmac-sha256\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst digest = hmac.update(rawBody, \"utf8\").digest(\"base64\");\n\t\t\tconst sigBuffer = Buffer.from(signature, \"base64\");\n\t\t\tconst digestBuffer = Buffer.from(digest, \"base64\");\n\t\t\tif (sigBuffer.length !== digestBuffer.length) {\n\t\t\t\treturn { valid: false, error: \"Invalid Shopify signature\" };\n\t\t\t}\n\t\t\tconst valid = crypto.timingSafeEqual(sigBuffer, digestBuffer);\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid Shopify signature\" };\n\t\t},\n\t\tgetEventId: (headers) => headers[\"x-shopify-webhook-id\"] || uuid(),\n\t},\n\n\tcustom: {\n\t\tgetEventType: (headers, body) => headers[\"x-event-type\"] || (body as { event?: string })?.event || \"custom\",\n\t\tgetSignature: (headers) => headers[\"x-signature\"] || headers[\"x-webhook-signature\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\t// Default: HMAC-SHA256\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst digest = hmac.update(rawBody).digest(\"hex\");\n\t\t\tconst valid = signature === digest || signature === `sha256=${digest}`;\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid signature\" };\n\t\t},\n\t\tgetEventId: (headers, body) => headers[\"x-event-id\"] || (body as { id?: string })?.id || uuid(),\n\t},\n};\n\n/**\n * WebhookTrigger - Handle webhook events\n */\nexport abstract class WebhookTrigger extends TriggerBase {\n\tprotected nodeMap: GlobalOptions = {} as GlobalOptions;\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-webhook-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\tprotected readonly logger = new DefaultLogger();\n\tprotected webhookWorkflows: WebhookWorkflowModel[] = [];\n\n\t// Subclasses provide these\n\tprotected abstract nodes: Record<string, BlokService<unknown>>;\n\tprotected abstract workflows: Record<string, HelperResponse>;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis.loadNodes();\n\t\tthis.loadWorkflows();\n\t}\n\n\t/**\n\t * Load nodes into the node map\n\t */\n\tloadNodes(): void {\n\t\tthis.nodeMap.nodes = new NodeMap();\n\t\tconst nodeKeys = Object.keys(this.nodes);\n\t\tfor (const key of nodeKeys) {\n\t\t\tthis.nodeMap.nodes.addNode(key, this.nodes[key]);\n\t\t}\n\t}\n\n\t/**\n\t * Load workflows into the workflow map\n\t */\n\tloadWorkflows(): void {\n\t\tthis.nodeMap.workflows = this.workflows;\n\t}\n\n\t/**\n\t * Initialize webhook trigger (call after loading workflows)\n\t */\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\n\t\t// Find all workflows with webhook triggers\n\t\tthis.webhookWorkflows = this.getWebhookWorkflows();\n\n\t\tif (this.webhookWorkflows.length === 0) {\n\t\t\tthis.logger.log(\"No workflows with webhook triggers found\");\n\t\t} else {\n\t\t\tthis.logger.log(`Webhook trigger initialized. ${this.webhookWorkflows.length} workflow(s) registered`);\n\t\t}\n\n\t\t// Enable HMR in development mode\n\t\tif (process.env.BLOK_HMR === \"true\" || process.env.NODE_ENV === \"development\") {\n\t\t\tawait this.enableHotReload();\n\t\t}\n\n\t\treturn this.endCounter(startTime);\n\t}\n\n\t/**\n\t * Stop the webhook trigger\n\t */\n\tasync stop(): Promise<void> {\n\t\tthis.webhookWorkflows = [];\n\t\tthis.logger.log(\"Webhook trigger stopped\");\n\t}\n\n\tprotected override async onHmrWorkflowChange(): Promise<void> {\n\t\tthis.loadWorkflows();\n\t\tthis.webhookWorkflows = this.getWebhookWorkflows();\n\t\tthis.logger.log(`[HMR] Webhook workflows reloaded. ${this.webhookWorkflows.length} workflow(s) registered`);\n\t}\n\n\t/**\n\t * Process an incoming webhook request\n\t * Call this from your HTTP endpoint handler\n\t */\n\tasync handleWebhook(\n\t\tsource: string,\n\t\trawBody: string,\n\t\theaders: Record<string, string>,\n\t): Promise<TriggerResponse | null> {\n\t\tconst handler = sourceHandlers[source] || sourceHandlers.custom;\n\n\t\t// Parse body\n\t\tlet body: unknown;\n\t\ttry {\n\t\t\tbody = JSON.parse(rawBody);\n\t\t} catch {\n\t\t\tbody = rawBody;\n\t\t}\n\n\t\t// Create webhook event\n\t\tconst event: WebhookEvent = {\n\t\t\tid: handler.getEventId(headers, body),\n\t\t\tsource,\n\t\t\teventType: handler.getEventType(headers, body),\n\t\t\tpayload: body,\n\t\t\theaders,\n\t\t\tsignature: handler.getSignature(headers),\n\t\t\ttimestamp: new Date(),\n\t\t\trawBody,\n\t\t};\n\n\t\t// Find matching workflow\n\t\tconst workflow = this.findMatchingWorkflow(event);\n\t\tif (!workflow) {\n\t\t\tthis.logger.log(`No matching workflow for webhook: ${source}/${event.eventType}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tconst config = workflow.config.trigger?.webhook as WebhookTriggerOpts;\n\n\t\t// Verify signature if secret is configured\n\t\tif (config.secret && event.signature) {\n\t\t\tconst verification = handler.verifySignature(rawBody, event.signature, config.secret);\n\t\t\tif (!verification.valid) {\n\t\t\t\tthis.logger.error(`Webhook signature verification failed: ${verification.error}`);\n\t\t\t\tthrow new Error(`Signature verification failed: ${verification.error}`);\n\t\t\t}\n\t\t} else if (config.secret && !event.signature) {\n\t\t\tthis.logger.error(\"Webhook signature missing but secret is configured\");\n\t\t\tthrow new Error(\"Signature missing\");\n\t\t}\n\n\t\treturn this.executeWorkflow(event, workflow, config);\n\t}\n\n\t/**\n\t * Get all workflows that have webhook triggers\n\t */\n\tprotected getWebhookWorkflows(): WebhookWorkflowModel[] {\n\t\tconst workflows: WebhookWorkflowModel[] = [];\n\n\t\tfor (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {\n\t\t\tconst workflowConfig = (workflow as unknown as { _config: WebhookWorkflowModel[\"config\"] })._config;\n\n\t\t\tif (workflowConfig?.trigger) {\n\t\t\t\tconst triggerType = Object.keys(workflowConfig.trigger)[0];\n\n\t\t\t\tif (triggerType === \"webhook\" && workflowConfig.trigger.webhook) {\n\t\t\t\t\tworkflows.push({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tconfig: workflowConfig,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn workflows;\n\t}\n\n\t/**\n\t * Find workflow matching the webhook event\n\t */\n\tprotected findMatchingWorkflow(event: WebhookEvent): WebhookWorkflowModel | null {\n\t\tfor (const workflow of this.webhookWorkflows) {\n\t\t\tconst config = workflow.config.trigger?.webhook;\n\t\t\tif (!config) continue;\n\n\t\t\t// Check source match\n\t\t\tif (config.source !== event.source) continue;\n\n\t\t\t// Check event type match\n\t\t\tif (config.events && config.events.length > 0) {\n\t\t\t\tconst matches = config.events.some((pattern) => {\n\t\t\t\t\t// Support wildcards (e.g., \"push\", \"pull_request.*\")\n\t\t\t\t\tif (pattern === \"*\") return true;\n\t\t\t\t\tif (pattern.endsWith(\".*\")) {\n\t\t\t\t\t\tconst prefix = pattern.slice(0, -2);\n\t\t\t\t\t\treturn event.eventType.startsWith(prefix);\n\t\t\t\t\t}\n\t\t\t\t\treturn pattern === event.eventType;\n\t\t\t\t});\n\t\t\t\tif (!matches) continue;\n\t\t\t}\n\n\t\t\treturn workflow;\n\t\t}\n\n\t\treturn null;\n\t}\n\n\t/**\n\t * Execute a workflow for a webhook event\n\t */\n\tprotected async executeWorkflow(\n\t\tevent: WebhookEvent,\n\t\tworkflow: WebhookWorkflowModel,\n\t\t_config: WebhookTriggerOpts,\n\t): Promise<TriggerResponse> {\n\t\tconst executionId = uuid();\n\n\t\tconst defaultMeter = metrics.getMeter(\"default\");\n\t\tconst webhookExecutions = defaultMeter.createCounter(\"webhook_executions\", {\n\t\t\tdescription: \"Webhook executions\",\n\t\t});\n\t\tconst webhookErrors = defaultMeter.createCounter(\"webhook_errors\", {\n\t\t\tdescription: \"Webhook execution errors\",\n\t\t});\n\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.tracer.startActiveSpan(`webhook:${event.source}/${event.eventType}`, async (span: Span) => {\n\t\t\t\ttry {\n\t\t\t\t\tconst start = performance.now();\n\n\t\t\t\t\t// Initialize configuration for this workflow\n\t\t\t\t\tawait this.configuration.init(workflow.path, this.nodeMap);\n\n\t\t\t\t\t// Create context\n\t\t\t\t\tconst ctx: Context = this.createContext(undefined, workflow.path, executionId);\n\n\t\t\t\t\t// Populate request with webhook event\n\t\t\t\t\tctx.request = {\n\t\t\t\t\t\tbody: event.payload,\n\t\t\t\t\t\theaders: event.headers,\n\t\t\t\t\t\tquery: {},\n\t\t\t\t\t\tparams: {\n\t\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\t\teventType: event.eventType,\n\t\t\t\t\t\t\teventId: event.id,\n\t\t\t\t\t\t},\n\t\t\t\t\t} as unknown as RequestContext;\n\n\t\t\t\t\t// Store webhook context in vars\n\t\t\t\t\tif (!ctx.vars) ctx.vars = {};\n\t\t\t\t\tctx.vars._webhook_event = {\n\t\t\t\t\t\tid: event.id,\n\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\teventType: event.eventType,\n\t\t\t\t\t\ttimestamp: event.timestamp.toISOString(),\n\t\t\t\t\t\thasSignature: String(!!event.signature),\n\t\t\t\t\t};\n\n\t\t\t\t\tctx.logger.log(`Processing webhook: ${event.source}/${event.eventType} (${event.id})`);\n\n\t\t\t\t\t// Execute workflow\n\t\t\t\t\tconst response: TriggerResponse = await this.run(ctx);\n\t\t\t\t\tconst end = performance.now();\n\n\t\t\t\t\t// Set span attributes\n\t\t\t\t\tspan.setAttribute(\"success\", true);\n\t\t\t\t\tspan.setAttribute(\"event_id\", event.id);\n\t\t\t\t\tspan.setAttribute(\"source\", event.source);\n\t\t\t\t\tspan.setAttribute(\"event_type\", event.eventType);\n\t\t\t\t\tspan.setAttribute(\"workflow_path\", workflow.path);\n\t\t\t\t\tspan.setAttribute(\"elapsed_ms\", end - start);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\n\t\t\t\t\t// Record metrics\n\t\t\t\t\twebhookExecutions.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\tevent_type: event.eventType,\n\t\t\t\t\t\tworkflow_name: this.configuration.name,\n\t\t\t\t\t\tsuccess: \"true\",\n\t\t\t\t\t});\n\n\t\t\t\t\tctx.logger.log(`Webhook processed in ${(end - start).toFixed(2)}ms: ${event.id}`);\n\n\t\t\t\t\tresolve(response);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tconst errorMessage = (error as Error).message;\n\n\t\t\t\t\t// Set span error\n\t\t\t\t\tspan.setAttribute(\"success\", false);\n\t\t\t\t\tspan.recordException(error as Error);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });\n\n\t\t\t\t\t// Record error metrics\n\t\t\t\t\twebhookErrors.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\tevent_type: event.eventType,\n\t\t\t\t\t\tworkflow_name: this.configuration?.name || \"unknown\",\n\t\t\t\t\t});\n\n\t\t\t\t\tthis.logger.error(`Webhook failed ${event.id}: ${errorMessage}`, (error as Error).stack);\n\n\t\t\t\t\tthrow error;\n\t\t\t\t} finally {\n\t\t\t\t\tspan.end();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n\n\t/**\n\t * Register a custom source handler\n\t */\n\tstatic registerSourceHandler(source: string, handler: WebhookSourceHandler): void {\n\t\tsourceHandlers[source] = handler;\n\t}\n}\n\nexport default WebhookTrigger;\nexport { sourceHandlers };\n"]}

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @blok/trigger-webhook
+ *
+ * Webhook trigger for Blok workflows.
+ * Handle webhook events from external services.
+ *
+ * Supported Services:
+ * - GitHub (push, pull_request, issues, releases, etc.)
+ * - Stripe (payment_intent, checkout.session, customer, etc.)
+ * - Shopify (orders, products, customers, etc.)
+ * - Custom webhooks (any service with signature verification)
+ *
+ * Features:
+ * - Signature verification (HMAC-SHA256)
+ * - Event type filtering
+ * - Source-specific handlers
+ * - Custom source registration
+ *
+ * @example
+ * ```typescript
+ * import { WebhookTrigger } from "@blok/trigger-webhook";
+ *
+ * class MyWebhookTrigger extends WebhookTrigger {
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ *
+ * const trigger = new MyWebhookTrigger();
+ * await trigger.listen();
+ *
+ * // In your HTTP endpoint handler:
+ * app.post("/webhooks/:source", async (req, res) => {
+ *   const rawBody = JSON.stringify(req.body);
+ *   const result = await trigger.handleWebhook(
+ *     req.params.source,
+ *     rawBody,
+ *     req.headers as Record<string, string>
+ *   );
+ *   res.status(200).json({ received: true });
+ * });
+ * ```
+ *
+ * Workflow Definition:
+ * ```typescript
+ * Workflow({ name: "github-push", version: "1.0.0" })
+ *   .addTrigger("webhook", {
+ *     source: "github",
+ *     events: ["push", "pull_request.*"],
+ *     secret: process.env.GITHUB_WEBHOOK_SECRET,
+ *   })
+ *   .addStep({ ... });
+ * ```
+ *
+ * Custom Source Handler:
+ * ```typescript
+ * import { WebhookTrigger } from "@blok/trigger-webhook";
+ *
+ * WebhookTrigger.registerSourceHandler("my-service", {
+ *   getEventType: (headers, body) => body.event_type,
+ *   getSignature: (headers) => headers["x-my-signature"],
+ *   verifySignature: (rawBody, signature, secret) => {
+ *     // Your verification logic
+ *     return { valid: true };
+ *   },
+ *   getEventId: (headers, body) => body.id,
+ * });
+ * ```
+ */
+export { WebhookTrigger, sourceHandlers, type WebhookEvent, type VerificationResult, type WebhookSourceHandler, } from "./WebhookTrigger";
+export type { WebhookTriggerOpts } from "@blok/helper";