@railhook/node 2.12.0

package/dist/__tests__/incoming.test.js

@@ -0,0 +1,316 @@
+"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 });
+const client_1 = require("../client");
+const http = __importStar(require("http"));
+// Minimal mock HTTP server to verify request paths & methods
+let server;
+let lastRequest;
+let mockResponse = { status: 200, body: {} };
+const PORT = 19876;
+beforeAll((done) => {
+    server = http.createServer((req, res) => {
+        let body = '';
+        req.on('data', (chunk) => (body += chunk));
+        req.on('end', () => {
+            lastRequest = {
+                method: req.method || '',
+                url: req.url || '',
+                body,
+                headers: req.headers,
+            };
+            res.writeHead(mockResponse.status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(mockResponse.body));
+        });
+    });
+    server.listen(PORT, done);
+});
+afterAll((done) => {
+    server.close(done);
+});
+function setMockResponse(status, body) {
+    mockResponse = { status, body };
+}
+function createClient() {
+    return new client_1.Railhook({
+        apiKey: 'test_key',
+        baseUrl: `http://localhost:${PORT}`,
+    });
+}
+describe('IncomingSources', () => {
+    const client = createClient();
+    const projectId = 'proj-123';
+    const sourceId = 'src-456';
+    const sourceResponse = {
+        id: sourceId,
+        projectId,
+        name: 'Stripe Webhooks',
+        slug: 'stripe',
+        providerType: 'STRIPE',
+        status: 'ACTIVE',
+        ingressPathToken: 'tok_abc',
+        ingressUrl: `http://localhost:${PORT}/ingress/tok_abc`,
+        verificationMode: 'HMAC_GENERIC',
+        hmacHeaderName: 'Stripe-Signature',
+        hmacSecretConfigured: true,
+        createdAt: '2024-01-01T00:00:00Z',
+    };
+    describe('create', () => {
+        it('should POST to correct path with params', async () => {
+            setMockResponse(200, sourceResponse);
+            const result = await client.incomingSources.create(projectId, {
+                name: 'Stripe Webhooks',
+                slug: 'stripe',
+                providerType: 'STRIPE',
+                verificationMode: 'HMAC_GENERIC',
+                hmacSecret: 'whsec_test',
+                hmacHeaderName: 'Stripe-Signature',
+            });
+            expect(lastRequest.method).toBe('POST');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources`);
+            const body = JSON.parse(lastRequest.body);
+            expect(body.name).toBe('Stripe Webhooks');
+            expect(body.providerType).toBe('STRIPE');
+            expect(body.hmacSecret).toBe('whsec_test');
+            expect(result.id).toBe(sourceId);
+            expect(result.ingressUrl).toContain('tok_abc');
+        });
+    });
+    describe('get', () => {
+        it('should GET by source ID', async () => {
+            setMockResponse(200, sourceResponse);
+            const result = await client.incomingSources.get(projectId, sourceId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);
+            expect(result.name).toBe('Stripe Webhooks');
+        });
+    });
+    describe('list', () => {
+        it('should GET sources list', async () => {
+            setMockResponse(200, { content: [sourceResponse], totalElements: 1, totalPages: 1, size: 20, number: 0 });
+            const result = await client.incomingSources.list(projectId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources`);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].slug).toBe('stripe');
+        });
+    });
+    describe('update', () => {
+        it('should PUT with update params', async () => {
+            setMockResponse(200, { ...sourceResponse, name: 'Updated' });
+            const result = await client.incomingSources.update(projectId, sourceId, {
+                name: 'Updated',
+                status: 'DISABLED',
+            });
+            expect(lastRequest.method).toBe('PUT');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);
+            const body = JSON.parse(lastRequest.body);
+            expect(body.name).toBe('Updated');
+            expect(body.status).toBe('DISABLED');
+            expect(result.name).toBe('Updated');
+        });
+    });
+    describe('delete', () => {
+        it('should DELETE by source ID', async () => {
+            setMockResponse(204, '');
+            await client.incomingSources.delete(projectId, sourceId);
+            expect(lastRequest.method).toBe('DELETE');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);
+        });
+    });
+    // ── Destinations ──
+    const destId = 'dest-789';
+    const destResponse = {
+        id: destId,
+        incomingSourceId: sourceId,
+        url: 'https://api.example.com/webhooks/stripe',
+        authType: 'NONE',
+        authConfigured: false,
+        enabled: true,
+        maxAttempts: 5,
+        timeoutSeconds: 30,
+        createdAt: '2024-01-01T00:00:00Z',
+    };
+    describe('createDestination', () => {
+        it('should POST to destinations path', async () => {
+            setMockResponse(200, destResponse);
+            const result = await client.incomingSources.createDestination(projectId, sourceId, {
+                url: 'https://api.example.com/webhooks/stripe',
+                enabled: true,
+                maxAttempts: 5,
+            });
+            expect(lastRequest.method).toBe('POST');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`);
+            const body = JSON.parse(lastRequest.body);
+            expect(body.url).toBe('https://api.example.com/webhooks/stripe');
+            expect(result.id).toBe(destId);
+        });
+    });
+    describe('getDestination', () => {
+        it('should GET destination by ID', async () => {
+            setMockResponse(200, destResponse);
+            const result = await client.incomingSources.getDestination(projectId, sourceId, destId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destId}`);
+            expect(result.url).toBe('https://api.example.com/webhooks/stripe');
+        });
+    });
+    describe('listDestinations', () => {
+        it('should GET destinations list', async () => {
+            setMockResponse(200, { content: [destResponse], totalElements: 1, totalPages: 1, size: 20, number: 0 });
+            const result = await client.incomingSources.listDestinations(projectId, sourceId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`);
+            expect(result.content).toHaveLength(1);
+        });
+    });
+    describe('updateDestination', () => {
+        it('should PUT with update params', async () => {
+            setMockResponse(200, { ...destResponse, enabled: false });
+            const result = await client.incomingSources.updateDestination(projectId, sourceId, destId, {
+                enabled: false,
+            });
+            expect(lastRequest.method).toBe('PUT');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destId}`);
+            expect(result.enabled).toBe(false);
+        });
+    });
+    describe('deleteDestination', () => {
+        it('should DELETE destination', async () => {
+            setMockResponse(204, '');
+            await client.incomingSources.deleteDestination(projectId, sourceId, destId);
+            expect(lastRequest.method).toBe('DELETE');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destId}`);
+        });
+    });
+});
+describe('IncomingEvents', () => {
+    const client = createClient();
+    const projectId = 'proj-123';
+    const eventId = 'evt-abc';
+    const eventResponse = {
+        id: eventId,
+        incomingSourceId: 'src-456',
+        sourceName: 'Stripe Webhooks',
+        requestId: 'req-xyz',
+        method: 'POST',
+        path: '/ingress/tok_abc',
+        bodyRaw: '{"type":"checkout.session.completed"}',
+        contentType: 'application/json',
+        verified: true,
+        receivedAt: '2024-01-01T00:00:00Z',
+    };
+    describe('list', () => {
+        it('should GET events without params', async () => {
+            setMockResponse(200, { content: [eventResponse], totalElements: 1, totalPages: 1, size: 20, number: 0 });
+            const result = await client.incomingEvents.list(projectId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events`);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].requestId).toBe('req-xyz');
+        });
+        it('should pass sourceId filter as query param', async () => {
+            setMockResponse(200, { content: [], totalElements: 0, totalPages: 0, size: 20, number: 0 });
+            await client.incomingEvents.list(projectId, { sourceId: 'src-456' });
+            expect(lastRequest.url).toContain('sourceId=src-456');
+        });
+        it('should pass pagination params', async () => {
+            setMockResponse(200, { content: [], totalElements: 0, totalPages: 0, size: 10, number: 2 });
+            await client.incomingEvents.list(projectId, { page: 2, size: 10 });
+            expect(lastRequest.url).toContain('page=2');
+            expect(lastRequest.url).toContain('size=10');
+        });
+    });
+    describe('get', () => {
+        it('should GET event by ID', async () => {
+            setMockResponse(200, eventResponse);
+            const result = await client.incomingEvents.get(projectId, eventId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events/${eventId}`);
+            expect(result.verified).toBe(true);
+            expect(result.method).toBe('POST');
+        });
+    });
+    describe('getAttempts', () => {
+        it('should GET forward attempts', async () => {
+            const attemptResponse = {
+                content: [{
+                        id: 'att-1',
+                        incomingEventId: eventId,
+                        destinationId: 'dest-789',
+                        destinationUrl: 'https://api.example.com/webhooks/stripe',
+                        attemptNumber: 1,
+                        status: 'SUCCESS',
+                        startedAt: '2024-01-01T00:00:00Z',
+                        finishedAt: '2024-01-01T00:00:01Z',
+                        responseCode: 200,
+                        responseBodySnippet: 'OK',
+                        createdAt: '2024-01-01T00:00:00Z',
+                    }],
+                totalElements: 1,
+                totalPages: 1,
+                size: 20,
+                number: 0,
+            };
+            setMockResponse(200, attemptResponse);
+            const result = await client.incomingEvents.getAttempts(projectId, eventId);
+            expect(lastRequest.method).toBe('GET');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events/${eventId}/attempts`);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].responseCode).toBe(200);
+            expect(result.content[0].status).toBe('SUCCESS');
+            expect(result.content[0].attemptNumber).toBe(1);
+            expect(result.content[0].destinationUrl).toBe('https://api.example.com/webhooks/stripe');
+        });
+    });
+    describe('replay', () => {
+        it('should POST replay', async () => {
+            setMockResponse(200, { status: 'replayed', eventId, destinationsCount: 2 });
+            const result = await client.incomingEvents.replay(projectId, eventId);
+            expect(lastRequest.method).toBe('POST');
+            expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events/${eventId}/replay`);
+            expect(result.status).toBe('replayed');
+            expect(result.destinationsCount).toBe(2);
+        });
+    });
+});
+describe('Client initialization includes incoming modules', () => {
+    it('should have incomingSources and incomingEvents', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_key' });
+        expect(client.incomingSources).toBeDefined();
+        expect(client.incomingEvents).toBeDefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"incoming.test.js","sourceRoot":"","sources":["../../src/__tests__/incoming.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Railhook } from '../client';\nimport * as http from 'http';\n\n// Minimal mock HTTP server to verify request paths & methods\nlet server: http.Server;\nlet lastRequest: { method: string; url: string; body: string; headers: http.IncomingHttpHeaders };\nlet mockResponse: { status: number; body: unknown } = { status: 200, body: {} };\n\nconst PORT = 19876;\n\nbeforeAll((done) => {\n  server = http.createServer((req, res) => {\n    let body = '';\n    req.on('data', (chunk) => (body += chunk));\n    req.on('end', () => {\n      lastRequest = {\n        method: req.method || '',\n        url: req.url || '',\n        body,\n        headers: req.headers,\n      };\n      res.writeHead(mockResponse.status, { 'Content-Type': 'application/json' });\n      res.end(JSON.stringify(mockResponse.body));\n    });\n  });\n  server.listen(PORT, done);\n});\n\nafterAll((done) => {\n  server.close(done);\n});\n\nfunction setMockResponse(status: number, body: unknown) {\n  mockResponse = { status, body };\n}\n\nfunction createClient(): Railhook {\n  return new Railhook({\n    apiKey: 'test_key',\n    baseUrl: `http://localhost:${PORT}`,\n  });\n}\n\ndescribe('IncomingSources', () => {\n  const client = createClient();\n  const projectId = 'proj-123';\n  const sourceId = 'src-456';\n\n  const sourceResponse = {\n    id: sourceId,\n    projectId,\n    name: 'Stripe Webhooks',\n    slug: 'stripe',\n    providerType: 'STRIPE',\n    status: 'ACTIVE',\n    ingressPathToken: 'tok_abc',\n    ingressUrl: `http://localhost:${PORT}/ingress/tok_abc`,\n    verificationMode: 'HMAC_GENERIC',\n    hmacHeaderName: 'Stripe-Signature',\n    hmacSecretConfigured: true,\n    createdAt: '2024-01-01T00:00:00Z',\n  };\n\n  describe('create', () => {\n    it('should POST to correct path with params', async () => {\n      setMockResponse(200, sourceResponse);\n\n      const result = await client.incomingSources.create(projectId, {\n        name: 'Stripe Webhooks',\n        slug: 'stripe',\n        providerType: 'STRIPE',\n        verificationMode: 'HMAC_GENERIC',\n        hmacSecret: 'whsec_test',\n        hmacHeaderName: 'Stripe-Signature',\n      });\n\n      expect(lastRequest.method).toBe('POST');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources`);\n      const body = JSON.parse(lastRequest.body);\n      expect(body.name).toBe('Stripe Webhooks');\n      expect(body.providerType).toBe('STRIPE');\n      expect(body.hmacSecret).toBe('whsec_test');\n      expect(result.id).toBe(sourceId);\n      expect(result.ingressUrl).toContain('tok_abc');\n    });\n  });\n\n  describe('get', () => {\n    it('should GET by source ID', async () => {\n      setMockResponse(200, sourceResponse);\n\n      const result = await client.incomingSources.get(projectId, sourceId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);\n      expect(result.name).toBe('Stripe Webhooks');\n    });\n  });\n\n  describe('list', () => {\n    it('should GET sources list', async () => {\n      setMockResponse(200, { content: [sourceResponse], totalElements: 1, totalPages: 1, size: 20, number: 0 });\n\n      const result = await client.incomingSources.list(projectId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources`);\n      expect(result.content).toHaveLength(1);\n      expect(result.content[0].slug).toBe('stripe');\n    });\n  });\n\n  describe('update', () => {\n    it('should PUT with update params', async () => {\n      setMockResponse(200, { ...sourceResponse, name: 'Updated' });\n\n      const result = await client.incomingSources.update(projectId, sourceId, {\n        name: 'Updated',\n        status: 'DISABLED',\n      });\n\n      expect(lastRequest.method).toBe('PUT');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);\n      const body = JSON.parse(lastRequest.body);\n      expect(body.name).toBe('Updated');\n      expect(body.status).toBe('DISABLED');\n      expect(result.name).toBe('Updated');\n    });\n  });\n\n  describe('delete', () => {\n    it('should DELETE by source ID', async () => {\n      setMockResponse(204, '');\n\n      await client.incomingSources.delete(projectId, sourceId);\n\n      expect(lastRequest.method).toBe('DELETE');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);\n    });\n  });\n\n  // ── Destinations ──\n\n  const destId = 'dest-789';\n  const destResponse = {\n    id: destId,\n    incomingSourceId: sourceId,\n    url: 'https://api.example.com/webhooks/stripe',\n    authType: 'NONE',\n    authConfigured: false,\n    enabled: true,\n    maxAttempts: 5,\n    timeoutSeconds: 30,\n    createdAt: '2024-01-01T00:00:00Z',\n  };\n\n  describe('createDestination', () => {\n    it('should POST to destinations path', async () => {\n      setMockResponse(200, destResponse);\n\n      const result = await client.incomingSources.createDestination(projectId, sourceId, {\n        url: 'https://api.example.com/webhooks/stripe',\n        enabled: true,\n        maxAttempts: 5,\n      });\n\n      expect(lastRequest.method).toBe('POST');\n      expect(lastRequest.url).toBe(\n        `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`\n      );\n      const body = JSON.parse(lastRequest.body);\n      expect(body.url).toBe('https://api.example.com/webhooks/stripe');\n      expect(result.id).toBe(destId);\n    });\n  });\n\n  describe('getDestination', () => {\n    it('should GET destination by ID', async () => {\n      setMockResponse(200, destResponse);\n\n      const result = await client.incomingSources.getDestination(projectId, sourceId, destId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(\n        `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destId}`\n      );\n      expect(result.url).toBe('https://api.example.com/webhooks/stripe');\n    });\n  });\n\n  describe('listDestinations', () => {\n    it('should GET destinations list', async () => {\n      setMockResponse(200, { content: [destResponse], totalElements: 1, totalPages: 1, size: 20, number: 0 });\n\n      const result = await client.incomingSources.listDestinations(projectId, sourceId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(\n        `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`\n      );\n      expect(result.content).toHaveLength(1);\n    });\n  });\n\n  describe('updateDestination', () => {\n    it('should PUT with update params', async () => {\n      setMockResponse(200, { ...destResponse, enabled: false });\n\n      const result = await client.incomingSources.updateDestination(projectId, sourceId, destId, {\n        enabled: false,\n      });\n\n      expect(lastRequest.method).toBe('PUT');\n      expect(lastRequest.url).toBe(\n        `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destId}`\n      );\n      expect(result.enabled).toBe(false);\n    });\n  });\n\n  describe('deleteDestination', () => {\n    it('should DELETE destination', async () => {\n      setMockResponse(204, '');\n\n      await client.incomingSources.deleteDestination(projectId, sourceId, destId);\n\n      expect(lastRequest.method).toBe('DELETE');\n      expect(lastRequest.url).toBe(\n        `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destId}`\n      );\n    });\n  });\n});\n\ndescribe('IncomingEvents', () => {\n  const client = createClient();\n  const projectId = 'proj-123';\n  const eventId = 'evt-abc';\n\n  const eventResponse = {\n    id: eventId,\n    incomingSourceId: 'src-456',\n    sourceName: 'Stripe Webhooks',\n    requestId: 'req-xyz',\n    method: 'POST',\n    path: '/ingress/tok_abc',\n    bodyRaw: '{\"type\":\"checkout.session.completed\"}',\n    contentType: 'application/json',\n    verified: true,\n    receivedAt: '2024-01-01T00:00:00Z',\n  };\n\n  describe('list', () => {\n    it('should GET events without params', async () => {\n      setMockResponse(200, { content: [eventResponse], totalElements: 1, totalPages: 1, size: 20, number: 0 });\n\n      const result = await client.incomingEvents.list(projectId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events`);\n      expect(result.content).toHaveLength(1);\n      expect(result.content[0].requestId).toBe('req-xyz');\n    });\n\n    it('should pass sourceId filter as query param', async () => {\n      setMockResponse(200, { content: [], totalElements: 0, totalPages: 0, size: 20, number: 0 });\n\n      await client.incomingEvents.list(projectId, { sourceId: 'src-456' });\n\n      expect(lastRequest.url).toContain('sourceId=src-456');\n    });\n\n    it('should pass pagination params', async () => {\n      setMockResponse(200, { content: [], totalElements: 0, totalPages: 0, size: 10, number: 2 });\n\n      await client.incomingEvents.list(projectId, { page: 2, size: 10 });\n\n      expect(lastRequest.url).toContain('page=2');\n      expect(lastRequest.url).toContain('size=10');\n    });\n  });\n\n  describe('get', () => {\n    it('should GET event by ID', async () => {\n      setMockResponse(200, eventResponse);\n\n      const result = await client.incomingEvents.get(projectId, eventId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events/${eventId}`);\n      expect(result.verified).toBe(true);\n      expect(result.method).toBe('POST');\n    });\n  });\n\n  describe('getAttempts', () => {\n    it('should GET forward attempts', async () => {\n      const attemptResponse = {\n        content: [{\n          id: 'att-1',\n          incomingEventId: eventId,\n          destinationId: 'dest-789',\n          destinationUrl: 'https://api.example.com/webhooks/stripe',\n          attemptNumber: 1,\n          status: 'SUCCESS',\n          startedAt: '2024-01-01T00:00:00Z',\n          finishedAt: '2024-01-01T00:00:01Z',\n          responseCode: 200,\n          responseBodySnippet: 'OK',\n          createdAt: '2024-01-01T00:00:00Z',\n        }],\n        totalElements: 1,\n        totalPages: 1,\n        size: 20,\n        number: 0,\n      };\n      setMockResponse(200, attemptResponse);\n\n      const result = await client.incomingEvents.getAttempts(projectId, eventId);\n\n      expect(lastRequest.method).toBe('GET');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events/${eventId}/attempts`);\n      expect(result.content).toHaveLength(1);\n      expect(result.content[0].responseCode).toBe(200);\n      expect(result.content[0].status).toBe('SUCCESS');\n      expect(result.content[0].attemptNumber).toBe(1);\n      expect(result.content[0].destinationUrl).toBe('https://api.example.com/webhooks/stripe');\n    });\n  });\n\n  describe('replay', () => {\n    it('should POST replay', async () => {\n      setMockResponse(200, { status: 'replayed', eventId, destinationsCount: 2 });\n\n      const result = await client.incomingEvents.replay(projectId, eventId);\n\n      expect(lastRequest.method).toBe('POST');\n      expect(lastRequest.url).toBe(`/api/v1/projects/${projectId}/incoming-events/${eventId}/replay`);\n      expect(result.status).toBe('replayed');\n      expect(result.destinationsCount).toBe(2);\n    });\n  });\n});\n\ndescribe('Client initialization includes incoming modules', () => {\n  it('should have incomingSources and incomingEvents', () => {\n    const client = new Railhook({ apiKey: 'test_key' });\n    expect(client.incomingSources).toBeDefined();\n    expect(client.incomingEvents).toBeDefined();\n  });\n});\n"]}

package/dist/__tests__/package-identity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/package-identity.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("@railhook/node");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../../package.json');
+// Guards the published identity of this SDK: the manifest name and the export
+// surface a consumer gets from `npm install @railhook/node` must not
+// drift apart.
+describe('package identity (@railhook/node)', () => {
+    it('is published under the @railhook/node package name', () => {
+        expect(pkg.name).toBe('@railhook/node');
+    });
+    it('smoke: importing "@railhook/node" constructs a working client', () => {
+        const client = new node_1.Railhook({ apiKey: 'test_api_key' });
+        expect(client).toBeInstanceOf(node_1.Railhook);
+        expect(client.events).toBeDefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZS1pZGVudGl0eS50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL19fdGVzdHNfXy9wYWNrYWdlLWlkZW50aXR5LnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBMEM7QUFDMUMsOERBQThEO0FBQzlELE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO0FBRTFDLDhFQUE4RTtBQUM5RSxxRUFBcUU7QUFDckUsZUFBZTtBQUNmLFFBQVEsQ0FBQyxtQ0FBbUMsRUFBRSxHQUFHLEVBQUU7SUFDakQsRUFBRSxDQUFDLG9EQUFvRCxFQUFFLEdBQUcsRUFBRTtRQUM1RCxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQzFDLENBQUMsQ0FBQyxDQUFDO0lBRUgsRUFBRSxDQUFDLCtEQUErRCxFQUFFLEdBQUcsRUFBRTtRQUN2RSxNQUFNLE1BQU0sR0FBRyxJQUFJLGVBQVEsQ0FBQyxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQUUsQ0FBQyxDQUFDO1FBQ3hELE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxjQUFjLENBQUMsZUFBUSxDQUFDLENBQUM7UUFDeEMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUN0QyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmFpbGhvb2sgfSBmcm9tICdAcmFpbGhvb2svbm9kZSc7XG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXZhci1yZXF1aXJlc1xuY29uc3QgcGtnID0gcmVxdWlyZSgnLi4vLi4vcGFja2FnZS5qc29uJyk7XG5cbi8vIEd1YXJkcyB0aGUgcHVibGlzaGVkIGlkZW50aXR5IG9mIHRoaXMgU0RLOiB0aGUgbWFuaWZlc3QgbmFtZSBhbmQgdGhlIGV4cG9ydFxuLy8gc3VyZmFjZSBhIGNvbnN1bWVyIGdldHMgZnJvbSBgbnBtIGluc3RhbGwgQHJhaWxob29rL25vZGVgIG11c3Qgbm90XG4vLyBkcmlmdCBhcGFydC5cbmRlc2NyaWJlKCdwYWNrYWdlIGlkZW50aXR5IChAcmFpbGhvb2svbm9kZSknLCAoKSA9PiB7XG4gIGl0KCdpcyBwdWJsaXNoZWQgdW5kZXIgdGhlIEByYWlsaG9vay9ub2RlIHBhY2thZ2UgbmFtZScsICgpID0+IHtcbiAgICBleHBlY3QocGtnLm5hbWUpLnRvQmUoJ0ByYWlsaG9vay9ub2RlJyk7XG4gIH0pO1xuXG4gIGl0KCdzbW9rZTogaW1wb3J0aW5nIFwiQHJhaWxob29rL25vZGVcIiBjb25zdHJ1Y3RzIGEgd29ya2luZyBjbGllbnQnLCAoKSA9PiB7XG4gICAgY29uc3QgY2xpZW50ID0gbmV3IFJhaWxob29rKHsgYXBpS2V5OiAndGVzdF9hcGlfa2V5JyB9KTtcbiAgICBleHBlY3QoY2xpZW50KS50b0JlSW5zdGFuY2VPZihSYWlsaG9vayk7XG4gICAgZXhwZWN0KGNsaWVudC5ldmVudHMpLnRvQmVEZWZpbmVkKCk7XG4gIH0pO1xufSk7XG4iXX0=

package/dist/__tests__/standardWebhooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/standardWebhooks.test.js

@@ -0,0 +1,102 @@
+"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 });
+const webhooks_1 = require("../webhooks");
+const errors_1 = require("../errors");
+const crypto = __importStar(require("crypto"));
+/**
+ * The point of this scheme is that a receiver can verify with a library they already have,
+ * so the first test is the reference algorithm rather than a round-trip against ourselves —
+ * a round-trip would only prove we agree with our own bug.
+ */
+describe('verifyStandardWebhook', () => {
+    const id = 'msg_p5jXN8AQM9LWM0D4loKWxJek';
+    const payload = '{"test": 2432232314}';
+    const secretB64 = 'MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw';
+    const sharedSecret = `whsec_${secretB64}`;
+    /** Exactly what the reference libraries do: hmac(b64decode(secret), `${id}.${ts}.${body}`). */
+    const sign = (ts, secret = secretB64) => crypto
+        .createHmac('sha256', Buffer.from(secret, 'base64'))
+        .update(`${id}.${ts}.${payload}`)
+        .digest('base64');
+    const headers = (ts, signature) => ({
+        'webhook-id': id,
+        'webhook-timestamp': String(ts),
+        'webhook-signature': signature,
+    });
+    it('accepts a signature produced the way the reference libraries produce one', () => {
+        const ts = Math.floor(Date.now() / 1000);
+        expect((0, webhooks_1.verifyStandardWebhook)(payload, headers(ts, `v1,${sign(ts)}`), sharedSecret)).toBe(true);
+    });
+    it('accepts either signature during a secret rotation', () => {
+        const ts = Math.floor(Date.now() / 1000);
+        const retired = 'b2xkLXNlY3JldC1ieXRlcy1oZXJlLXBhZGRpbmc=';
+        // What Railhook sends through the grace window: one signature per valid secret.
+        const header = `v1,${sign(ts)} v1,${sign(ts, retired)}`;
+        expect((0, webhooks_1.verifyStandardWebhook)(payload, headers(ts, header), sharedSecret)).toBe(true);
+        expect((0, webhooks_1.verifyStandardWebhook)(payload, headers(ts, header), `whsec_${retired}`)).toBe(true);
+    });
+    it('rejects a replayed request even though its signature is still valid', () => {
+        // A signature over a fixed body never expires by itself, so without the timestamp check
+        // a captured request stays replayable for as long as the secret lives.
+        const old = Math.floor(Date.now() / 1000) - 3600;
+        expect(() => (0, webhooks_1.verifyStandardWebhook)(payload, headers(old, `v1,${sign(old)}`), sharedSecret))
+            .toThrow(errors_1.RailhookError);
+    });
+    it('rejects a signature lifted from a different message', () => {
+        const ts = Math.floor(Date.now() / 1000);
+        const forAnotherMessage = crypto
+            .createHmac('sha256', Buffer.from(secretB64, 'base64'))
+            .update(`msg_somethingelse.${ts}.${payload}`)
+            .digest('base64');
+        expect(() => (0, webhooks_1.verifyStandardWebhook)(payload, headers(ts, `v1,${forAnotherMessage}`), sharedSecret)).toThrow(errors_1.RailhookError);
+    });
+    it('rejects a tampered body', () => {
+        const ts = Math.floor(Date.now() / 1000);
+        expect(() => (0, webhooks_1.verifyStandardWebhook)('{"test": 1}', headers(ts, `v1,${sign(ts)}`), sharedSecret)).toThrow(errors_1.RailhookError);
+    });
+    it('reports missing headers rather than treating them as unsigned', () => {
+        const ts = Math.floor(Date.now() / 1000);
+        expect(() => (0, webhooks_1.verifyStandardWebhook)(payload, { 'webhook-id': id }, sharedSecret))
+            .toThrow(errors_1.RailhookError);
+        expect(() => (0, webhooks_1.verifyStandardWebhook)(payload, { ...headers(ts, `v1,${sign(ts)}`), 'webhook-id': undefined }, sharedSecret)).toThrow(errors_1.RailhookError);
+    });
+    it('ignores signature entries of an unknown version', () => {
+        const ts = Math.floor(Date.now() / 1000);
+        expect(() => (0, webhooks_1.verifyStandardWebhook)(payload, headers(ts, `v2,${sign(ts)}`), sharedSecret))
+            .toThrow(errors_1.RailhookError);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standardWebhooks.test.js","sourceRoot":"","sources":["../../src/__tests__/standardWebhooks.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { verifyStandardWebhook } from '../webhooks';\nimport { RailhookError } from '../errors';\nimport * as crypto from 'crypto';\n\n/**\n * The point of this scheme is that a receiver can verify with a library they already have,\n * so the first test is the reference algorithm rather than a round-trip against ourselves —\n * a round-trip would only prove we agree with our own bug.\n */\ndescribe('verifyStandardWebhook', () => {\n  const id = 'msg_p5jXN8AQM9LWM0D4loKWxJek';\n  const payload = '{\"test\": 2432232314}';\n  const secretB64 = 'MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw';\n  const sharedSecret = `whsec_${secretB64}`;\n\n  /** Exactly what the reference libraries do: hmac(b64decode(secret), `${id}.${ts}.${body}`). */\n  const sign = (ts: number, secret = secretB64) =>\n    crypto\n      .createHmac('sha256', Buffer.from(secret, 'base64'))\n      .update(`${id}.${ts}.${payload}`)\n      .digest('base64');\n\n  const headers = (ts: number, signature: string) => ({\n    'webhook-id': id,\n    'webhook-timestamp': String(ts),\n    'webhook-signature': signature,\n  });\n\n  it('accepts a signature produced the way the reference libraries produce one', () => {\n    const ts = Math.floor(Date.now() / 1000);\n    expect(verifyStandardWebhook(payload, headers(ts, `v1,${sign(ts)}`), sharedSecret)).toBe(true);\n  });\n\n  it('accepts either signature during a secret rotation', () => {\n    const ts = Math.floor(Date.now() / 1000);\n    const retired = 'b2xkLXNlY3JldC1ieXRlcy1oZXJlLXBhZGRpbmc=';\n    // What Railhook sends through the grace window: one signature per valid secret.\n    const header = `v1,${sign(ts)} v1,${sign(ts, retired)}`;\n\n    expect(verifyStandardWebhook(payload, headers(ts, header), sharedSecret)).toBe(true);\n    expect(verifyStandardWebhook(payload, headers(ts, header), `whsec_${retired}`)).toBe(true);\n  });\n\n  it('rejects a replayed request even though its signature is still valid', () => {\n    // A signature over a fixed body never expires by itself, so without the timestamp check\n    // a captured request stays replayable for as long as the secret lives.\n    const old = Math.floor(Date.now() / 1000) - 3600;\n    expect(() => verifyStandardWebhook(payload, headers(old, `v1,${sign(old)}`), sharedSecret))\n      .toThrow(RailhookError);\n  });\n\n  it('rejects a signature lifted from a different message', () => {\n    const ts = Math.floor(Date.now() / 1000);\n    const forAnotherMessage = crypto\n      .createHmac('sha256', Buffer.from(secretB64, 'base64'))\n      .update(`msg_somethingelse.${ts}.${payload}`)\n      .digest('base64');\n\n    expect(() =>\n      verifyStandardWebhook(payload, headers(ts, `v1,${forAnotherMessage}`), sharedSecret)\n    ).toThrow(RailhookError);\n  });\n\n  it('rejects a tampered body', () => {\n    const ts = Math.floor(Date.now() / 1000);\n    expect(() =>\n      verifyStandardWebhook('{\"test\": 1}', headers(ts, `v1,${sign(ts)}`), sharedSecret)\n    ).toThrow(RailhookError);\n  });\n\n  it('reports missing headers rather than treating them as unsigned', () => {\n    const ts = Math.floor(Date.now() / 1000);\n    expect(() => verifyStandardWebhook(payload, { 'webhook-id': id }, sharedSecret))\n      .toThrow(RailhookError);\n    expect(() =>\n      verifyStandardWebhook(payload, { ...headers(ts, `v1,${sign(ts)}`), 'webhook-id': undefined }, sharedSecret)\n    ).toThrow(RailhookError);\n  });\n\n  it('ignores signature entries of an unknown version', () => {\n    const ts = Math.floor(Date.now() / 1000);\n    expect(() => verifyStandardWebhook(payload, headers(ts, `v2,${sign(ts)}`), sharedSecret))\n      .toThrow(RailhookError);\n  });\n});\n"]}

package/dist/__tests__/webhooks.test.d.ts

@@ -0,0 +1 @@
+export {};