@webhooks-cc/sdk 0.6.0 → 1.0.0

package/dist/chunk-7IMPSHQY.mjs

@@ -0,0 +1,236 @@
+// 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 UnauthorizedError = class extends WebhooksCCError {
+  constructor(message = "Invalid or missing API key") {
+    super(401, message);
+    this.name = "UnauthorizedError";
+  }
+};
+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";
+  }
+};
+var RateLimitError = class extends WebhooksCCError {
+  constructor(retryAfter) {
+    const message = retryAfter ? `Rate limited, retry after ${retryAfter}s` : "Rate limited";
+    super(429, message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+
+// 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/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
+  };
+}
+
+export {
+  WebhooksCCError,
+  UnauthorizedError,
+  NotFoundError,
+  TimeoutError,
+  RateLimitError,
+  parseDuration,
+  diffRequests
+};