@webhooks-cc/sdk 0.5.0 → 1.0.0

package/dist/testing.d.mts

@@ -0,0 +1,30 @@
+import { g as DiffResult, e as CreateEndpointOptions, R as Request, a0 as WebhooksCC, E as Endpoint } from './diff-Dn4j4B_n.mjs';
+
+type TestingClient = Pick<WebhooksCC, "endpoints" | "requests">;
+interface AssertRequestExpectation {
+    method?: string;
+    path?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    bodyJson?: Record<string, unknown>;
+}
+interface AssertRequestOptions {
+    ignoreHeaders?: string[];
+    throwOnFailure?: boolean;
+}
+interface AssertRequestResult {
+    pass: boolean;
+    diff: DiffResult;
+}
+interface CaptureDuringOptions extends CreateEndpointOptions {
+    timeout?: number | string;
+    pollInterval?: number | string;
+    count?: number;
+    match?: (request: Request) => boolean;
+}
+declare function withEndpoint<T>(client: TestingClient, callback: (endpoint: Endpoint) => Promise<T>, options?: CreateEndpointOptions): Promise<T>;
+declare function withEphemeralEndpoint<T>(client: TestingClient, callback: (endpoint: Endpoint) => Promise<T>, options?: Omit<CreateEndpointOptions, "ephemeral">): Promise<T>;
+declare function captureDuring(client: TestingClient, action: (endpoint: Endpoint) => Promise<unknown>, options?: CaptureDuringOptions): Promise<Request[]>;
+declare function assertRequest(request: Request, expected: AssertRequestExpectation, options?: AssertRequestOptions): AssertRequestResult;
+
+export { type AssertRequestExpectation, type AssertRequestOptions, type AssertRequestResult, type CaptureDuringOptions, assertRequest, captureDuring, withEndpoint, withEphemeralEndpoint };

package/dist/testing.d.ts

@@ -0,0 +1,30 @@
+import { g as DiffResult, e as CreateEndpointOptions, R as Request, a0 as WebhooksCC, E as Endpoint } from './diff-Dn4j4B_n.js';
+
+type TestingClient = Pick<WebhooksCC, "endpoints" | "requests">;
+interface AssertRequestExpectation {
+    method?: string;
+    path?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    bodyJson?: Record<string, unknown>;
+}
+interface AssertRequestOptions {
+    ignoreHeaders?: string[];
+    throwOnFailure?: boolean;
+}
+interface AssertRequestResult {
+    pass: boolean;
+    diff: DiffResult;
+}
+interface CaptureDuringOptions extends CreateEndpointOptions {
+    timeout?: number | string;
+    pollInterval?: number | string;
+    count?: number;
+    match?: (request: Request) => boolean;
+}
+declare function withEndpoint<T>(client: TestingClient, callback: (endpoint: Endpoint) => Promise<T>, options?: CreateEndpointOptions): Promise<T>;
+declare function withEphemeralEndpoint<T>(client: TestingClient, callback: (endpoint: Endpoint) => Promise<T>, options?: Omit<CreateEndpointOptions, "ephemeral">): Promise<T>;
+declare function captureDuring(client: TestingClient, action: (endpoint: Endpoint) => Promise<unknown>, options?: CaptureDuringOptions): Promise<Request[]>;
+declare function assertRequest(request: Request, expected: AssertRequestExpectation, options?: AssertRequestOptions): AssertRequestResult;
+
+export { type AssertRequestExpectation, type AssertRequestOptions, type AssertRequestResult, type CaptureDuringOptions, assertRequest, captureDuring, withEndpoint, withEphemeralEndpoint };

package/dist/testing.js

