@railhook/node 2.12.0

package/dist/__tests__/webhooks.test.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webhooks_1 = require("../webhooks");
+const errors_1 = require("../errors");
+describe('Webhook Signature Verification', () => {
+    const secret = 'whsec_test_secret_key_123';
+    const payload = JSON.stringify({ type: 'order.completed', data: { orderId: '12345' } });
+    describe('generateSignature', () => {
+        it('should generate valid signature format', () => {
+            const signature = (0, webhooks_1.generateSignature)(payload, secret);
+            expect(signature).toMatch(/^t=\d+,v1=[a-f0-9]{64}$/);
+        });
+        it('should use provided timestamp', () => {
+            const timestamp = 1700000000000;
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            expect(signature).toContain(`t=${timestamp}`);
+        });
+        it('should generate consistent signatures for same inputs', () => {
+            const timestamp = 1700000000000;
+            const sig1 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const sig2 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            expect(sig1).toBe(sig2);
+        });
+        it('should generate different signatures for different payloads', () => {
+            const timestamp = 1700000000000;
+            const sig1 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const sig2 = (0, webhooks_1.generateSignature)('different payload', secret, timestamp);
+            expect(sig1).not.toBe(sig2);
+        });
+        it('should generate different signatures for different secrets', () => {
+            const timestamp = 1700000000000;
+            const sig1 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const sig2 = (0, webhooks_1.generateSignature)(payload, 'different_secret', timestamp);
+            expect(sig1).not.toBe(sig2);
+        });
+    });
+    /**
+     * After a rotation Railhook signs each delivery with the new secret and the retired one
+     * for the endpoint's grace window, so a receiver that has not deployed the new secret yet
+     * keeps working. The parser used to keep only the last v1 and rejected whichever half of
+     * the pair the receiver was holding.
+     */
+    describe('a header carrying two signatures (secret rotation)', () => {
+        const newSecret = 'whsec_new';
+        const retiredSecret = 'whsec_retired';
+        const dualHeader = (body, at = Date.now()) => {
+            const retiredV1 = (0, webhooks_1.generateSignature)(body, retiredSecret, at).split('v1=')[1];
+            return `${(0, webhooks_1.generateSignature)(body, newSecret, at)},v1=${retiredV1}`;
+        };
+        it('verifies with the new secret', () => {
+            expect((0, webhooks_1.verifySignature)(payload, dualHeader(payload), newSecret)).toBe(true);
+        });
+        it('verifies with the retired secret', () => {
+            expect((0, webhooks_1.verifySignature)(payload, dualHeader(payload), retiredSecret)).toBe(true);
+        });
+        it('still rejects an unrelated secret', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, dualHeader(payload), 'whsec_someone_else'))
+                .toThrow(errors_1.RailhookError);
+        });
+        it('still rejects a tampered body', () => {
+            expect(() => (0, webhooks_1.verifySignature)(`${payload} `, dualHeader(payload), newSecret))
+                .toThrow(errors_1.RailhookError);
+        });
+    });
+    describe('verifySignature', () => {
+        it('should verify valid signature', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            expect((0, webhooks_1.verifySignature)(payload, signature, secret)).toBe(true);
+        });
+        it('should throw on missing signature', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, '', secret)).toThrow(errors_1.RailhookError);
+            expect(() => (0, webhooks_1.verifySignature)(payload, '', secret)).toThrow('Missing signature header');
+        });
+        it('should throw on invalid signature format', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, 'invalid', secret)).toThrow('Invalid signature format');
+        });
+        it('should throw on missing timestamp', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, 'v1=abc123', secret)).toThrow('Invalid signature format');
+        });
+        it('should throw on missing v1 signature', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, 't=1700000000000', secret)).toThrow('Invalid signature format');
+        });
+        it('should throw on expired timestamp', () => {
+            const oldTimestamp = Date.now() - 600000; // 10 minutes ago
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, oldTimestamp);
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret)).toThrow('outside tolerance window');
+        });
+        it('should throw on future timestamp outside tolerance', () => {
+            const futureTimestamp = Date.now() + 600000; // 10 minutes in future
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, futureTimestamp);
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret)).toThrow('outside tolerance window');
+        });
+        it('should accept timestamp within tolerance', () => {
+            const recentTimestamp = Date.now() - 60000; // 1 minute ago
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, recentTimestamp);
+            expect((0, webhooks_1.verifySignature)(payload, signature, secret)).toBe(true);
+        });
+        it('should throw on invalid signature value', () => {
+            const timestamp = Date.now();
+            const signature = `t=${timestamp},v1=invalid_signature_that_will_not_match`;
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret)).toThrow('Invalid signature');
+        });
+        it('should throw on tampered payload', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const tamperedPayload = JSON.stringify({ type: 'order.cancelled', data: {} });
+            expect(() => (0, webhooks_1.verifySignature)(tamperedPayload, signature, secret)).toThrow('Invalid signature');
+        });
+        it('should respect custom tolerance', () => {
+            const oldTimestamp = Date.now() - 60000; // 1 minute ago
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, oldTimestamp);
+            // Should fail with 30s tolerance
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret, { tolerance: 30000 }))
+                .toThrow('outside tolerance window');
+            // Should pass with 2min tolerance
+            expect((0, webhooks_1.verifySignature)(payload, signature, secret, { tolerance: 120000 })).toBe(true);
+        });
+    });
+    describe('constructEvent', () => {
+        it('should construct event from valid request', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+                'x-timestamp': timestamp.toString(),
+                'x-event-id': 'evt_123',
+                'x-delivery-id': 'dlv_456',
+            };
+            const event = (0, webhooks_1.constructEvent)(payload, headers, secret);
+            expect(event.eventId).toBe('evt_123');
+            expect(event.deliveryId).toBe('dlv_456');
+            expect(event.timestamp).toBe(timestamp);
+            expect(event.type).toBe('order.completed');
+            expect(event.data).toEqual({ orderId: '12345' });
+        });
+        it('should handle uppercase headers', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const headers = {
+                'X-Signature': signature,
+                'X-Timestamp': timestamp.toString(),
+                'X-Event-Id': 'evt_123',
+                'X-Delivery-Id': 'dlv_456',
+            };
+            const event = (0, webhooks_1.constructEvent)(payload, headers, secret);
+            expect(event.eventId).toBe('evt_123');
+        });
+        it('should throw on missing signature header', () => {
+            const headers = {
+                'x-timestamp': Date.now().toString(),
+            };
+            expect(() => (0, webhooks_1.constructEvent)(payload, headers, secret))
+                .toThrow('Missing X-Signature header');
+        });
+        it('should throw on invalid JSON payload', () => {
+            const timestamp = Date.now();
+            const invalidPayload = 'not valid json';
+            const signature = (0, webhooks_1.generateSignature)(invalidPayload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+                'x-timestamp': timestamp.toString(),
+            };
+            expect(() => (0, webhooks_1.constructEvent)(invalidPayload, headers, secret))
+                .toThrow('Invalid JSON payload');
+        });
+        it('should handle payload without nested data field', () => {
+            const flatPayload = JSON.stringify({ type: 'test.event', value: 123 });
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(flatPayload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+                'x-timestamp': timestamp.toString(),
+            };
+            const event = (0, webhooks_1.constructEvent)(flatPayload, headers, secret);
+            expect(event.type).toBe('test.event');
+            expect(event.data).toEqual({ type: 'test.event', value: 123 });
+        });
+        it('should use current timestamp if not provided in headers', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+            };
+            const event = (0, webhooks_1.constructEvent)(payload, headers, secret);
+            expect(event.timestamp).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhooks.test.js","sourceRoot":"","sources":["../../src/__tests__/webhooks.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { verifySignature, constructEvent, generateSignature } from '../webhooks';\nimport { RailhookError } from '../errors';\n\ndescribe('Webhook Signature Verification', () => {\n  const secret = 'whsec_test_secret_key_123';\n  const payload = JSON.stringify({ type: 'order.completed', data: { orderId: '12345' } });\n\n  describe('generateSignature', () => {\n    it('should generate valid signature format', () => {\n      const signature = generateSignature(payload, secret);\n      expect(signature).toMatch(/^t=\\d+,v1=[a-f0-9]{64}$/);\n    });\n\n    it('should use provided timestamp', () => {\n      const timestamp = 1700000000000;\n      const signature = generateSignature(payload, secret, timestamp);\n      expect(signature).toContain(`t=${timestamp}`);\n    });\n\n    it('should generate consistent signatures for same inputs', () => {\n      const timestamp = 1700000000000;\n      const sig1 = generateSignature(payload, secret, timestamp);\n      const sig2 = generateSignature(payload, secret, timestamp);\n      expect(sig1).toBe(sig2);\n    });\n\n    it('should generate different signatures for different payloads', () => {\n      const timestamp = 1700000000000;\n      const sig1 = generateSignature(payload, secret, timestamp);\n      const sig2 = generateSignature('different payload', secret, timestamp);\n      expect(sig1).not.toBe(sig2);\n    });\n\n    it('should generate different signatures for different secrets', () => {\n      const timestamp = 1700000000000;\n      const sig1 = generateSignature(payload, secret, timestamp);\n      const sig2 = generateSignature(payload, 'different_secret', timestamp);\n      expect(sig1).not.toBe(sig2);\n    });\n  });\n\n  /**\n   * After a rotation Railhook signs each delivery with the new secret and the retired one\n   * for the endpoint's grace window, so a receiver that has not deployed the new secret yet\n   * keeps working. The parser used to keep only the last v1 and rejected whichever half of\n   * the pair the receiver was holding.\n   */\n  describe('a header carrying two signatures (secret rotation)', () => {\n    const newSecret = 'whsec_new';\n    const retiredSecret = 'whsec_retired';\n\n    const dualHeader = (body: string, at = Date.now()) => {\n      const retiredV1 = generateSignature(body, retiredSecret, at).split('v1=')[1];\n      return `${generateSignature(body, newSecret, at)},v1=${retiredV1}`;\n    };\n\n    it('verifies with the new secret', () => {\n      expect(verifySignature(payload, dualHeader(payload), newSecret)).toBe(true);\n    });\n\n    it('verifies with the retired secret', () => {\n      expect(verifySignature(payload, dualHeader(payload), retiredSecret)).toBe(true);\n    });\n\n    it('still rejects an unrelated secret', () => {\n      expect(() => verifySignature(payload, dualHeader(payload), 'whsec_someone_else'))\n        .toThrow(RailhookError);\n    });\n\n    it('still rejects a tampered body', () => {\n      expect(() => verifySignature(`${payload} `, dualHeader(payload), newSecret))\n        .toThrow(RailhookError);\n    });\n  });\n\n  describe('verifySignature', () => {\n    it('should verify valid signature', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      expect(verifySignature(payload, signature, secret)).toBe(true);\n    });\n\n    it('should throw on missing signature', () => {\n      expect(() => verifySignature(payload, '', secret)).toThrow(RailhookError);\n      expect(() => verifySignature(payload, '', secret)).toThrow('Missing signature header');\n    });\n\n    it('should throw on invalid signature format', () => {\n      expect(() => verifySignature(payload, 'invalid', secret)).toThrow('Invalid signature format');\n    });\n\n    it('should throw on missing timestamp', () => {\n      expect(() => verifySignature(payload, 'v1=abc123', secret)).toThrow('Invalid signature format');\n    });\n\n    it('should throw on missing v1 signature', () => {\n      expect(() => verifySignature(payload, 't=1700000000000', secret)).toThrow('Invalid signature format');\n    });\n\n    it('should throw on expired timestamp', () => {\n      const oldTimestamp = Date.now() - 600000; // 10 minutes ago\n      const signature = generateSignature(payload, secret, oldTimestamp);\n      expect(() => verifySignature(payload, signature, secret)).toThrow('outside tolerance window');\n    });\n\n    it('should throw on future timestamp outside tolerance', () => {\n      const futureTimestamp = Date.now() + 600000; // 10 minutes in future\n      const signature = generateSignature(payload, secret, futureTimestamp);\n      expect(() => verifySignature(payload, signature, secret)).toThrow('outside tolerance window');\n    });\n\n    it('should accept timestamp within tolerance', () => {\n      const recentTimestamp = Date.now() - 60000; // 1 minute ago\n      const signature = generateSignature(payload, secret, recentTimestamp);\n      expect(verifySignature(payload, signature, secret)).toBe(true);\n    });\n\n    it('should throw on invalid signature value', () => {\n      const timestamp = Date.now();\n      const signature = `t=${timestamp},v1=invalid_signature_that_will_not_match`;\n      expect(() => verifySignature(payload, signature, secret)).toThrow('Invalid signature');\n    });\n\n    it('should throw on tampered payload', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      const tamperedPayload = JSON.stringify({ type: 'order.cancelled', data: {} });\n      expect(() => verifySignature(tamperedPayload, signature, secret)).toThrow('Invalid signature');\n    });\n\n    it('should respect custom tolerance', () => {\n      const oldTimestamp = Date.now() - 60000; // 1 minute ago\n      const signature = generateSignature(payload, secret, oldTimestamp);\n      \n      // Should fail with 30s tolerance\n      expect(() => verifySignature(payload, signature, secret, { tolerance: 30000 }))\n        .toThrow('outside tolerance window');\n      \n      // Should pass with 2min tolerance\n      expect(verifySignature(payload, signature, secret, { tolerance: 120000 })).toBe(true);\n    });\n  });\n\n  describe('constructEvent', () => {\n    it('should construct event from valid request', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n        'x-timestamp': timestamp.toString(),\n        'x-event-id': 'evt_123',\n        'x-delivery-id': 'dlv_456',\n      };\n\n      const event = constructEvent(payload, headers, secret);\n      \n      expect(event.eventId).toBe('evt_123');\n      expect(event.deliveryId).toBe('dlv_456');\n      expect(event.timestamp).toBe(timestamp);\n      expect(event.type).toBe('order.completed');\n      expect(event.data).toEqual({ orderId: '12345' });\n    });\n\n    it('should handle uppercase headers', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      \n      const headers = {\n        'X-Signature': signature,\n        'X-Timestamp': timestamp.toString(),\n        'X-Event-Id': 'evt_123',\n        'X-Delivery-Id': 'dlv_456',\n      };\n\n      const event = constructEvent(payload, headers, secret);\n      expect(event.eventId).toBe('evt_123');\n    });\n\n    it('should throw on missing signature header', () => {\n      const headers = {\n        'x-timestamp': Date.now().toString(),\n      };\n\n      expect(() => constructEvent(payload, headers, secret))\n        .toThrow('Missing X-Signature header');\n    });\n\n    it('should throw on invalid JSON payload', () => {\n      const timestamp = Date.now();\n      const invalidPayload = 'not valid json';\n      const signature = generateSignature(invalidPayload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n        'x-timestamp': timestamp.toString(),\n      };\n\n      expect(() => constructEvent(invalidPayload, headers, secret))\n        .toThrow('Invalid JSON payload');\n    });\n\n    it('should handle payload without nested data field', () => {\n      const flatPayload = JSON.stringify({ type: 'test.event', value: 123 });\n      const timestamp = Date.now();\n      const signature = generateSignature(flatPayload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n        'x-timestamp': timestamp.toString(),\n      };\n\n      const event = constructEvent(flatPayload, headers, secret);\n      expect(event.type).toBe('test.event');\n      expect(event.data).toEqual({ type: 'test.event', value: 123 });\n    });\n\n    it('should use current timestamp if not provided in headers', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n      };\n\n      const event = constructEvent(payload, headers, secret);\n      expect(event.timestamp).toBeGreaterThan(0);\n    });\n  });\n});\n"]}

package/dist/client.d.ts

@@ -0,0 +1,103 @@
+import { RailhookConfig, Event, EventResponse, Endpoint, EndpointCreateParams, EndpointUpdateParams, EndpointListParams, Subscription, SubscriptionCreateParams, Delivery, DeliveryAttempt, DeliveryListParams, PaginatedResponse, EndpointTestResult, IncomingSource, IncomingSourceCreateParams, IncomingSourceUpdateParams, IncomingDestination, IncomingDestinationCreateParams, IncomingDestinationUpdateParams, IncomingEvent, IncomingEventListParams, IncomingForwardAttempt, ReplayEventResponse } from './types';
+export declare class Railhook {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    readonly events: Events;
+    readonly endpoints: Endpoints;
+    readonly subscriptions: Subscriptions;
+    readonly deliveries: Deliveries;
+    readonly incomingSources: IncomingSources;
+    readonly incomingEvents: IncomingEvents;
+    constructor(config: RailhookConfig);
+    request<T>(method: string, path: string, body?: unknown, idempotencyKey?: string): Promise<T>;
+    /**
+     * Generic GET request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    get<T = unknown>(path: string): Promise<T>;
+    /**
+     * Generic POST request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    post<T = unknown>(path: string, body?: unknown, idempotencyKey?: string): Promise<T>;
+    /**
+     * Generic PUT request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    put<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Generic PATCH request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    patch<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Generic DELETE request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    delete<T = void>(path: string): Promise<T>;
+    private extractRateLimitInfo;
+    private handleError;
+}
+declare class Events {
+    private client;
+    constructor(client: Railhook);
+    send(event: Event, idempotencyKey?: string): Promise<EventResponse>;
+}
+declare class Endpoints {
+    private client;
+    constructor(client: Railhook);
+    create(projectId: string, params: EndpointCreateParams): Promise<Endpoint>;
+    get(projectId: string, endpointId: string): Promise<Endpoint>;
+    /**
+     * Lists a project's endpoints.
+     *
+     * The API returns a Spring page envelope here, not a bare array — the
+     * endpoints themselves are in `.content`.
+     */
+    list(projectId: string, params?: EndpointListParams): Promise<PaginatedResponse<Endpoint>>;
+    update(projectId: string, endpointId: string, params: EndpointUpdateParams): Promise<Endpoint>;
+    delete(projectId: string, endpointId: string): Promise<void>;
+    rotateSecret(projectId: string, endpointId: string): Promise<Endpoint>;
+    test(projectId: string, endpointId: string): Promise<EndpointTestResult>;
+}
+declare class Subscriptions {
+    private client;
+    constructor(client: Railhook);
+    create(projectId: string, params: SubscriptionCreateParams): Promise<Subscription>;
+    get(projectId: string, subscriptionId: string): Promise<Subscription>;
+    list(projectId: string): Promise<Subscription[]>;
+    update(projectId: string, subscriptionId: string, params: Partial<SubscriptionCreateParams>): Promise<Subscription>;
+    delete(projectId: string, subscriptionId: string): Promise<void>;
+}
+declare class Deliveries {
+    private client;
+    constructor(client: Railhook);
+    get(deliveryId: string): Promise<Delivery>;
+    list(projectId: string, params?: DeliveryListParams): Promise<PaginatedResponse<Delivery>>;
+    getAttempts(deliveryId: string): Promise<DeliveryAttempt[]>;
+    replay(deliveryId: string): Promise<void>;
+}
+declare class IncomingSources {
+    private client;
+    constructor(client: Railhook);
+    create(projectId: string, params: IncomingSourceCreateParams): Promise<IncomingSource>;
+    get(projectId: string, sourceId: string): Promise<IncomingSource>;
+    list(projectId: string): Promise<PaginatedResponse<IncomingSource>>;
+    update(projectId: string, sourceId: string, params: IncomingSourceUpdateParams): Promise<IncomingSource>;
+    delete(projectId: string, sourceId: string): Promise<void>;
+    createDestination(projectId: string, sourceId: string, params: IncomingDestinationCreateParams): Promise<IncomingDestination>;
+    getDestination(projectId: string, sourceId: string, destinationId: string): Promise<IncomingDestination>;
+    listDestinations(projectId: string, sourceId: string): Promise<PaginatedResponse<IncomingDestination>>;
+    updateDestination(projectId: string, sourceId: string, destinationId: string, params: IncomingDestinationUpdateParams): Promise<IncomingDestination>;
+    deleteDestination(projectId: string, sourceId: string, destinationId: string): Promise<void>;
+}
+declare class IncomingEvents {
+    private client;
+    constructor(client: Railhook);
+    list(projectId: string, params?: IncomingEventListParams): Promise<PaginatedResponse<IncomingEvent>>;
+    get(projectId: string, eventId: string): Promise<IncomingEvent>;
+    getAttempts(projectId: string, eventId: string): Promise<PaginatedResponse<IncomingForwardAttempt>>;
+    replay(projectId: string, eventId: string): Promise<ReplayEventResponse>;
+}
+export {};