@railhook/node 2.12.0

package/README.md

@@ -0,0 +1,476 @@
+# @railhook/node
+
+Official Node.js SDK for [Railhook](https://github.com/vadymkykalo/railhook).
+
+**Zero runtime dependencies.** This SDK talks to the API using Node's built-in
+`node:https` module — no third-party HTTP client, no transitive dependency
+tree to audit. `npm ls --prod` on this package prints nothing.
+
+## Scope
+
+This SDK covers the **send + verify** surface of the API: Events, Endpoints,
+Subscriptions, Deliveries, Incoming Sources, Incoming Events, and webhook
+signature verification — 7 of the platform's 35 API controllers. It
+does **not** wrap Transformations, Rules, Workflows, Schemas, DLQ, Analytics,
+Usage, Alerts, Incidents, PII rules, Audit Log, Tunnels, API keys, Members,
+or Projects. Those are dashboard/API-only today; use the [Generic
+Requests](#generic-requests) escape hatch below to call them directly if you
+need them before the SDK grows to cover them.
+
+## Installation
+
+```bash
+npm install @railhook/node
+```
+
+## Quick Start
+
+```typescript
+import { Railhook } from '@railhook/node';
+
+const client = new Railhook({
+  apiKey: process.env.RAILHOOK_API_KEY, // e.g. 'Kz1uAIM8VeJUQN7yGSYCst64WxNLabBHfOYbrPlJ1yk'
+  baseUrl: 'http://localhost:8080', // optional, defaults to localhost
+});
+
+// Send an event
+const event = await client.events.send({
+  type: 'order.completed',
+  data: {
+    orderId: 'ord_12345',
+    amount: 99.99,
+    currency: 'USD',
+  },
+});
+
+console.log(`Event created: ${event.eventId}`);
+console.log(`Deliveries created: ${event.deliveriesCreated}`);
+```
+
+## API Reference
+
+### Events
+
+```typescript
+// Send event with idempotency key
+const event = await client.events.send(
+  { type: 'order.completed', data: { orderId: '123' } },
+  'unique-idempotency-key'
+);
+```
+
+### Endpoints
+
+```typescript
+// Create endpoint
+const endpoint = await client.endpoints.create(projectId, {
+  url: 'https://api.example.com/webhooks',
+  description: 'Production webhooks',
+  enabled: true,
+});
+
+// List endpoints — the API paginates this one, so the endpoints are in .content
+const page = await client.endpoints.list(projectId, { page: 0, size: 20 });
+for (const endpoint of page.content) {
+  console.log(endpoint.url);
+}
+
+// Update endpoint
+await client.endpoints.update(projectId, endpointId, {
+  enabled: false,
+});
+
+// Delete endpoint
+await client.endpoints.delete(projectId, endpointId);
+
+// Rotate secret
+const updated = await client.endpoints.rotateSecret(projectId, endpointId);
+console.log(`New secret: ${updated.secret}`);
+
+// Test endpoint connectivity
+const result = await client.endpoints.test(projectId, endpointId);
+console.log(`Test ${result.success ? 'passed' : 'failed'}: ${result.latencyMs}ms`);
+console.log(`${result.httpStatusCode} — ${result.message}`);
+```
+
+### Subscriptions
+
+```typescript
+// Subscribe endpoint to an event type
+const subscription = await client.subscriptions.create(projectId, {
+  endpointId: endpoint.id,
+  eventType: 'order.completed',
+  enabled: true,
+});
+
+// List subscriptions — a bare array; unlike endpoints, this one is not paginated
+const subscriptions = await client.subscriptions.list(projectId);
+
+// Update subscription
+await client.subscriptions.update(projectId, subscriptionId, {
+  eventType: 'order.shipped',
+  enabled: true,
+});
+
+// Delete subscription
+await client.subscriptions.delete(projectId, subscriptionId);
+```
+
+### Deliveries
+
+```typescript
+// List deliveries with filters
+const deliveries = await client.deliveries.list(projectId, {
+  status: 'FAILED',
+  page: 0,
+  size: 20,
+});
+
+console.log(`Total failed: ${deliveries.totalElements}`);
+
+// Get delivery attempts
+const attempts = await client.deliveries.getAttempts(deliveryId);
+for (const attempt of attempts) {
+  console.log(`Attempt ${attempt.attemptNumber}: ${attempt.httpStatusCode} (${attempt.durationMs}ms)`);
+}
+
+// Replay failed delivery
+await client.deliveries.replay(deliveryId);
+```
+
+## Incoming Webhooks
+
+Receive, validate, and forward webhooks from third-party providers (Stripe, GitHub, Twilio, etc.).
+
+### Incoming Sources
+
+```typescript
+// Create an incoming source with HMAC verification
+const source = await client.incomingSources.create(projectId, {
+  name: 'Stripe Webhooks',
+  slug: 'stripe',
+  providerType: 'STRIPE',
+  verificationMode: 'HMAC_GENERIC',
+  hmacSecret: 'whsec_...',
+  hmacHeaderName: 'Stripe-Signature',
+});
+
+console.log(`Ingress URL: ${source.ingressUrl}`);
+
+// List sources
+const sources = await client.incomingSources.list(projectId);
+
+// Update source
+await client.incomingSources.update(projectId, sourceId, {
+  name: 'Stripe Production',
+  rateLimitPerSecond: 100,
+});
+
+// Delete source
+await client.incomingSources.delete(projectId, sourceId);
+```
+
+### Incoming Destinations
+
+```typescript
+// Add a forwarding destination
+const dest = await client.incomingSources.createDestination(projectId, sourceId, {
+  url: 'https://your-api.com/webhooks/stripe',
+  enabled: true,
+  maxAttempts: 5,
+  timeoutSeconds: 30,
+});
+
+// List destinations
+const dests = await client.incomingSources.listDestinations(projectId, sourceId);
+
+// Update destination
+await client.incomingSources.updateDestination(projectId, sourceId, destId, {
+  enabled: false,
+});
+
+// Delete destination
+await client.incomingSources.deleteDestination(projectId, sourceId, destId);
+```
+
+### Incoming Events
+
+```typescript
+// List incoming events (with optional source filter)
+const events = await client.incomingEvents.list(projectId, {
+  sourceId: source.id,
+  page: 0,
+  size: 20,
+});
+
+// Get event details
+const event = await client.incomingEvents.get(projectId, eventId);
+
+// Get forward attempts for an event
+const attempts = await client.incomingEvents.getAttempts(projectId, eventId);
+
+// Replay event to all destinations
+const result = await client.incomingEvents.replay(projectId, eventId);
+console.log(`Replayed to ${result.destinationsCount} destinations`);
+```
+
+## Webhook Signature Verification
+
+Verify incoming webhooks in your endpoint:
+
+```typescript
+import { verifySignature, constructEvent } from '@railhook/node';
+
+app.post('/webhooks', (req, res) => {
+  const payload = req.body; // raw body string
+  const signature = req.headers['x-signature'];
+  const secret = process.env.WEBHOOK_SECRET;
+
+  try {
+    // Option 1: Just verify
+    verifySignature(payload, signature, secret);
+
+    // Option 2: Verify and parse
+    const event = constructEvent(payload, req.headers, secret);
+
+    // event.data is the parsed body; event.eventId / event.deliveryId /
+    // event.timestamp come from the X-Event-Id / X-Delivery-Id / X-Timestamp
+    // headers. See "What lands on your endpoint" below for event.type.
+    console.log(`Delivery ${event.deliveryId} of event ${event.eventId}:`, event.data);
+    handleOrderCompleted(event.data);
+
+    res.status(200).send('OK');
+  } catch (err) {
+    console.error('Webhook verification failed:', err.message);
+    res.status(400).send('Invalid signature');
+  }
+});
+```
+
+### What lands on your endpoint
+
+Railhook PUTs the event's **payload** on the wire, not an envelope. This:
+
+```typescript
+await client.events.send({ type: 'order.completed', data: { orderId: 'ord_1' } });
+```
+
+arrives at your endpoint as the `data` object alone —
+
+```http
+POST /webhooks HTTP/1.1
+Content-Type: application/json
+X-Signature: t=1738000000000,v1=<hex hmac-sha256>
+X-Timestamp: 1738000000000
+X-Event-Id: 6f0e…
+X-Delivery-Id: 91ab…
+X-Sequence-Number: 0
+Idempotency-Key: 6f0e…-<endpoint-id>
+
+{"orderId":"ord_1"}
+```
+
+So `constructEvent` fills `eventId`, `deliveryId` and `timestamp` from the
+headers and `data` from the body, but **`type` is empty**: the event type is
+not on the wire for a default subscription. Route on the payload, on the
+endpoint you registered, or set the subscription's `payloadTemplate` to wrap
+the event so `type` becomes part of the body.
+
+The signature is computed over `` `${timestamp}.${rawBody}` `` with HMAC-SHA256
+and the endpoint secret, and the server rejects timestamps more than **300
+seconds** old — verify against the *raw* body bytes, before any JSON parse and
+re-serialize.
+
+### Express.js Example
+
+```typescript
+import express from 'express';
+import { constructEvent } from '@railhook/node';
+
+const app = express();
+
+// Important: Use raw body for signature verification
+app.post('/webhooks', express.raw({ type: 'application/json' }), (req, res) => {
+  const event = constructEvent(
+    req.body.toString(),
+    req.headers,
+    process.env.WEBHOOK_SECRET
+  );
+
+  // Process event...
+  res.sendStatus(200);
+});
+```
+
+## Error Handling
+
+```typescript
+import { 
+  RailhookError, 
+  RateLimitError, 
+  AuthenticationError,
+  ValidationError 
+} from '@railhook/node';
+
+try {
+  await client.events.send({ type: 'test', data: {} });
+} catch (err) {
+  if (err instanceof RateLimitError) {
+    // retryAfter is milliseconds. err.rateLimitInfo.reset is the raw
+    // X-RateLimit-Reset header, which the API sends in Unix *seconds*.
+    console.log(`Rate limited. Retry after ${err.retryAfter}ms`);
+    await sleep(err.retryAfter);
+  } else if (err instanceof AuthenticationError) {
+    console.error('Invalid API key');
+  } else if (err instanceof ValidationError) {
+    console.error('Validation failed:', err.fieldErrors);
+  } else if (err instanceof RailhookError) {
+    console.error(`Error ${err.status}: ${err.message}`);
+  }
+}
+```
+
+### Error Response Format
+
+All API errors return a consistent JSON body:
+
+```json
+{
+  "error": "error_code",
+  "message": "Human-readable description",
+  "status": 400,
+  "fieldErrors": { "field": "reason" }
+}
+```
+
+- **`error`** — machine-readable error code (`snake_case`), always present
+- **`message`** — human-readable description, always present
+- **`status`** — HTTP status code (integer), always present
+- **`fieldErrors`** — field-level validation details (only present for `validation_error`)
+
+### Error Codes Reference
+
+| HTTP Status | `error` Code | SDK Exception | Description |
+|---|---|---|---|
+| 400 | `validation_error` | `ValidationError` | Invalid request parameters; see `fieldErrors` |
+| 400 | `invalid_request` | `RailhookError` | Malformed or semantically invalid request |
+| 401 | `unauthorized` | `AuthenticationError` | Missing or invalid API key / expired token |
+| 403 | `forbidden` | `RailhookError` | Insufficient permissions for the action |
+| 404 | `not_found` | `NotFoundError` | Requested resource does not exist |
+| 413 | `payload_too_large` | `RailhookError` | Request body exceeds maximum allowed size |
+| 422 | `unprocessable_entity` | `RailhookError` | Valid syntax but violates business rules |
+| 429 | `rate_limit_exceeded` | `RateLimitError` | Too many requests; check `X-RateLimit-*` headers |
+| 500 | `internal_error` | `RailhookError` | Unexpected server error |
+
+## Generic Requests
+
+As the API expands, you can call any endpoint directly without waiting for SDK updates:
+
+```typescript
+// GET
+const schemas = await client.get<any[]>('/api/v1/projects/proj_123/schemas');
+
+// POST with body and idempotency key
+const result = await client.post('/api/v1/some/new/endpoint', { key: 'value' }, 'idempotency-key');
+
+// PUT
+await client.put('/api/v1/projects/proj_123/settings', { timezone: 'UTC' });
+
+// PATCH
+await client.patch('/api/v1/projects/proj_123/settings', { timezone: 'UTC' });
+
+// DELETE
+await client.delete('/api/v1/projects/proj_123/tags/old-tag');
+
+// Fully custom request (any HTTP method)
+const data = await client.request<any>('OPTIONS', '/api/v1/some/path');
+```
+
+All generic methods use the same authentication, error handling, and rate-limit logic as the built-in methods.
+
+## Configuration
+
+```typescript
+const client = new Railhook({
+  apiKey: process.env.RAILHOOK_API_KEY, // Required: Your project API key
+  baseUrl: 'https://api.example.com', // Optional: API base URL (default: http://localhost:8080)
+  timeout: 30000,              // Optional: Request timeout in ms (default: 30000)
+});
+```
+
+### Timeouts and retries
+
+`timeout` is a per-request socket timeout; hitting it rejects with
+`RailhookError` (`code: 'timeout'`, `status: 0`). A connection-level failure
+rejects the same way with `code: 'network_error'`.
+
+**The client does not retry.** One SDK call is exactly one HTTP request — no
+backoff, no idempotent replay. That is deliberate: `events.send` accepts an
+`Idempotency-Key`, so a retry policy belongs to the caller who knows whether
+reissuing the request is safe. What *is* retried is the delivery itself, by the
+platform, on the subscription's `retryDelays` ladder.
+
+## Authentication
+
+Every request the client makes carries `X-API-Key: <your key>` — the project
+API key, created in the dashboard or via
+`POST /api/v1/projects/{projectId}/api-keys`. The SDK never sends a bearer
+token and has no login surface: JWT-authenticated endpoints (auth, projects,
+organizations, members, API keys) are not part of it. Bootstrapping a project
+and a key is a one-time step you do with the dashboard, the CLI, or plain
+HTTP.
+
+## TypeScript Support
+
+This SDK is written in TypeScript and includes full type definitions:
+
+```typescript
+import type { 
+  Event, 
+  EventResponse, 
+  Endpoint, 
+  Delivery,
+  DeliveryStatus 
+} from '@railhook/node';
+```
+
+## Development
+
+### Running Tests
+
+**Local (requires Node.js 16+):**
+```bash
+npm install
+npm test
+```
+
+**Docker:**
+```bash
+docker run --rm -v $(pwd):/app -w /app node:20-alpine sh -c "npm install && npm test"
+```
+
+### Live-API smoke check
+
+`npm test` stubs the transport, so it cannot see a renamed field. To drive the
+SDK against a real instance:
+
+```bash
+make up                # from the repo root
+npm run smoke:live     # SMOKE_API_BASE_URL overrides the target
+```
+
+It registers a throwaway org, walks endpoint → subscription → event →
+deliveries → attempts → incoming, checks each error envelope, and verifies a
+signature the running server itself produced. It is a script, not a test —
+`jest.config.js` roots at `src/`, so `npm test` never collects it and still
+passes with no backend.
+
+### Building
+
+```bash
+npm run build
+```
+
+## License
+
+MIT

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

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

package/dist/__tests__/client.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const errors_1 = require("../errors");
+describe('Railhook Client', () => {
+    describe('constructor', () => {
+        it('should create client with API key', () => {
+            const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+            expect(client).toBeInstanceOf(client_1.Railhook);
+        });
+        it('should throw error without API key', () => {
+            expect(() => new client_1.Railhook({ apiKey: '' })).toThrow('API key is required');
+        });
+        it('should use default base URL', () => {
+            const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+            expect(client).toBeDefined();
+        });
+        it('should accept custom base URL', () => {
+            const client = new client_1.Railhook({
+                apiKey: 'test_api_key',
+                baseUrl: 'https://api.example.com',
+            });
+            expect(client).toBeDefined();
+        });
+        it('should accept custom timeout', () => {
+            const client = new client_1.Railhook({
+                apiKey: 'test_api_key',
+                timeout: 60000,
+            });
+            expect(client).toBeDefined();
+        });
+        it('should initialize all API modules', () => {
+            const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+            expect(client.events).toBeDefined();
+            expect(client.endpoints).toBeDefined();
+            expect(client.subscriptions).toBeDefined();
+            expect(client.deliveries).toBeDefined();
+        });
+    });
+});
+describe('Generic Request Methods', () => {
+    it('should expose get method', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+        expect(typeof client.get).toBe('function');
+    });
+    it('should expose post method', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+        expect(typeof client.post).toBe('function');
+    });
+    it('should expose put method', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+        expect(typeof client.put).toBe('function');
+    });
+    it('should expose patch method', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+        expect(typeof client.patch).toBe('function');
+    });
+    it('should expose delete method', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+        expect(typeof client.delete).toBe('function');
+    });
+    it('should expose request method for fully custom calls', () => {
+        const client = new client_1.Railhook({ apiKey: 'test_api_key' });
+        expect(typeof client.request).toBe('function');
+    });
+});
+describe('Error Classes', () => {
+    describe('RailhookError', () => {
+        it('should have correct properties', () => {
+            const error = new errors_1.RailhookError('Test error', 500, 'test_code');
+            expect(error.message).toBe('Test error');
+            expect(error.status).toBe(500);
+            expect(error.code).toBe('test_code');
+            expect(error.name).toBe('RailhookError');
+        });
+    });
+    describe('AuthenticationError', () => {
+        it('should have correct defaults', () => {
+            const error = new errors_1.AuthenticationError();
+            expect(error.message).toBe('Invalid API key');
+            expect(error.status).toBe(401);
+            expect(error.code).toBe('authentication_error');
+            expect(error.name).toBe('AuthenticationError');
+        });
+        it('should accept custom message', () => {
+            const error = new errors_1.AuthenticationError('Custom auth error');
+            expect(error.message).toBe('Custom auth error');
+        });
+    });
+    describe('ValidationError', () => {
+        it('should have field errors', () => {
+            const fieldErrors = { email: 'Invalid email', url: 'Invalid URL' };
+            const error = new errors_1.ValidationError('Validation failed', fieldErrors);
+            expect(error.message).toBe('Validation failed');
+            expect(error.status).toBe(400);
+            expect(error.code).toBe('validation_error');
+            expect(error.fieldErrors).toEqual(fieldErrors);
+        });
+        it('should default to empty field errors', () => {
+            const error = new errors_1.ValidationError('Validation failed');
+            expect(error.fieldErrors).toEqual({});
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.test.js","sourceRoot":"","sources":["../../src/__tests__/client.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Railhook } from '../client';\nimport { RailhookError, AuthenticationError, ValidationError } from '../errors';\n\ndescribe('Railhook Client', () => {\n  describe('constructor', () => {\n    it('should create client with API key', () => {\n      const client = new Railhook({ apiKey: 'test_api_key' });\n      expect(client).toBeInstanceOf(Railhook);\n    });\n\n    it('should throw error without API key', () => {\n      expect(() => new Railhook({ apiKey: '' })).toThrow('API key is required');\n    });\n\n    it('should use default base URL', () => {\n      const client = new Railhook({ apiKey: 'test_api_key' });\n      expect(client).toBeDefined();\n    });\n\n    it('should accept custom base URL', () => {\n      const client = new Railhook({\n        apiKey: 'test_api_key',\n        baseUrl: 'https://api.example.com',\n      });\n      expect(client).toBeDefined();\n    });\n\n    it('should accept custom timeout', () => {\n      const client = new Railhook({\n        apiKey: 'test_api_key',\n        timeout: 60000,\n      });\n      expect(client).toBeDefined();\n    });\n\n    it('should initialize all API modules', () => {\n      const client = new Railhook({ apiKey: 'test_api_key' });\n      expect(client.events).toBeDefined();\n      expect(client.endpoints).toBeDefined();\n      expect(client.subscriptions).toBeDefined();\n      expect(client.deliveries).toBeDefined();\n    });\n  });\n});\n\ndescribe('Generic Request Methods', () => {\n  it('should expose get method', () => {\n    const client = new Railhook({ apiKey: 'test_api_key' });\n    expect(typeof client.get).toBe('function');\n  });\n\n  it('should expose post method', () => {\n    const client = new Railhook({ apiKey: 'test_api_key' });\n    expect(typeof client.post).toBe('function');\n  });\n\n  it('should expose put method', () => {\n    const client = new Railhook({ apiKey: 'test_api_key' });\n    expect(typeof client.put).toBe('function');\n  });\n\n  it('should expose patch method', () => {\n    const client = new Railhook({ apiKey: 'test_api_key' });\n    expect(typeof client.patch).toBe('function');\n  });\n\n  it('should expose delete method', () => {\n    const client = new Railhook({ apiKey: 'test_api_key' });\n    expect(typeof client.delete).toBe('function');\n  });\n\n  it('should expose request method for fully custom calls', () => {\n    const client = new Railhook({ apiKey: 'test_api_key' });\n    expect(typeof client.request).toBe('function');\n  });\n});\n\ndescribe('Error Classes', () => {\n  describe('RailhookError', () => {\n    it('should have correct properties', () => {\n      const error = new RailhookError('Test error', 500, 'test_code');\n      expect(error.message).toBe('Test error');\n      expect(error.status).toBe(500);\n      expect(error.code).toBe('test_code');\n      expect(error.name).toBe('RailhookError');\n    });\n  });\n\n  describe('AuthenticationError', () => {\n    it('should have correct defaults', () => {\n      const error = new AuthenticationError();\n      expect(error.message).toBe('Invalid API key');\n      expect(error.status).toBe(401);\n      expect(error.code).toBe('authentication_error');\n      expect(error.name).toBe('AuthenticationError');\n    });\n\n    it('should accept custom message', () => {\n      const error = new AuthenticationError('Custom auth error');\n      expect(error.message).toBe('Custom auth error');\n    });\n  });\n\n  describe('ValidationError', () => {\n    it('should have field errors', () => {\n      const fieldErrors = { email: 'Invalid email', url: 'Invalid URL' };\n      const error = new ValidationError('Validation failed', fieldErrors);\n      expect(error.message).toBe('Validation failed');\n      expect(error.status).toBe(400);\n      expect(error.code).toBe('validation_error');\n      expect(error.fieldErrors).toEqual(fieldErrors);\n    });\n\n    it('should default to empty field errors', () => {\n      const error = new ValidationError('Validation failed');\n      expect(error.fieldErrors).toEqual({});\n    });\n  });\n});\n"]}

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

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