@railhook/node 2.12.0

package/dist/client.js

@@ -0,0 +1,344 @@
+"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.Railhook = void 0;
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const url_1 = require("url");
+const errors_1 = require("./errors");
+const DEFAULT_BASE_URL = 'http://localhost:8080';
+const DEFAULT_TIMEOUT = 30000;
+const SDK_VERSION = '2.12.0';
+class Railhook {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('API key is required');
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        this.timeout = config.timeout || DEFAULT_TIMEOUT;
+        this.events = new Events(this);
+        this.endpoints = new Endpoints(this);
+        this.subscriptions = new Subscriptions(this);
+        this.deliveries = new Deliveries(this);
+        this.incomingSources = new IncomingSources(this);
+        this.incomingEvents = new IncomingEvents(this);
+    }
+    async request(method, path, body, idempotencyKey) {
+        const url = new url_1.URL(path, this.baseUrl);
+        const isHttps = url.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const headers = {
+            'X-API-Key': this.apiKey,
+            'Content-Type': 'application/json',
+            'User-Agent': `railhook-node/${SDK_VERSION}`,
+        };
+        if (idempotencyKey) {
+            headers['Idempotency-Key'] = idempotencyKey;
+        }
+        const options = {
+            method,
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            headers,
+            timeout: this.timeout,
+        };
+        return new Promise((resolve, reject) => {
+            const req = lib.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    try {
+                        const rateLimitInfo = this.extractRateLimitInfo(res.headers);
+                        if (res.statusCode === 204) {
+                            resolve(undefined);
+                            return;
+                        }
+                        const parsed = data ? JSON.parse(data) : {};
+                        if (res.statusCode && res.statusCode >= 400) {
+                            reject(this.handleError(res.statusCode, parsed, rateLimitInfo));
+                            return;
+                        }
+                        resolve(parsed);
+                    }
+                    catch (err) {
+                        reject(new errors_1.RailhookError('Failed to parse response', 500));
+                    }
+                });
+            });
+            req.on('error', (err) => {
+                reject(new errors_1.RailhookError(err.message, 0, 'network_error'));
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new errors_1.RailhookError('Request timeout', 0, 'timeout'));
+            });
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
+    }
+    /**
+     * Generic GET request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    async get(path) {
+        return this.request('GET', path);
+    }
+    /**
+     * Generic POST request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    async post(path, body, idempotencyKey) {
+        return this.request('POST', path, body, idempotencyKey);
+    }
+    /**
+     * Generic PUT request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    async put(path, body) {
+        return this.request('PUT', path, body);
+    }
+    /**
+     * Generic PATCH request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    async patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    /**
+     * Generic DELETE request to any API path.
+     * Use this for endpoints not yet covered by the SDK.
+     */
+    async delete(path) {
+        return this.request('DELETE', path);
+    }
+    extractRateLimitInfo(headers) {
+        const limit = headers['x-ratelimit-limit'];
+        const remaining = headers['x-ratelimit-remaining'];
+        const reset = headers['x-ratelimit-reset'];
+        if (limit && remaining && reset) {
+            return {
+                limit: parseInt(limit, 10),
+                remaining: parseInt(remaining, 10),
+                reset: parseInt(reset, 10),
+            };
+        }
+        return undefined;
+    }
+    handleError(status, body, rateLimitInfo) {
+        const message = body.message || 'Unknown error';
+        switch (status) {
+            case 401:
+                return new errors_1.AuthenticationError(message);
+            case 404:
+                return new errors_1.NotFoundError(message);
+            case 429:
+                return new errors_1.RateLimitError(message, 
+                // `reset` is a Unix timestamp in seconds (see RateLimitInfo), so the
+                // fallback has to be in seconds too, not Date.now() + 60000.
+                rateLimitInfo || { limit: 0, remaining: 0, reset: Math.floor(Date.now() / 1000) + 60 });
+            case 400:
+                return new errors_1.ValidationError(message, body.fieldErrors || {});
+            default:
+                return new errors_1.RailhookError(message, status, body.error);
+        }
+    }
+}
+exports.Railhook = Railhook;
+class Events {
+    constructor(client) {
+        this.client = client;
+    }
+    async send(event, idempotencyKey) {
+        return this.client.request('POST', '/api/v1/events', event, idempotencyKey);
+    }
+}
+class Endpoints {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(projectId, params) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/endpoints`, params);
+    }
+    async get(projectId, endpointId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/endpoints/${endpointId}`);
+    }
+    /**
+     * Lists a project's endpoints.
+     *
+     * The API returns a Spring page envelope here, not a bare array — the
+     * endpoints themselves are in `.content`.
+     */
+    async list(projectId, params = {}) {
+        const query = new URLSearchParams();
+        if (params.page !== undefined)
+            query.set('page', params.page.toString());
+        if (params.size !== undefined)
+            query.set('size', params.size.toString());
+        const queryString = query.toString();
+        const path = `/api/v1/projects/${projectId}/endpoints${queryString ? `?${queryString}` : ''}`;
+        return this.client.request('GET', path);
+    }
+    async update(projectId, endpointId, params) {
+        return this.client.request('PUT', `/api/v1/projects/${projectId}/endpoints/${endpointId}`, params);
+    }
+    async delete(projectId, endpointId) {
+        return this.client.request('DELETE', `/api/v1/projects/${projectId}/endpoints/${endpointId}`);
+    }
+    async rotateSecret(projectId, endpointId) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/endpoints/${endpointId}/rotate-secret`);
+    }
+    async test(projectId, endpointId) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/endpoints/${endpointId}/test`);
+    }
+}
+class Subscriptions {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(projectId, params) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/subscriptions`, params);
+    }
+    async get(projectId, subscriptionId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/subscriptions/${subscriptionId}`);
+    }
+    async list(projectId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/subscriptions`);
+    }
+    async update(projectId, subscriptionId, params) {
+        return this.client.request('PUT', `/api/v1/projects/${projectId}/subscriptions/${subscriptionId}`, params);
+    }
+    async delete(projectId, subscriptionId) {
+        return this.client.request('DELETE', `/api/v1/projects/${projectId}/subscriptions/${subscriptionId}`);
+    }
+}
+class Deliveries {
+    constructor(client) {
+        this.client = client;
+    }
+    async get(deliveryId) {
+        return this.client.request('GET', `/api/v1/deliveries/${deliveryId}`);
+    }
+    async list(projectId, params = {}) {
+        const query = new URLSearchParams();
+        if (params.status)
+            query.set('status', params.status);
+        if (params.endpointId)
+            query.set('endpointId', params.endpointId);
+        if (params.fromDate)
+            query.set('fromDate', params.fromDate);
+        if (params.toDate)
+            query.set('toDate', params.toDate);
+        if (params.page !== undefined)
+            query.set('page', params.page.toString());
+        if (params.size !== undefined)
+            query.set('size', params.size.toString());
+        const queryString = query.toString();
+        const path = `/api/v1/deliveries/projects/${projectId}${queryString ? `?${queryString}` : ''}`;
+        return this.client.request('GET', path);
+    }
+    async getAttempts(deliveryId) {
+        return this.client.request('GET', `/api/v1/deliveries/${deliveryId}/attempts`);
+    }
+    async replay(deliveryId) {
+        return this.client.request('POST', `/api/v1/deliveries/${deliveryId}/replay`);
+    }
+}
+class IncomingSources {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(projectId, params) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/incoming-sources`, params);
+    }
+    async get(projectId, sourceId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);
+    }
+    async list(projectId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/incoming-sources`);
+    }
+    async update(projectId, sourceId, params) {
+        return this.client.request('PUT', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}`, params);
+    }
+    async delete(projectId, sourceId) {
+        return this.client.request('DELETE', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}`);
+    }
+    // ── Destinations ──
+    async createDestination(projectId, sourceId, params) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`, params);
+    }
+    async getDestination(projectId, sourceId, destinationId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destinationId}`);
+    }
+    async listDestinations(projectId, sourceId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`);
+    }
+    async updateDestination(projectId, sourceId, destinationId, params) {
+        return this.client.request('PUT', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destinationId}`, params);
+    }
+    async deleteDestination(projectId, sourceId, destinationId) {
+        return this.client.request('DELETE', `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destinationId}`);
+    }
+}
+class IncomingEvents {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(projectId, params = {}) {
+        const query = new URLSearchParams();
+        if (params.sourceId)
+            query.set('sourceId', params.sourceId);
+        if (params.page !== undefined)
+            query.set('page', params.page.toString());
+        if (params.size !== undefined)
+            query.set('size', params.size.toString());
+        const queryString = query.toString();
+        const path = `/api/v1/projects/${projectId}/incoming-events${queryString ? `?${queryString}` : ''}`;
+        return this.client.request('GET', path);
+    }
+    async get(projectId, eventId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/incoming-events/${eventId}`);
+    }
+    async getAttempts(projectId, eventId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/incoming-events/${eventId}/attempts`);
+    }
+    async replay(projectId, eventId) {
+        return this.client.request('POST', `/api/v1/projects/${projectId}/incoming-events/${eventId}/replay`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["import * as https from 'https';\nimport * as http from 'http';\nimport { URL } from 'url';\nimport {\n  RailhookConfig,\n  Event,\n  EventResponse,\n  Endpoint,\n  EndpointCreateParams,\n  EndpointUpdateParams,\n  EndpointListParams,\n  Subscription,\n  SubscriptionCreateParams,\n  Delivery,\n  DeliveryAttempt,\n  DeliveryListParams,\n  PaginatedResponse,\n  EndpointTestResult,\n  RateLimitInfo,\n  IncomingSource,\n  IncomingSourceCreateParams,\n  IncomingSourceUpdateParams,\n  IncomingDestination,\n  IncomingDestinationCreateParams,\n  IncomingDestinationUpdateParams,\n  IncomingEvent,\n  IncomingEventListParams,\n  IncomingForwardAttempt,\n  ReplayEventResponse,\n} from './types';\nimport {\n  RailhookError,\n  AuthenticationError,\n  RateLimitError,\n  ValidationError,\n  NotFoundError,\n} from './errors';\n\nconst DEFAULT_BASE_URL = 'http://localhost:8080';\nconst DEFAULT_TIMEOUT = 30000;\nconst SDK_VERSION = '2.12.0';\n\nexport class Railhook {\n  private readonly apiKey: string;\n  private readonly baseUrl: string;\n  private readonly timeout: number;\n\n  public readonly events: Events;\n  public readonly endpoints: Endpoints;\n  public readonly subscriptions: Subscriptions;\n  public readonly deliveries: Deliveries;\n  public readonly incomingSources: IncomingSources;\n  public readonly incomingEvents: IncomingEvents;\n\n  constructor(config: RailhookConfig) {\n    if (!config.apiKey) {\n      throw new Error('API key is required');\n    }\n\n    this.apiKey = config.apiKey;\n    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;\n    this.timeout = config.timeout || DEFAULT_TIMEOUT;\n\n    this.events = new Events(this);\n    this.endpoints = new Endpoints(this);\n    this.subscriptions = new Subscriptions(this);\n    this.deliveries = new Deliveries(this);\n    this.incomingSources = new IncomingSources(this);\n    this.incomingEvents = new IncomingEvents(this);\n  }\n\n  async request<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    idempotencyKey?: string\n  ): Promise<T> {\n    const url = new URL(path, this.baseUrl);\n    const isHttps = url.protocol === 'https:';\n    const lib = isHttps ? https : http;\n\n    const headers: Record<string, string> = {\n      'X-API-Key': this.apiKey,\n      'Content-Type': 'application/json',\n      'User-Agent': `railhook-node/${SDK_VERSION}`,\n    };\n\n    if (idempotencyKey) {\n      headers['Idempotency-Key'] = idempotencyKey;\n    }\n\n    const options: http.RequestOptions = {\n      method,\n      hostname: url.hostname,\n      port: url.port || (isHttps ? 443 : 80),\n      path: url.pathname + url.search,\n      headers,\n      timeout: this.timeout,\n    };\n\n    return new Promise((resolve, reject) => {\n      const req = lib.request(options, (res) => {\n        let data = '';\n        res.on('data', (chunk) => (data += chunk));\n        res.on('end', () => {\n          try {\n            const rateLimitInfo = this.extractRateLimitInfo(res.headers);\n            \n            if (res.statusCode === 204) {\n              resolve(undefined as T);\n              return;\n            }\n\n            const parsed = data ? JSON.parse(data) : {};\n\n            if (res.statusCode && res.statusCode >= 400) {\n              reject(this.handleError(res.statusCode, parsed, rateLimitInfo));\n              return;\n            }\n\n            resolve(parsed as T);\n          } catch (err) {\n            reject(new RailhookError('Failed to parse response', 500));\n          }\n        });\n      });\n\n      req.on('error', (err) => {\n        reject(new RailhookError(err.message, 0, 'network_error'));\n      });\n\n      req.on('timeout', () => {\n        req.destroy();\n        reject(new RailhookError('Request timeout', 0, 'timeout'));\n      });\n\n      if (body) {\n        req.write(JSON.stringify(body));\n      }\n\n      req.end();\n    });\n  }\n\n  /**\n   * Generic GET request to any API path.\n   * Use this for endpoints not yet covered by the SDK.\n   */\n  async get<T = unknown>(path: string): Promise<T> {\n    return this.request<T>('GET', path);\n  }\n\n  /**\n   * Generic POST request to any API path.\n   * Use this for endpoints not yet covered by the SDK.\n   */\n  async post<T = unknown>(path: string, body?: unknown, idempotencyKey?: string): Promise<T> {\n    return this.request<T>('POST', path, body, idempotencyKey);\n  }\n\n  /**\n   * Generic PUT request to any API path.\n   * Use this for endpoints not yet covered by the SDK.\n   */\n  async put<T = unknown>(path: string, body?: unknown): Promise<T> {\n    return this.request<T>('PUT', path, body);\n  }\n\n  /**\n   * Generic PATCH request to any API path.\n   * Use this for endpoints not yet covered by the SDK.\n   */\n  async patch<T = unknown>(path: string, body?: unknown): Promise<T> {\n    return this.request<T>('PATCH', path, body);\n  }\n\n  /**\n   * Generic DELETE request to any API path.\n   * Use this for endpoints not yet covered by the SDK.\n   */\n  async delete<T = void>(path: string): Promise<T> {\n    return this.request<T>('DELETE', path);\n  }\n\n  private extractRateLimitInfo(headers: http.IncomingHttpHeaders): RateLimitInfo | undefined {\n    const limit = headers['x-ratelimit-limit'];\n    const remaining = headers['x-ratelimit-remaining'];\n    const reset = headers['x-ratelimit-reset'];\n\n    if (limit && remaining && reset) {\n      return {\n        limit: parseInt(limit as string, 10),\n        remaining: parseInt(remaining as string, 10),\n        reset: parseInt(reset as string, 10),\n      };\n    }\n    return undefined;\n  }\n\n  private handleError(\n    status: number,\n    body: Record<string, unknown>,\n    rateLimitInfo?: RateLimitInfo\n  ): RailhookError {\n    const message = (body.message as string) || 'Unknown error';\n\n    switch (status) {\n      case 401:\n        return new AuthenticationError(message);\n      case 404:\n        return new NotFoundError(message);\n      case 429:\n        return new RateLimitError(\n          message,\n          // `reset` is a Unix timestamp in seconds (see RateLimitInfo), so the\n          // fallback has to be in seconds too, not Date.now() + 60000.\n          rateLimitInfo || { limit: 0, remaining: 0, reset: Math.floor(Date.now() / 1000) + 60 }\n        );\n      case 400:\n        return new ValidationError(\n          message,\n          (body.fieldErrors as Record<string, string>) || {}\n        );\n      default:\n        return new RailhookError(message, status, body.error as string);\n    }\n  }\n}\n\nclass Events {\n  constructor(private client: Railhook) {}\n\n  async send(event: Event, idempotencyKey?: string): Promise<EventResponse> {\n    return this.client.request<EventResponse>(\n      'POST',\n      '/api/v1/events',\n      event,\n      idempotencyKey\n    );\n  }\n}\n\nclass Endpoints {\n  constructor(private client: Railhook) {}\n\n  async create(projectId: string, params: EndpointCreateParams): Promise<Endpoint> {\n    return this.client.request<Endpoint>(\n      'POST',\n      `/api/v1/projects/${projectId}/endpoints`,\n      params\n    );\n  }\n\n  async get(projectId: string, endpointId: string): Promise<Endpoint> {\n    return this.client.request<Endpoint>(\n      'GET',\n      `/api/v1/projects/${projectId}/endpoints/${endpointId}`\n    );\n  }\n\n  /**\n   * Lists a project's endpoints.\n   *\n   * The API returns a Spring page envelope here, not a bare array — the\n   * endpoints themselves are in `.content`.\n   */\n  async list(\n    projectId: string,\n    params: EndpointListParams = {}\n  ): Promise<PaginatedResponse<Endpoint>> {\n    const query = new URLSearchParams();\n    if (params.page !== undefined) query.set('page', params.page.toString());\n    if (params.size !== undefined) query.set('size', params.size.toString());\n\n    const queryString = query.toString();\n    const path = `/api/v1/projects/${projectId}/endpoints${queryString ? `?${queryString}` : ''}`;\n\n    return this.client.request<PaginatedResponse<Endpoint>>('GET', path);\n  }\n\n  async update(\n    projectId: string,\n    endpointId: string,\n    params: EndpointUpdateParams\n  ): Promise<Endpoint> {\n    return this.client.request<Endpoint>(\n      'PUT',\n      `/api/v1/projects/${projectId}/endpoints/${endpointId}`,\n      params\n    );\n  }\n\n  async delete(projectId: string, endpointId: string): Promise<void> {\n    return this.client.request<void>(\n      'DELETE',\n      `/api/v1/projects/${projectId}/endpoints/${endpointId}`\n    );\n  }\n\n  async rotateSecret(projectId: string, endpointId: string): Promise<Endpoint> {\n    return this.client.request<Endpoint>(\n      'POST',\n      `/api/v1/projects/${projectId}/endpoints/${endpointId}/rotate-secret`\n    );\n  }\n\n  async test(projectId: string, endpointId: string): Promise<EndpointTestResult> {\n    return this.client.request<EndpointTestResult>(\n      'POST',\n      `/api/v1/projects/${projectId}/endpoints/${endpointId}/test`\n    );\n  }\n}\n\nclass Subscriptions {\n  constructor(private client: Railhook) {}\n\n  async create(projectId: string, params: SubscriptionCreateParams): Promise<Subscription> {\n    return this.client.request<Subscription>(\n      'POST',\n      `/api/v1/projects/${projectId}/subscriptions`,\n      params\n    );\n  }\n\n  async get(projectId: string, subscriptionId: string): Promise<Subscription> {\n    return this.client.request<Subscription>(\n      'GET',\n      `/api/v1/projects/${projectId}/subscriptions/${subscriptionId}`\n    );\n  }\n\n  async list(projectId: string): Promise<Subscription[]> {\n    return this.client.request<Subscription[]>(\n      'GET',\n      `/api/v1/projects/${projectId}/subscriptions`\n    );\n  }\n\n  async update(\n    projectId: string,\n    subscriptionId: string,\n    params: Partial<SubscriptionCreateParams>\n  ): Promise<Subscription> {\n    return this.client.request<Subscription>(\n      'PUT',\n      `/api/v1/projects/${projectId}/subscriptions/${subscriptionId}`,\n      params\n    );\n  }\n\n  async delete(projectId: string, subscriptionId: string): Promise<void> {\n    return this.client.request<void>(\n      'DELETE',\n      `/api/v1/projects/${projectId}/subscriptions/${subscriptionId}`\n    );\n  }\n}\n\nclass Deliveries {\n  constructor(private client: Railhook) {}\n\n  async get(deliveryId: string): Promise<Delivery> {\n    return this.client.request<Delivery>('GET', `/api/v1/deliveries/${deliveryId}`);\n  }\n\n  async list(\n    projectId: string,\n    params: DeliveryListParams = {}\n  ): Promise<PaginatedResponse<Delivery>> {\n    const query = new URLSearchParams();\n    if (params.status) query.set('status', params.status);\n    if (params.endpointId) query.set('endpointId', params.endpointId);\n    if (params.fromDate) query.set('fromDate', params.fromDate);\n    if (params.toDate) query.set('toDate', params.toDate);\n    if (params.page !== undefined) query.set('page', params.page.toString());\n    if (params.size !== undefined) query.set('size', params.size.toString());\n\n    const queryString = query.toString();\n    const path = `/api/v1/deliveries/projects/${projectId}${queryString ? `?${queryString}` : ''}`;\n\n    return this.client.request<PaginatedResponse<Delivery>>('GET', path);\n  }\n\n  async getAttempts(deliveryId: string): Promise<DeliveryAttempt[]> {\n    return this.client.request<DeliveryAttempt[]>(\n      'GET',\n      `/api/v1/deliveries/${deliveryId}/attempts`\n    );\n  }\n\n  async replay(deliveryId: string): Promise<void> {\n    return this.client.request<void>('POST', `/api/v1/deliveries/${deliveryId}/replay`);\n  }\n}\n\nclass IncomingSources {\n  constructor(private client: Railhook) {}\n\n  async create(projectId: string, params: IncomingSourceCreateParams): Promise<IncomingSource> {\n    return this.client.request<IncomingSource>(\n      'POST',\n      `/api/v1/projects/${projectId}/incoming-sources`,\n      params\n    );\n  }\n\n  async get(projectId: string, sourceId: string): Promise<IncomingSource> {\n    return this.client.request<IncomingSource>(\n      'GET',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}`\n    );\n  }\n\n  async list(projectId: string): Promise<PaginatedResponse<IncomingSource>> {\n    return this.client.request<PaginatedResponse<IncomingSource>>(\n      'GET',\n      `/api/v1/projects/${projectId}/incoming-sources`\n    );\n  }\n\n  async update(projectId: string, sourceId: string, params: IncomingSourceUpdateParams): Promise<IncomingSource> {\n    return this.client.request<IncomingSource>(\n      'PUT',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}`,\n      params\n    );\n  }\n\n  async delete(projectId: string, sourceId: string): Promise<void> {\n    return this.client.request<void>(\n      'DELETE',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}`\n    );\n  }\n\n  // ── Destinations ──\n\n  async createDestination(\n    projectId: string,\n    sourceId: string,\n    params: IncomingDestinationCreateParams\n  ): Promise<IncomingDestination> {\n    return this.client.request<IncomingDestination>(\n      'POST',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`,\n      params\n    );\n  }\n\n  async getDestination(\n    projectId: string,\n    sourceId: string,\n    destinationId: string\n  ): Promise<IncomingDestination> {\n    return this.client.request<IncomingDestination>(\n      'GET',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destinationId}`\n    );\n  }\n\n  async listDestinations(\n    projectId: string,\n    sourceId: string\n  ): Promise<PaginatedResponse<IncomingDestination>> {\n    return this.client.request<PaginatedResponse<IncomingDestination>>(\n      'GET',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations`\n    );\n  }\n\n  async updateDestination(\n    projectId: string,\n    sourceId: string,\n    destinationId: string,\n    params: IncomingDestinationUpdateParams\n  ): Promise<IncomingDestination> {\n    return this.client.request<IncomingDestination>(\n      'PUT',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destinationId}`,\n      params\n    );\n  }\n\n  async deleteDestination(\n    projectId: string,\n    sourceId: string,\n    destinationId: string\n  ): Promise<void> {\n    return this.client.request<void>(\n      'DELETE',\n      `/api/v1/projects/${projectId}/incoming-sources/${sourceId}/destinations/${destinationId}`\n    );\n  }\n}\n\nclass IncomingEvents {\n  constructor(private client: Railhook) {}\n\n  async list(\n    projectId: string,\n    params: IncomingEventListParams = {}\n  ): Promise<PaginatedResponse<IncomingEvent>> {\n    const query = new URLSearchParams();\n    if (params.sourceId) query.set('sourceId', params.sourceId);\n    if (params.page !== undefined) query.set('page', params.page.toString());\n    if (params.size !== undefined) query.set('size', params.size.toString());\n\n    const queryString = query.toString();\n    const path = `/api/v1/projects/${projectId}/incoming-events${queryString ? `?${queryString}` : ''}`;\n\n    return this.client.request<PaginatedResponse<IncomingEvent>>('GET', path);\n  }\n\n  async get(projectId: string, eventId: string): Promise<IncomingEvent> {\n    return this.client.request<IncomingEvent>(\n      'GET',\n      `/api/v1/projects/${projectId}/incoming-events/${eventId}`\n    );\n  }\n\n  async getAttempts(\n    projectId: string,\n    eventId: string\n  ): Promise<PaginatedResponse<IncomingForwardAttempt>> {\n    return this.client.request<PaginatedResponse<IncomingForwardAttempt>>(\n      'GET',\n      `/api/v1/projects/${projectId}/incoming-events/${eventId}/attempts`\n    );\n  }\n\n  async replay(projectId: string, eventId: string): Promise<ReplayEventResponse> {\n    return this.client.request<ReplayEventResponse>(\n      'POST',\n      `/api/v1/projects/${projectId}/incoming-events/${eventId}/replay`\n    );\n  }\n}\n"]}