@@ -0,0 +1,360 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  assertRequest: () => assertRequest,
+  captureDuring: () => captureDuring,
+  withEndpoint: () => withEndpoint,
+  withEphemeralEndpoint: () => withEphemeralEndpoint
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/diff.ts
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonBody(body) {
+  if (body.length === 0) {
+    return { valid: false };
+  }
+  try {
+    return { valid: true, value: JSON.parse(body) };
+  } catch {
+    return { valid: false };
+  }
+}
+function areEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => areEqual(value, right[index]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => areEqual(left[key], right[key]));
+  }
+  return Number.isNaN(left) && Number.isNaN(right);
+}
+function compareJsonValues(left, right, path, changes) {
+  if (areEqual(left, right)) {
+    return;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index++) {
+      const nextPath = path ? `${path}.${index}` : String(index);
+      compareJsonValues(left[index], right[index], nextPath, changes);
+    }
+    return;
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].sort();
+    for (const key of keys) {
+      const nextPath = path ? `${path}.${key}` : key;
+      compareJsonValues(left[key], right[key], nextPath, changes);
+    }
+    return;
+  }
+  changes[path || "$"] = { left, right };
+}
+function formatJsonDiff(changes) {
+  return Object.entries(changes).map(
+    ([path, difference]) => `${path}: ${JSON.stringify(difference.left)} -> ${JSON.stringify(difference.right)}`
+  ).join("\n");
+}
+function formatTextDiff(left, right) {
+  const leftLines = left.split("\n");
+  const rightLines = right.split("\n");
+  const maxLength = Math.max(leftLines.length, rightLines.length);
+  const lines = [];
+  for (let index = 0; index < maxLength; index++) {
+    const leftLine = leftLines[index];
+    const rightLine = rightLines[index];
+    if (leftLine === rightLine) {
+      continue;
+    }
+    if (leftLine !== void 0) {
+      lines.push(`- ${leftLine}`);
+    }
+    if (rightLine !== void 0) {
+      lines.push(`+ ${rightLine}`);
+    }
+  }
+  return lines.join("\n");
+}
+function normalizeHeaders(headers, ignoredHeaders) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lowerKey = key.toLowerCase();
+    if (!ignoredHeaders.has(lowerKey)) {
+      normalized[lowerKey] = value;
+    }
+  }
+  return normalized;
+}
+function diffHeaders(leftHeaders, rightHeaders, options) {
+  const ignoredHeaders = new Set(
+    (options.ignoreHeaders ?? []).map((header) => header.toLowerCase())
+  );
+  const left = normalizeHeaders(leftHeaders, ignoredHeaders);
+  const right = normalizeHeaders(rightHeaders, ignoredHeaders);
+  const leftKeys = new Set(Object.keys(left));
+  const rightKeys = new Set(Object.keys(right));
+  const added = [...rightKeys].filter((key) => !leftKeys.has(key)).sort();
+  const removed = [...leftKeys].filter((key) => !rightKeys.has(key)).sort();
+  const changed = {};
+  for (const key of [...leftKeys].filter((header) => rightKeys.has(header)).sort()) {
+    if (left[key] !== right[key]) {
+      changed[key] = { left: left[key], right: right[key] };
+    }
+  }
+  if (added.length === 0 && removed.length === 0 && Object.keys(changed).length === 0) {
+    return void 0;
+  }
+  return { added, removed, changed };
+}
+function diffBodies(leftBody, rightBody) {
+  const left = leftBody ?? "";
+  const right = rightBody ?? "";
+  if (left === right) {
+    return void 0;
+  }
+  const leftJson = isJsonBody(left);
+  const rightJson = isJsonBody(right);
+  if (leftJson.valid && rightJson.valid) {
+    const changed = {};
+    compareJsonValues(leftJson.value, rightJson.value, "", changed);
+    if (Object.keys(changed).length === 0) {
+      return void 0;
+    }
+    return {
+      type: "json",
+      changed,
+      diff: formatJsonDiff(changed)
+    };
+  }
+  return {
+    type: "text",
+    diff: formatTextDiff(left, right)
+  };
+}
+function diffRequests(left, right, options = {}) {
+  const differences = {};
+  if (left.method !== right.method) {
+    differences.method = { left: left.method, right: right.method };
+  }
+  if (left.path !== right.path) {
+    differences.path = { left: left.path, right: right.path };
+  }
+  const headerDiff = diffHeaders(left.headers, right.headers, options);
+  if (headerDiff) {
+    differences.headers = headerDiff;
+  }
+  const bodyDiff = diffBodies(left.body, right.body);
+  if (bodyDiff) {
+    differences.body = bodyDiff;
+  }
+  return {
+    matches: Object.keys(differences).length === 0,
+    differences
+  };
+}
+
+// src/errors.ts
+var WebhooksCCError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "WebhooksCCError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotFoundError = class extends WebhooksCCError {
+  constructor(message = "Resource not found") {
+    super(404, message);
+    this.name = "NotFoundError";
+  }
+};
+var TimeoutError = class extends WebhooksCCError {
+  constructor(timeoutMs) {
+    super(0, `Request timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/utils.ts
+var DURATION_REGEX = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/;
+function parseDuration(input) {
+  if (typeof input === "number") {
+    if (!Number.isFinite(input) || input < 0) {
+      throw new Error(`Invalid duration: must be a finite non-negative number, got ${input}`);
+    }
+    return input;
+  }
+  const trimmed = input.trim();
+  const asNumber = Number(trimmed);
+  if (!isNaN(asNumber) && trimmed.length > 0) {
+    if (!Number.isFinite(asNumber) || asNumber < 0) {
+      throw new Error(`Invalid duration: must be a finite non-negative number, got "${input}"`);
+    }
+    return asNumber;
+  }
+  const match = DURATION_REGEX.exec(trimmed);
+  if (!match) {
+    throw new Error(`Invalid duration: "${input}"`);
+  }
+  const value = parseFloat(match[1]);
+  switch (match[2]) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 6e4;
+    case "h":
+      return value * 36e5;
+    case "d":
+      return value * 864e5;
+    default:
+      throw new Error(`Invalid duration: "${input}"`);
+  }
+}
+
+// src/testing.ts
+var MIN_CAPTURE_POLL_INTERVAL = 10;
+var DEFAULT_CAPTURE_LIMIT = 100;
+function isPlainObject2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeExpectedJson(actual, expected) {
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) {
+      return expected;
+    }
+    return expected.map((value, index) => mergeExpectedJson(actual[index], value));
+  }
+  if (isPlainObject2(expected)) {
+    const base = isPlainObject2(actual) ? { ...actual } : {};
+    for (const [key, value] of Object.entries(expected)) {
+      base[key] = mergeExpectedJson(base[key], value);
+    }
+    return base;
+  }
+  return expected;
+}
+function parseRequestJsonBody(body) {
+  if (!body) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+}
+function formatAssertionError(diff) {
+  return `Request assertion failed:
+${JSON.stringify(diff.differences, null, 2)}`;
+}
+async function cleanupEndpoint(client, slug) {
+  try {
+    await client.endpoints.delete(slug);
+  } catch (error) {
+    if (!(error instanceof NotFoundError)) {
+      throw error;
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withEndpoint(client, callback, options = {}) {
+  const endpoint = await client.endpoints.create(options);
+  try {
+    return await callback(endpoint);
+  } finally {
+    await cleanupEndpoint(client, endpoint.slug);
+  }
+}
+async function withEphemeralEndpoint(client, callback, options = {}) {
+  return withEndpoint(client, callback, {
+    ...options,
+    ephemeral: true
+  });
+}
+async function captureDuring(client, action, options = {}) {
+  const { timeout = 3e4, pollInterval = 200, count = 1, match, ...createOptions } = options;
+  const timeoutMs = parseDuration(timeout);
+  const pollIntervalMs = Math.max(MIN_CAPTURE_POLL_INTERVAL, parseDuration(pollInterval));
+  const expectedCount = Math.max(1, Math.floor(count));
+  const requestLimit = Math.max(DEFAULT_CAPTURE_LIMIT, expectedCount * 5);
+  return withEndpoint(
+    client,
+    async (endpoint) => {
+      const startedAt = Date.now();
+      await action(endpoint);
+      while (Date.now() - startedAt < timeoutMs) {
+        const requests = await client.requests.list(endpoint.slug, { limit: requestLimit });
+        const matched = (match ? requests.filter(match) : requests).slice().sort((left, right) => left.receivedAt - right.receivedAt);
+        if (matched.length >= expectedCount) {
+          return matched.slice(0, expectedCount);
+        }
+        await sleep(pollIntervalMs);
+      }
+      throw new TimeoutError(timeoutMs);
+    },
+    createOptions
+  );
+}
+function assertRequest(request, expected, options = {}) {
+  if (expected.body !== void 0 && expected.bodyJson !== void 0) {
+    throw new Error("assertRequest accepts either body or bodyJson, not both");
+  }
+  const comparable = {
+    ...request,
+    method: expected.method ?? request.method,
+    path: expected.path ?? request.path,
+    headers: expected.headers ? { ...request.headers, ...expected.headers } : request.headers
+  };
+  if (expected.body !== void 0) {
+    comparable.body = expected.body;
+  } else if (expected.bodyJson !== void 0) {
+    const actualJson = parseRequestJsonBody(request.body);
+    comparable.body = JSON.stringify(mergeExpectedJson(actualJson, expected.bodyJson));
+  }
+  const diff = diffRequests(request, comparable, {
+    ignoreHeaders: options.ignoreHeaders
+  });
+  const result = { pass: diff.matches, diff };
+  if (!result.pass && options.throwOnFailure) {
+    throw new Error(formatAssertionError(diff));
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertRequest,
+  captureDuring,
+  withEndpoint,
+  withEphemeralEndpoint
+});

package/dist/testing.mjs

@@ -0,0 +1,124 @@
+import {
+  NotFoundError,
+  TimeoutError,
+  diffRequests,
+  parseDuration
+} from "./chunk-7IMPSHQY.mjs";
+
+// src/testing.ts
+var MIN_CAPTURE_POLL_INTERVAL = 10;
+var DEFAULT_CAPTURE_LIMIT = 100;
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeExpectedJson(actual, expected) {
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) {
+      return expected;
+    }
+    return expected.map((value, index) => mergeExpectedJson(actual[index], value));
+  }
+  if (isPlainObject(expected)) {
+    const base = isPlainObject(actual) ? { ...actual } : {};
+    for (const [key, value] of Object.entries(expected)) {
+      base[key] = mergeExpectedJson(base[key], value);
+    }
+    return base;
+  }
+  return expected;
+}
+function parseRequestJsonBody(body) {
+  if (!body) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+}
+function formatAssertionError(diff) {
+  return `Request assertion failed:
+${JSON.stringify(diff.differences, null, 2)}`;
+}
+async function cleanupEndpoint(client, slug) {
+  try {
+    await client.endpoints.delete(slug);
+  } catch (error) {
+    if (!(error instanceof NotFoundError)) {
+      throw error;
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withEndpoint(client, callback, options = {}) {
+  const endpoint = await client.endpoints.create(options);
+  try {
+    return await callback(endpoint);
+  } finally {
+    await cleanupEndpoint(client, endpoint.slug);
+  }
+}
+async function withEphemeralEndpoint(client, callback, options = {}) {
+  return withEndpoint(client, callback, {
+    ...options,
+    ephemeral: true
+  });
+}
+async function captureDuring(client, action, options = {}) {
+  const { timeout = 3e4, pollInterval = 200, count = 1, match, ...createOptions } = options;
+  const timeoutMs = parseDuration(timeout);
+  const pollIntervalMs = Math.max(MIN_CAPTURE_POLL_INTERVAL, parseDuration(pollInterval));
+  const expectedCount = Math.max(1, Math.floor(count));
+  const requestLimit = Math.max(DEFAULT_CAPTURE_LIMIT, expectedCount * 5);
+  return withEndpoint(
+    client,
+    async (endpoint) => {
+      const startedAt = Date.now();
+      await action(endpoint);
+      while (Date.now() - startedAt < timeoutMs) {
+        const requests = await client.requests.list(endpoint.slug, { limit: requestLimit });
+        const matched = (match ? requests.filter(match) : requests).slice().sort((left, right) => left.receivedAt - right.receivedAt);
+        if (matched.length >= expectedCount) {
+          return matched.slice(0, expectedCount);
+        }
+        await sleep(pollIntervalMs);
+      }
+      throw new TimeoutError(timeoutMs);
+    },
+    createOptions
+  );
+}
+function assertRequest(request, expected, options = {}) {
+  if (expected.body !== void 0 && expected.bodyJson !== void 0) {
+    throw new Error("assertRequest accepts either body or bodyJson, not both");
+  }
+  const comparable = {
+    ...request,
+    method: expected.method ?? request.method,
+    path: expected.path ?? request.path,
+    headers: expected.headers ? { ...request.headers, ...expected.headers } : request.headers
+  };
+  if (expected.body !== void 0) {
+    comparable.body = expected.body;
+  } else if (expected.bodyJson !== void 0) {
+    const actualJson = parseRequestJsonBody(request.body);
+    comparable.body = JSON.stringify(mergeExpectedJson(actualJson, expected.bodyJson));
+  }
+  const diff = diffRequests(request, comparable, {
+    ignoreHeaders: options.ignoreHeaders
+  });
+  const result = { pass: diff.matches, diff };
+  if (!result.pass && options.throwOnFailure) {
+    throw new Error(formatAssertionError(diff));
+  }
+  return result;
+}
+export {
+  assertRequest,
+  captureDuring,
+  withEndpoint,
+  withEphemeralEndpoint
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webhooks-cc/sdk",
-  "version": "0.5.0",
+  "version": "1.0.0",
   "description": "TypeScript SDK for webhooks.cc — create endpoints, capture requests, assert in tests",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -10,6 +10,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.mjs",
+      "require": "./dist/testing.js"
     }
   },
   "files": [
@@ -34,11 +39,11 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.0.0"
+    "vitest": "^3.2.4"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "build": "tsup --config tsup.config.ts",
+    "dev": "tsup --config tsup.config.ts --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest"