@railhook/node 2.12.0

package/dist/webhooks.js

@@ -0,0 +1,241 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = verifySignature;
+exports.verifyStandardWebhook = verifyStandardWebhook;
+exports.constructEvent = constructEvent;
+exports.generateSignature = generateSignature;
+const crypto = __importStar(require("crypto"));
+const errors_1 = require("./errors");
+const SIGNATURE_HEADER = 'x-signature';
+const TIMESTAMP_HEADER = 'x-timestamp';
+const EVENT_ID_HEADER = 'x-event-id';
+const DELIVERY_ID_HEADER = 'x-delivery-id';
+const DEFAULT_TOLERANCE = 300000; // 5 minutes in milliseconds
+/**
+ * Verifies the webhook signature using HMAC-SHA256.
+ *
+ * The header is `t=<unix-ms>,v1=<hex>`, and it may carry **more than one** `v1`.
+ * After you rotate an endpoint's secret, Railhook signs each delivery with both
+ * the new secret and the retired one for the endpoint's grace window (24 hours
+ * by default), so you can deploy the new secret whenever you like instead of at
+ * the instant you press rotate. The delivery is authentic if *any* `v1` matches,
+ * which is what this checks.
+ *
+ * @param payload - Raw request body as string
+ * @param signature - X-Signature header value (format: t=timestamp,v1=signature[,v1=...])
+ * @param secret - Endpoint webhook secret
+ * @param options - Verification options
+ * @returns true if signature is valid
+ * @throws RailhookError if signature is invalid
+ */
+function verifySignature(payload, signature, secret, options = {}) {
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+    if (!signature) {
+        throw new errors_1.RailhookError('Missing signature header', 400, 'invalid_signature');
+    }
+    const parts = signature.split(',');
+    let timestamp;
+    const signatures = [];
+    for (const part of parts) {
+        const [key, value] = part.split('=');
+        if (key === 't')
+            timestamp = value?.trim();
+        // Collected, not overwritten: a header sent during a secret rotation carries
+        // one v1 per valid secret, and keeping only the last would reject whichever
+        // of the pair you are currently holding.
+        if (key === 'v1' && value)
+            signatures.push(value.trim());
+    }
+    if (!timestamp || signatures.length === 0) {
+        throw new errors_1.RailhookError('Invalid signature format. Expected: t=timestamp,v1=signature', 400, 'invalid_signature');
+    }
+    const timestampMs = parseInt(timestamp, 10);
+    const now = Date.now();
+    if (Math.abs(now - timestampMs) > tolerance) {
+        throw new errors_1.RailhookError('Webhook timestamp is outside tolerance window', 400, 'timestamp_expired');
+    }
+    const signedPayload = `${timestamp}.${payload}`;
+    const expectedSignature = crypto
+        .createHmac('sha256', secret)
+        .update(signedPayload)
+        .digest('hex');
+    const expectedBuffer = Buffer.from(expectedSignature);
+    // Every candidate is compared — no early exit — so the time taken does not
+    // depend on which position matched.
+    let matched = false;
+    for (const candidate of signatures) {
+        const sigBuffer = Buffer.from(candidate);
+        if (sigBuffer.length === expectedBuffer.length && crypto.timingSafeEqual(sigBuffer, expectedBuffer)) {
+            matched = true;
+        }
+    }
+    if (!matched) {
+        throw new errors_1.RailhookError('Invalid signature', 400, 'invalid_signature');
+    }
+    return true;
+}
+const STANDARD_ID_HEADER = 'webhook-id';
+const STANDARD_TIMESTAMP_HEADER = 'webhook-timestamp';
+const STANDARD_SIGNATURE_HEADER = 'webhook-signature';
+/** Tolerance for the Standard Webhooks headers, whose timestamp is in **seconds**. */
+const DEFAULT_STANDARD_TOLERANCE_SECONDS = 300;
+/**
+ * Verifies the [Standard Webhooks](https://www.standardwebhooks.com) headers.
+ *
+ * Endpoints receive both header sets by default (`signatureScheme: 'BOTH'`), so use
+ * whichever you prefer — this one if you would rather your verification match what other
+ * providers send, `verifySignature` if you are already verifying `X-Signature`.
+ *
+ * Two things differ from Railhook's own scheme beyond the header names: the message id is
+ * part of what is signed, and the digest is base64 rather than hex. Rotation works the same
+ * way — during the grace window the header carries a space-separated signature per valid
+ * secret, and any one matching is enough.
+ *
+ * @param payload - Raw request body as string
+ * @param headers - Request headers, including the three `webhook-*` ones
+ * @param secret - The endpoint's `standardWebhooksSecret` (`whsec_…`), not the raw secret.
+ *                 A plain secret is accepted too and used as-is.
+ * @returns true if the signature is valid
+ * @throws RailhookError if it is not
+ */
+function verifyStandardWebhook(payload, headers, secret, options = {}) {
+    const tolerance = options.toleranceSeconds ?? DEFAULT_STANDARD_TOLERANCE_SECONDS;
+    const id = headers[STANDARD_ID_HEADER] || headers['Webhook-Id'];
+    const timestamp = headers[STANDARD_TIMESTAMP_HEADER] || headers['Webhook-Timestamp'];
+    const signature = headers[STANDARD_SIGNATURE_HEADER] || headers['Webhook-Signature'];
+    if (!id || !timestamp || !signature) {
+        throw new errors_1.RailhookError('Missing webhook-id, webhook-timestamp or webhook-signature header', 400, 'invalid_signature');
+    }
+    const timestampSeconds = parseInt(timestamp, 10);
+    if (Number.isNaN(timestampSeconds)) {
+        throw new errors_1.RailhookError('Invalid webhook-timestamp header', 400, 'invalid_signature');
+    }
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    if (Math.abs(nowSeconds - timestampSeconds) > tolerance) {
+        throw new errors_1.RailhookError('Webhook timestamp is outside tolerance window', 400, 'timestamp_expired');
+    }
+    // `whsec_<base64>` is the conventional form and is what the endpoint's
+    // standardWebhooksSecret gives you; the base64 body decodes to the key bytes. Anything
+    // else is taken literally, so a raw secret still works.
+    const key = secret.startsWith('whsec_')
+        ? Buffer.from(secret.slice('whsec_'.length), 'base64')
+        : Buffer.from(secret, 'utf8');
+    const expected = crypto
+        .createHmac('sha256', key)
+        .update(`${id}.${timestampSeconds}.${payload}`)
+        .digest('base64');
+    const expectedBuffer = Buffer.from(expected);
+    // Space-separated, one per valid secret during a rotation window. Every candidate is
+    // compared with no early exit, so the time taken does not reveal which one matched.
+    let matched = false;
+    for (const part of signature.trim().split(/\s+/)) {
+        const comma = part.indexOf(',');
+        if (comma < 1 || part.slice(0, comma) !== 'v1')
+            continue;
+        const candidate = Buffer.from(part.slice(comma + 1));
+        if (candidate.length === expectedBuffer.length && crypto.timingSafeEqual(candidate, expectedBuffer)) {
+            matched = true;
+        }
+    }
+    if (!matched) {
+        throw new errors_1.RailhookError('Invalid signature', 400, 'invalid_signature');
+    }
+    return true;
+}
+/**
+ * Constructs a webhook event from the request.
+ *
+ * What Railhook actually PUTs on the wire is the event's **payload**, not an
+ * envelope: a `client.events.send({ type: 'order.completed', data: {...} })`
+ * arrives at your endpoint as the `data` object alone, with the identifiers
+ * carried in headers (`X-Event-Id`, `X-Delivery-Id`, `X-Timestamp`,
+ * `X-Sequence-Number`). So:
+ *
+ * - `eventId` / `deliveryId` / `timestamp` come from the headers and are
+ *   always populated for a real delivery.
+ * - `data` is the parsed body.
+ * - `type` is only populated when the body happens to carry a `type` key —
+ *   which for a default subscription it does not. Route on the payload, or
+ *   configure the subscription's `payloadTemplate` to wrap the event so that
+ *   `type` is part of the body.
+ *
+ * @param payload - Raw request body as string
+ * @param headers - Request headers
+ * @param secret - Endpoint webhook secret
+ * @param options - Verification options
+ * @returns Parsed and verified webhook event
+ */
+function constructEvent(payload, headers, secret, options = {}) {
+    const signature = headers[SIGNATURE_HEADER] || headers['X-Signature'];
+    const timestamp = headers[TIMESTAMP_HEADER] || headers['X-Timestamp'];
+    const eventId = headers[EVENT_ID_HEADER] || headers['X-Event-Id'];
+    const deliveryId = headers[DELIVERY_ID_HEADER] || headers['X-Delivery-Id'];
+    if (!signature) {
+        throw new errors_1.RailhookError('Missing X-Signature header', 400, 'missing_header');
+    }
+    verifySignature(payload, signature, secret, options);
+    let data;
+    try {
+        data = JSON.parse(payload);
+    }
+    catch {
+        throw new errors_1.RailhookError('Invalid JSON payload', 400, 'invalid_payload');
+    }
+    return {
+        eventId: eventId || '',
+        deliveryId: deliveryId || '',
+        timestamp: timestamp ? parseInt(timestamp, 10) : Date.now(),
+        type: data.type || '',
+        data: data.data || data,
+    };
+}
+/**
+ * Generates a signature for testing purposes
+ * @param payload - Request body as string
+ * @param secret - Webhook secret
+ * @param timestamp - Optional timestamp (defaults to now)
+ * @returns Signature string in format t=timestamp,v1=signature
+ */
+function generateSignature(payload, secret, timestamp) {
+    const ts = timestamp ?? Date.now();
+    const signedPayload = `${ts}.${payload}`;
+    const signature = crypto
+        .createHmac('sha256', secret)
+        .update(signedPayload)
+        .digest('hex');
+    return `t=${ts},v1=${signature}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhooks.js","sourceRoot":"","sources":["../src/webhooks.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,0CAkEC;AA4BD,sDAgEC;AAyBD,wCA+BC;AASD,8CAaC;AApRD,+CAAiC;AAEjC,qCAAyC;AAEzC,MAAM,gBAAgB,GAAG,aAAa,CAAC;AACvC,MAAM,gBAAgB,GAAG,aAAa,CAAC;AACvC,MAAM,eAAe,GAAG,YAAY,CAAC;AACrC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAE3C,MAAM,iBAAiB,GAAG,MAAM,CAAC,CAAC,4BAA4B;AAc9D;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,eAAe,CAC7B,OAAe,EACf,SAAiB,EACjB,MAAc,EACd,UAAyB,EAAE;IAE3B,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,iBAAiB,CAAC;IAEzD,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,sBAAa,CAAC,0BAA0B,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC;IAChF,CAAC;IAED,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,SAA6B,CAAC;IAClC,MAAM,UAAU,GAAa,EAAE,CAAC;IAEhC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,GAAG,KAAK,GAAG;YAAE,SAAS,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC;QAC3C,6EAA6E;QAC7E,4EAA4E;QAC5E,yCAAyC;QACzC,IAAI,GAAG,KAAK,IAAI,IAAI,KAAK;YAAE,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,CAAC,SAAS,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,sBAAa,CACrB,8DAA8D,EAC9D,GAAG,EACH,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEvB,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,WAAW,CAAC,GAAG,SAAS,EAAE,CAAC;QAC5C,MAAM,IAAI,sBAAa,CACrB,+CAA+C,EAC/C,GAAG,EACH,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED,MAAM,aAAa,GAAG,GAAG,SAAS,IAAI,OAAO,EAAE,CAAC;IAChD,MAAM,iBAAiB,GAAG,MAAM;SAC7B,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC;SAC5B,MAAM,CAAC,aAAa,CAAC;SACrB,MAAM,CAAC,KAAK,CAAC,CAAC;IAEjB,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACtD,2EAA2E;IAC3E,oCAAoC;IACpC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzC,IAAI,SAAS,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,CAAC;YACpG,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,sBAAa,CAAC,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,kBAAkB,GAAG,YAAY,CAAC;AACxC,MAAM,yBAAyB,GAAG,mBAAmB,CAAC;AACtD,MAAM,yBAAyB,GAAG,mBAAmB,CAAC;AAEtD,sFAAsF;AACtF,MAAM,kCAAkC,GAAG,GAAG,CAAC;AAE/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,qBAAqB,CACnC,OAAe,EACf,OAAuB,EACvB,MAAc,EACd,UAAyC,EAAE;IAE3C,MAAM,SAAS,GAAG,OAAO,CAAC,gBAAgB,IAAI,kCAAkC,CAAC;IAEjF,MAAM,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAChE,MAAM,SAAS,GAAG,OAAO,CAAC,yBAAyB,CAAC,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrF,MAAM,SAAS,GAAG,OAAO,CAAC,yBAAyB,CAAC,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAErF,IAAI,CAAC,EAAE,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC;QACpC,MAAM,IAAI,sBAAa,CACrB,mEAAmE,EACnE,GAAG,EACH,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED,MAAM,gBAAgB,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACjD,IAAI,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,sBAAa,CAAC,kCAAkC,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC;IACxF,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IACjD,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG,gBAAgB,CAAC,GAAG,SAAS,EAAE,CAAC;QACxD,MAAM,IAAI,sBAAa,CACrB,+CAA+C,EAC/C,GAAG,EACH,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED,uEAAuE;IACvE,uFAAuF;IACvF,wDAAwD;IACxD,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC;QACrC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC;QACtD,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC,MAAM,QAAQ,GAAG,MAAM;SACpB,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC;SACzB,MAAM,CAAC,GAAG,EAAE,IAAI,gBAAgB,IAAI,OAAO,EAAE,CAAC;SAC9C,MAAM,CAAC,QAAQ,CAAC,CAAC;IACpB,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAE7C,qFAAqF;IACrF,oFAAoF;IACpF,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,IAAI;YAAE,SAAS;QACzD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;QACrD,IAAI,SAAS,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,CAAC;YACpG,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,sBAAa,CAAC,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,cAAc,CAC5B,OAAe,EACf,OAAuB,EACvB,MAAc,EACd,UAAyB,EAAE;IAE3B,MAAM,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IACtE,MAAM,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IACtE,MAAM,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAClE,MAAM,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IAE3E,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,sBAAa,CAAC,4BAA4B,EAAE,GAAG,EAAE,gBAAgB,CAAC,CAAC;IAC/E,CAAC;IAED,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAErD,IAAI,IAA6B,CAAC;IAClC,IAAI,CAAC;QACH,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,sBAAa,CAAC,sBAAsB,EAAE,GAAG,EAAE,iBAAiB,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO;QACL,OAAO,EAAE,OAAO,IAAI,EAAE;QACtB,UAAU,EAAE,UAAU,IAAI,EAAE;QAC5B,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;QAC3D,IAAI,EAAG,IAAI,CAAC,IAAe,IAAI,EAAE;QACjC,IAAI,EAAG,IAAI,CAAC,IAAgC,IAAI,IAAI;KACrD,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAC/B,OAAe,EACf,MAAc,EACd,SAAkB;IAElB,MAAM,EAAE,GAAG,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;IACnC,MAAM,aAAa,GAAG,GAAG,EAAE,IAAI,OAAO,EAAE,CAAC;IACzC,MAAM,SAAS,GAAG,MAAM;SACrB,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC;SAC5B,MAAM,CAAC,aAAa,CAAC;SACrB,MAAM,CAAC,KAAK,CAAC,CAAC;IAEjB,OAAO,KAAK,EAAE,OAAO,SAAS,EAAE,CAAC;AACnC,CAAC","sourcesContent":["import * as crypto from 'crypto';\nimport { WebhookEvent } from './types';\nimport { RailhookError } from './errors';\n\nconst SIGNATURE_HEADER = 'x-signature';\nconst TIMESTAMP_HEADER = 'x-timestamp';\nconst EVENT_ID_HEADER = 'x-event-id';\nconst DELIVERY_ID_HEADER = 'x-delivery-id';\n\nconst DEFAULT_TOLERANCE = 300000; // 5 minutes in milliseconds\n\nexport interface WebhookHeaders {\n  'x-signature'?: string;\n  'x-timestamp'?: string;\n  'x-event-id'?: string;\n  'x-delivery-id'?: string;\n  [key: string]: string | undefined;\n}\n\nexport interface VerifyOptions {\n  tolerance?: number;\n}\n\n/**\n * Verifies the webhook signature using HMAC-SHA256.\n *\n * The header is `t=<unix-ms>,v1=<hex>`, and it may carry **more than one** `v1`.\n * After you rotate an endpoint's secret, Railhook signs each delivery with both\n * the new secret and the retired one for the endpoint's grace window (24 hours\n * by default), so you can deploy the new secret whenever you like instead of at\n * the instant you press rotate. The delivery is authentic if *any* `v1` matches,\n * which is what this checks.\n *\n * @param payload - Raw request body as string\n * @param signature - X-Signature header value (format: t=timestamp,v1=signature[,v1=...])\n * @param secret - Endpoint webhook secret\n * @param options - Verification options\n * @returns true if signature is valid\n * @throws RailhookError if signature is invalid\n */\nexport function verifySignature(\n  payload: string,\n  signature: string,\n  secret: string,\n  options: VerifyOptions = {}\n): boolean {\n  const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;\n\n  if (!signature) {\n    throw new RailhookError('Missing signature header', 400, 'invalid_signature');\n  }\n\n  const parts = signature.split(',');\n  let timestamp: string | undefined;\n  const signatures: string[] = [];\n\n  for (const part of parts) {\n    const [key, value] = part.split('=');\n    if (key === 't') timestamp = value?.trim();\n    // Collected, not overwritten: a header sent during a secret rotation carries\n    // one v1 per valid secret, and keeping only the last would reject whichever\n    // of the pair you are currently holding.\n    if (key === 'v1' && value) signatures.push(value.trim());\n  }\n\n  if (!timestamp || signatures.length === 0) {\n    throw new RailhookError(\n      'Invalid signature format. Expected: t=timestamp,v1=signature',\n      400,\n      'invalid_signature'\n    );\n  }\n\n  const timestampMs = parseInt(timestamp, 10);\n  const now = Date.now();\n\n  if (Math.abs(now - timestampMs) > tolerance) {\n    throw new RailhookError(\n      'Webhook timestamp is outside tolerance window',\n      400,\n      'timestamp_expired'\n    );\n  }\n\n  const signedPayload = `${timestamp}.${payload}`;\n  const expectedSignature = crypto\n    .createHmac('sha256', secret)\n    .update(signedPayload)\n    .digest('hex');\n\n  const expectedBuffer = Buffer.from(expectedSignature);\n  // Every candidate is compared — no early exit — so the time taken does not\n  // depend on which position matched.\n  let matched = false;\n  for (const candidate of signatures) {\n    const sigBuffer = Buffer.from(candidate);\n    if (sigBuffer.length === expectedBuffer.length && crypto.timingSafeEqual(sigBuffer, expectedBuffer)) {\n      matched = true;\n    }\n  }\n\n  if (!matched) {\n    throw new RailhookError('Invalid signature', 400, 'invalid_signature');\n  }\n\n  return true;\n}\n\nconst STANDARD_ID_HEADER = 'webhook-id';\nconst STANDARD_TIMESTAMP_HEADER = 'webhook-timestamp';\nconst STANDARD_SIGNATURE_HEADER = 'webhook-signature';\n\n/** Tolerance for the Standard Webhooks headers, whose timestamp is in **seconds**. */\nconst DEFAULT_STANDARD_TOLERANCE_SECONDS = 300;\n\n/**\n * Verifies the [Standard Webhooks](https://www.standardwebhooks.com) headers.\n *\n * Endpoints receive both header sets by default (`signatureScheme: 'BOTH'`), so use\n * whichever you prefer — this one if you would rather your verification match what other\n * providers send, `verifySignature` if you are already verifying `X-Signature`.\n *\n * Two things differ from Railhook's own scheme beyond the header names: the message id is\n * part of what is signed, and the digest is base64 rather than hex. Rotation works the same\n * way — during the grace window the header carries a space-separated signature per valid\n * secret, and any one matching is enough.\n *\n * @param payload - Raw request body as string\n * @param headers - Request headers, including the three `webhook-*` ones\n * @param secret - The endpoint's `standardWebhooksSecret` (`whsec_…`), not the raw secret.\n *                 A plain secret is accepted too and used as-is.\n * @returns true if the signature is valid\n * @throws RailhookError if it is not\n */\nexport function verifyStandardWebhook(\n  payload: string,\n  headers: WebhookHeaders,\n  secret: string,\n  options: { toleranceSeconds?: number } = {}\n): boolean {\n  const tolerance = options.toleranceSeconds ?? DEFAULT_STANDARD_TOLERANCE_SECONDS;\n\n  const id = headers[STANDARD_ID_HEADER] || headers['Webhook-Id'];\n  const timestamp = headers[STANDARD_TIMESTAMP_HEADER] || headers['Webhook-Timestamp'];\n  const signature = headers[STANDARD_SIGNATURE_HEADER] || headers['Webhook-Signature'];\n\n  if (!id || !timestamp || !signature) {\n    throw new RailhookError(\n      'Missing webhook-id, webhook-timestamp or webhook-signature header',\n      400,\n      'invalid_signature'\n    );\n  }\n\n  const timestampSeconds = parseInt(timestamp, 10);\n  if (Number.isNaN(timestampSeconds)) {\n    throw new RailhookError('Invalid webhook-timestamp header', 400, 'invalid_signature');\n  }\n\n  const nowSeconds = Math.floor(Date.now() / 1000);\n  if (Math.abs(nowSeconds - timestampSeconds) > tolerance) {\n    throw new RailhookError(\n      'Webhook timestamp is outside tolerance window',\n      400,\n      'timestamp_expired'\n    );\n  }\n\n  // `whsec_<base64>` is the conventional form and is what the endpoint's\n  // standardWebhooksSecret gives you; the base64 body decodes to the key bytes. Anything\n  // else is taken literally, so a raw secret still works.\n  const key = secret.startsWith('whsec_')\n    ? Buffer.from(secret.slice('whsec_'.length), 'base64')\n    : Buffer.from(secret, 'utf8');\n\n  const expected = crypto\n    .createHmac('sha256', key)\n    .update(`${id}.${timestampSeconds}.${payload}`)\n    .digest('base64');\n  const expectedBuffer = Buffer.from(expected);\n\n  // Space-separated, one per valid secret during a rotation window. Every candidate is\n  // compared with no early exit, so the time taken does not reveal which one matched.\n  let matched = false;\n  for (const part of signature.trim().split(/\\s+/)) {\n    const comma = part.indexOf(',');\n    if (comma < 1 || part.slice(0, comma) !== 'v1') continue;\n    const candidate = Buffer.from(part.slice(comma + 1));\n    if (candidate.length === expectedBuffer.length && crypto.timingSafeEqual(candidate, expectedBuffer)) {\n      matched = true;\n    }\n  }\n\n  if (!matched) {\n    throw new RailhookError('Invalid signature', 400, 'invalid_signature');\n  }\n\n  return true;\n}\n\n/**\n * Constructs a webhook event from the request.\n *\n * What Railhook actually PUTs on the wire is the event's **payload**, not an\n * envelope: a `client.events.send({ type: 'order.completed', data: {...} })`\n * arrives at your endpoint as the `data` object alone, with the identifiers\n * carried in headers (`X-Event-Id`, `X-Delivery-Id`, `X-Timestamp`,\n * `X-Sequence-Number`). So:\n *\n * - `eventId` / `deliveryId` / `timestamp` come from the headers and are\n *   always populated for a real delivery.\n * - `data` is the parsed body.\n * - `type` is only populated when the body happens to carry a `type` key —\n *   which for a default subscription it does not. Route on the payload, or\n *   configure the subscription's `payloadTemplate` to wrap the event so that\n *   `type` is part of the body.\n *\n * @param payload - Raw request body as string\n * @param headers - Request headers\n * @param secret - Endpoint webhook secret\n * @param options - Verification options\n * @returns Parsed and verified webhook event\n */\nexport function constructEvent(\n  payload: string,\n  headers: WebhookHeaders,\n  secret: string,\n  options: VerifyOptions = {}\n): WebhookEvent {\n  const signature = headers[SIGNATURE_HEADER] || headers['X-Signature'];\n  const timestamp = headers[TIMESTAMP_HEADER] || headers['X-Timestamp'];\n  const eventId = headers[EVENT_ID_HEADER] || headers['X-Event-Id'];\n  const deliveryId = headers[DELIVERY_ID_HEADER] || headers['X-Delivery-Id'];\n\n  if (!signature) {\n    throw new RailhookError('Missing X-Signature header', 400, 'missing_header');\n  }\n\n  verifySignature(payload, signature, secret, options);\n\n  let data: Record<string, unknown>;\n  try {\n    data = JSON.parse(payload);\n  } catch {\n    throw new RailhookError('Invalid JSON payload', 400, 'invalid_payload');\n  }\n\n  return {\n    eventId: eventId || '',\n    deliveryId: deliveryId || '',\n    timestamp: timestamp ? parseInt(timestamp, 10) : Date.now(),\n    type: (data.type as string) || '',\n    data: (data.data as Record<string, unknown>) || data,\n  };\n}\n\n/**\n * Generates a signature for testing purposes\n * @param payload - Request body as string\n * @param secret - Webhook secret\n * @param timestamp - Optional timestamp (defaults to now)\n * @returns Signature string in format t=timestamp,v1=signature\n */\nexport function generateSignature(\n  payload: string,\n  secret: string,\n  timestamp?: number\n): string {\n  const ts = timestamp ?? Date.now();\n  const signedPayload = `${ts}.${payload}`;\n  const signature = crypto\n    .createHmac('sha256', secret)\n    .update(signedPayload)\n    .digest('hex');\n\n  return `t=${ts},v1=${signature}`;\n}\n"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@railhook/node",
+  "version": "2.12.0",
+  "description": "Official Node.js SDK for Railhook — reliable webhook infrastructure",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:contract": "jest --config jest.contract.config.js",
+    "smoke:live": "npm run build && node scripts/live-api-smoke.mjs",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "webhook",
+    "webhooks",
+    "api",
+    "events",
+    "delivery"
+  ],
+  "author": "Vadym Kykalo <vadymkykalo@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vadymkykalo/railhook.git",
+    "directory": "sdks/node"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^26.3.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {}
+}