@webhook-platform/node 1.0.0

package/dist/client.js

@@ -0,0 +1,229 @@
+"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.WebhookPlatform = 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 = '1.0.0';
+class WebhookPlatform {
+    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);
+    }
+    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': `webhook-platform-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.WebhookPlatformError('Failed to parse response', 500));
+                    }
+                });
+            });
+            req.on('error', (err) => {
+                reject(new errors_1.WebhookPlatformError(err.message, 0, 'network_error'));
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new errors_1.WebhookPlatformError('Request timeout', 0, 'timeout'));
+            });
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
+    }
+    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, rateLimitInfo || { limit: 0, remaining: 0, reset: Date.now() + 60000 });
+            case 400:
+                return new errors_1.ValidationError(message, body.fieldErrors || {});
+            default:
+                return new errors_1.WebhookPlatformError(message, status, body.error);
+        }
+    }
+}
+exports.WebhookPlatform = WebhookPlatform;
+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}`);
+    }
+    async list(projectId) {
+        return this.client.request('GET', `/api/v1/projects/${projectId}/endpoints`);
+    }
+    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`);
+    }
+}
+//# 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  WebhookPlatformConfig,\n  Event,\n  EventResponse,\n  Endpoint,\n  EndpointCreateParams,\n  EndpointUpdateParams,\n  Subscription,\n  SubscriptionCreateParams,\n  Delivery,\n  DeliveryAttempt,\n  DeliveryListParams,\n  PaginatedResponse,\n  EndpointTestResult,\n  RateLimitInfo,\n} from './types';\nimport {\n  WebhookPlatformError,\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 = '1.0.0';\n\nexport class WebhookPlatform {\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\n  constructor(config: WebhookPlatformConfig) {\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  }\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': `webhook-platform-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 WebhookPlatformError('Failed to parse response', 500));\n          }\n        });\n      });\n\n      req.on('error', (err) => {\n        reject(new WebhookPlatformError(err.message, 0, 'network_error'));\n      });\n\n      req.on('timeout', () => {\n        req.destroy();\n        reject(new WebhookPlatformError('Request timeout', 0, 'timeout'));\n      });\n\n      if (body) {\n        req.write(JSON.stringify(body));\n      }\n\n      req.end();\n    });\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  ): WebhookPlatformError {\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          rateLimitInfo || { limit: 0, remaining: 0, reset: Date.now() + 60000 }\n        );\n      case 400:\n        return new ValidationError(\n          message,\n          (body.fieldErrors as Record<string, string>) || {}\n        );\n      default:\n        return new WebhookPlatformError(message, status, body.error as string);\n    }\n  }\n}\n\nclass Events {\n  constructor(private client: WebhookPlatform) {}\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: WebhookPlatform) {}\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  async list(projectId: string): Promise<Endpoint[]> {\n    return this.client.request<Endpoint[]>(\n      'GET',\n      `/api/v1/projects/${projectId}/endpoints`\n    );\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: WebhookPlatform) {}\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: WebhookPlatform) {}\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"]}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+import { RateLimitInfo } from './types';
+export declare class WebhookPlatformError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export declare class AuthenticationError extends WebhookPlatformError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends WebhookPlatformError {
+    readonly rateLimitInfo: RateLimitInfo;
+    constructor(message: string, rateLimitInfo: RateLimitInfo);
+    get retryAfter(): number;
+}
+export declare class ValidationError extends WebhookPlatformError {
+    readonly fieldErrors: Record<string, string>;
+    constructor(message: string, fieldErrors?: Record<string, string>);
+}
+export declare class NotFoundError extends WebhookPlatformError {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.ValidationError = exports.RateLimitError = exports.AuthenticationError = exports.WebhookPlatformError = void 0;
+class WebhookPlatformError extends Error {
+    constructor(message, status, code) {
+        super(message);
+        this.name = 'WebhookPlatformError';
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.WebhookPlatformError = WebhookPlatformError;
+class AuthenticationError extends WebhookPlatformError {
+    constructor(message = 'Invalid API key') {
+        super(message, 401, 'authentication_error');
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class RateLimitError extends WebhookPlatformError {
+    constructor(message, rateLimitInfo) {
+        super(message, 429, 'rate_limit_exceeded');
+        this.name = 'RateLimitError';
+        this.rateLimitInfo = rateLimitInfo;
+    }
+    get retryAfter() {
+        return Math.max(0, this.rateLimitInfo.reset - Date.now());
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ValidationError extends WebhookPlatformError {
+    constructor(message, fieldErrors = {}) {
+        super(message, 400, 'validation_error');
+        this.name = 'ValidationError';
+        this.fieldErrors = fieldErrors;
+    }
+}
+exports.ValidationError = ValidationError;
+class NotFoundError extends WebhookPlatformError {
+    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,4 @@
+export { WebhookPlatform } from './client';
+export { WebhookPlatformError, RateLimitError, AuthenticationError, ValidationError } from './errors';
+export { verifySignature, constructEvent } from './webhooks';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,29 @@
+"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.constructEvent = exports.verifySignature = exports.ValidationError = exports.AuthenticationError = exports.RateLimitError = exports.WebhookPlatformError = exports.WebhookPlatform = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "WebhookPlatform", { enumerable: true, get: function () { return client_1.WebhookPlatform; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "WebhookPlatformError", { enumerable: true, get: function () { return errors_1.WebhookPlatformError; } });
+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; } });
+var webhooks_1 = require("./webhooks");
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return webhooks_1.verifySignature; } });
+Object.defineProperty(exports, "constructEvent", { enumerable: true, get: function () { return webhooks_1.constructEvent; } });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtQ0FBMkM7QUFBbEMseUdBQUEsZUFBZSxPQUFBO0FBQ3hCLG1DQUFzRztBQUE3Riw4R0FBQSxvQkFBb0IsT0FBQTtBQUFFLHdHQUFBLGNBQWMsT0FBQTtBQUFFLDZHQUFBLG1CQUFtQixPQUFBO0FBQUUseUdBQUEsZUFBZSxPQUFBO0FBQ25GLHVDQUE2RDtBQUFwRCwyR0FBQSxlQUFlLE9BQUE7QUFBRSwwR0FBQSxjQUFjLE9BQUE7QUFDeEMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgV2ViaG9va1BsYXRmb3JtIH0gZnJvbSAnLi9jbGllbnQnO1xuZXhwb3J0IHsgV2ViaG9va1BsYXRmb3JtRXJyb3IsIFJhdGVMaW1pdEVycm9yLCBBdXRoZW50aWNhdGlvbkVycm9yLCBWYWxpZGF0aW9uRXJyb3IgfSBmcm9tICcuL2Vycm9ycyc7XG5leHBvcnQgeyB2ZXJpZnlTaWduYXR1cmUsIGNvbnN0cnVjdEV2ZW50IH0gZnJvbSAnLi93ZWJob29rcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+export interface WebhookPlatformConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export interface Event {
+    type: string;
+    data: Record<string, unknown>;
+}
+export interface EventResponse {
+    eventId: string;
+    type: string;
+    createdAt: string;
+    deliveriesCreated: number;
+}
+export interface Endpoint {
+    id: string;
+    url: string;
+    description?: string;
+    secret: string;
+    enabled: boolean;
+    rateLimitPerSecond?: number;
+    createdAt: string;
+}
+export interface EndpointCreateParams {
+    url: string;
+    description?: string;
+    enabled?: boolean;
+    rateLimitPerSecond?: number;
+}
+export interface EndpointUpdateParams {
+    url?: string;
+    description?: string;
+    enabled?: boolean;
+    rateLimitPerSecond?: number;
+}
+export interface Subscription {
+    id: string;
+    endpointId: string;
+    eventTypes: string[];
+    enabled: boolean;
+    createdAt: string;
+}
+export interface SubscriptionCreateParams {
+    endpointId: string;
+    eventTypes: string[];
+    enabled?: boolean;
+}
+export interface Delivery {
+    id: string;
+    eventId: string;
+    endpointId: string;
+    status: DeliveryStatus;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt?: string;
+    createdAt: string;
+    succeededAt?: string;
+}
+export type DeliveryStatus = 'PENDING' | 'SUCCESS' | 'FAILED' | 'DEAD_LETTER';
+export interface DeliveryAttempt {
+    id: string;
+    attemptNumber: number;
+    httpStatus?: number;
+    responseBody?: string;
+    errorMessage?: string;
+    latencyMs: number;
+    attemptedAt: string;
+}
+export interface PaginatedResponse<T> {
+    content: T[];
+    totalElements: number;
+    totalPages: number;
+    size: number;
+    number: number;
+}
+export interface DeliveryListParams {
+    status?: DeliveryStatus;
+    endpointId?: string;
+    fromDate?: string;
+    toDate?: string;
+    page?: number;
+    size?: number;
+}
+export interface EndpointTestResult {
+    success: boolean;
+    httpStatus?: number;
+    latencyMs: number;
+    errorMessage?: string;
+}
+export interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    reset: number;
+}
+export interface WebhookEvent {
+    eventId: string;
+    deliveryId: string;
+    timestamp: number;
+    type: string;
+    data: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/webhooks.d.ts

@@ -0,0 +1,38 @@
+import { WebhookEvent } from './types';
+export interface WebhookHeaders {
+    'x-signature'?: string;
+    'x-timestamp'?: string;
+    'x-event-id'?: string;
+    'x-delivery-id'?: string;
+    [key: string]: string | undefined;
+}
+export interface VerifyOptions {
+    tolerance?: number;
+}
+/**
+ * Verifies the webhook signature using HMAC-SHA256
+ * @param payload - Raw request body as string
+ * @param signature - X-Signature header value (format: t=timestamp,v1=signature)
+ * @param secret - Endpoint webhook secret
+ * @param options - Verification options
+ * @returns true if signature is valid
+ * @throws WebhookPlatformError if signature is invalid
+ */
+export declare function verifySignature(payload: string, signature: string, secret: string, options?: VerifyOptions): boolean;
+/**
+ * Constructs a webhook event from the request
+ * @param payload - Raw request body as string
+ * @param headers - Request headers
+ * @param secret - Endpoint webhook secret
+ * @param options - Verification options
+ * @returns Parsed and verified webhook event
+ */
+export declare function constructEvent(payload: string, headers: WebhookHeaders, secret: string, options?: VerifyOptions): WebhookEvent;
+/**
+ * Generates a signature for testing purposes
+ * @param payload - Request body as string
+ * @param secret - Webhook secret
+ * @param timestamp - Optional timestamp (defaults to now)
+ * @returns Signature string in format t=timestamp,v1=signature
+ */
+export declare function generateSignature(payload: string, secret: string, timestamp?: number): string;