package/dist/errors.d.ts

@@ -0,0 +1,28 @@
+import { RateLimitInfo } from './types';
+export declare class RailhookError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export declare class AuthenticationError extends RailhookError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends RailhookError {
+    readonly rateLimitInfo: RateLimitInfo;
+    constructor(message: string, rateLimitInfo: RateLimitInfo);
+    /**
+     * Milliseconds to wait before retrying.
+     *
+     * `rateLimitInfo.reset` is the raw `X-RateLimit-Reset` header, which the API
+     * sends as a Unix timestamp in **seconds**; comparing it to `Date.now()`
+     * (milliseconds) directly always yields a large negative number, i.e. 0.
+     */
+    get retryAfter(): number;
+}
+export declare class ValidationError extends RailhookError {
+    readonly fieldErrors: Record<string, string>;
+    constructor(message: string, fieldErrors?: Record<string, string>);
+}
+export declare class NotFoundError extends RailhookError {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.ValidationError = exports.RateLimitError = exports.AuthenticationError = exports.RailhookError = void 0;
+class RailhookError extends Error {
+    constructor(message, status, code) {
+        super(message);
+        this.name = 'RailhookError';
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.RailhookError = RailhookError;
+class AuthenticationError extends RailhookError {
+    constructor(message = 'Invalid API key') {
+        super(message, 401, 'authentication_error');
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class RateLimitError extends RailhookError {
+    constructor(message, rateLimitInfo) {
+        super(message, 429, 'rate_limit_exceeded');
+        this.name = 'RateLimitError';
+        this.rateLimitInfo = rateLimitInfo;
+    }
+    /**
+     * Milliseconds to wait before retrying.
+     *
+     * `rateLimitInfo.reset` is the raw `X-RateLimit-Reset` header, which the API
+     * sends as a Unix timestamp in **seconds**; comparing it to `Date.now()`
+     * (milliseconds) directly always yields a large negative number, i.e. 0.
+     */
+    get retryAfter() {
+        return Math.max(0, this.rateLimitInfo.reset * 1000 - Date.now());
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ValidationError extends RailhookError {
+    constructor(message, fieldErrors = {}) {
+        super(message, 400, 'validation_error');
+        this.name = 'ValidationError';
+        this.fieldErrors = fieldErrors;
+    }
+}
+exports.ValidationError = ValidationError;
+class NotFoundError extends RailhookError {
+    constructor(message = 'Resource not found') {
+        super(message, 404, 'not_found');
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Railhook } from './client';
+export { RailhookError, RateLimitError, AuthenticationError, ValidationError, NotFoundError } from './errors';
+export { Railhook as WebhookPlatform } from './client';
+export { RailhookError as WebhookPlatformError } from './errors';
+export { verifySignature, verifyStandardWebhook, constructEvent, generateSignature } from './webhooks';
+export type { WebhookHeaders, VerifyOptions } from './webhooks';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,37 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSignature = exports.constructEvent = exports.verifyStandardWebhook = exports.verifySignature = exports.WebhookPlatformError = exports.WebhookPlatform = exports.NotFoundError = exports.ValidationError = exports.AuthenticationError = exports.RateLimitError = exports.RailhookError = exports.Railhook = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "Railhook", { enumerable: true, get: function () { return client_1.Railhook; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "RailhookError", { enumerable: true, get: function () { return errors_1.RailhookError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_1.NotFoundError; } });
+// Backward-compatible aliases
+var client_2 = require("./client");
+Object.defineProperty(exports, "WebhookPlatform", { enumerable: true, get: function () { return client_2.Railhook; } });
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "WebhookPlatformError", { enumerable: true, get: function () { return errors_2.RailhookError; } });
+var webhooks_1 = require("./webhooks");
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return webhooks_1.verifySignature; } });
+Object.defineProperty(exports, "verifyStandardWebhook", { enumerable: true, get: function () { return webhooks_1.verifyStandardWebhook; } });
+Object.defineProperty(exports, "constructEvent", { enumerable: true, get: function () { return webhooks_1.constructEvent; } });
+Object.defineProperty(exports, "generateSignature", { enumerable: true, get: function () { return webhooks_1.generateSignature; } });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtQ0FBb0M7QUFBM0Isa0dBQUEsUUFBUSxPQUFBO0FBQ2pCLG1DQUE4RztBQUFyRyx1R0FBQSxhQUFhLE9BQUE7QUFBRSx3R0FBQSxjQUFjLE9BQUE7QUFBRSw2R0FBQSxtQkFBbUIsT0FBQTtBQUFFLHlHQUFBLGVBQWUsT0FBQTtBQUFFLHVHQUFBLGFBQWEsT0FBQTtBQUUzRiw4QkFBOEI7QUFDOUIsbUNBQXVEO0FBQTlDLHlHQUFBLFFBQVEsT0FBbUI7QUFDcEMsbUNBQWlFO0FBQXhELDhHQUFBLGFBQWEsT0FBd0I7QUFDOUMsdUNBQXVHO0FBQTlGLDJHQUFBLGVBQWUsT0FBQTtBQUFFLGlIQUFBLHFCQUFxQixPQUFBO0FBQUUsMEdBQUEsY0FBYyxPQUFBO0FBQUUsNkdBQUEsaUJBQWlCLE9BQUE7QUFFbEYsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgUmFpbGhvb2sgfSBmcm9tICcuL2NsaWVudCc7XG5leHBvcnQgeyBSYWlsaG9va0Vycm9yLCBSYXRlTGltaXRFcnJvciwgQXV0aGVudGljYXRpb25FcnJvciwgVmFsaWRhdGlvbkVycm9yLCBOb3RGb3VuZEVycm9yIH0gZnJvbSAnLi9lcnJvcnMnO1xuXG4vLyBCYWNrd2FyZC1jb21wYXRpYmxlIGFsaWFzZXNcbmV4cG9ydCB7IFJhaWxob29rIGFzIFdlYmhvb2tQbGF0Zm9ybSB9IGZyb20gJy4vY2xpZW50JztcbmV4cG9ydCB7IFJhaWxob29rRXJyb3IgYXMgV2ViaG9va1BsYXRmb3JtRXJyb3IgfSBmcm9tICcuL2Vycm9ycyc7XG5leHBvcnQgeyB2ZXJpZnlTaWduYXR1cmUsIHZlcmlmeVN0YW5kYXJkV2ViaG9vaywgY29uc3RydWN0RXZlbnQsIGdlbmVyYXRlU2lnbmF0dXJlIH0gZnJvbSAnLi93ZWJob29rcyc7XG5leHBvcnQgdHlwZSB7IFdlYmhvb2tIZWFkZXJzLCBWZXJpZnlPcHRpb25zIH0gZnJvbSAnLi93ZWJob29rcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==