swapped-commerce-sdk 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,340 @@
+// src/utils/errors.ts
+class SwappedError extends Error {
+  statusCode;
+  code;
+  details;
+  constructor(message, statusCode, code, details) {
+    super(message);
+    this.name = "SwappedError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, SwappedError);
+    }
+  }
+}
+
+class SwappedAuthenticationError extends SwappedError {
+  constructor(message = "Authentication failed") {
+    super(message, 401, "AUTHENTICATION_ERROR");
+    this.name = "SwappedAuthenticationError";
+  }
+}
+
+class SwappedValidationError extends SwappedError {
+  constructor(message, details) {
+    super(message, 400, "VALIDATION_ERROR", details);
+    this.name = "SwappedValidationError";
+  }
+}
+
+class SwappedRateLimitError extends SwappedError {
+  constructor(message = "Rate limit exceeded") {
+    super(message, 429, "RATE_LIMIT_ERROR");
+    this.name = "SwappedRateLimitError";
+  }
+}
+
+class SwappedNotFoundError extends SwappedError {
+  constructor(resource) {
+    super(`${resource} not found`, 404, "NOT_FOUND_ERROR");
+    this.name = "SwappedNotFoundError";
+  }
+}
+function createAuthenticationError(message) {
+  return new SwappedAuthenticationError(message);
+}
+function createValidationError(message, details) {
+  return new SwappedValidationError(message, details);
+}
+function createRateLimitError(message) {
+  return new SwappedRateLimitError(message);
+}
+function createNotFoundError(resource) {
+  return new SwappedNotFoundError(resource);
+}
+
+// src/utils/retry.ts
+async function withRetry(fn, config) {
+  let lastError;
+  for (let attempt = 0;attempt <= config.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (error instanceof SwappedError && error.statusCode !== undefined && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+        throw error;
+      }
+      if (attempt < config.maxRetries) {
+        const delayMs = Math.pow(2, attempt) * 1000;
+        await delay(delayMs);
+      }
+    }
+  }
+  throw lastError ?? new Error("Request failed after retries");
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/http.ts
+var BASE_URL = "https://pay-api.swapped.com";
+function buildUrl(baseUrl, path, params) {
+  const url = new URL(path, baseUrl);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined && value !== null) {
+        url.searchParams.append(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function createRequestConfig(config, method, path, body) {
+  const headers = {
+    "X-API-Key": config.apiKey,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  const requestInit = {
+    method,
+    headers
+  };
+  if (body !== undefined) {
+    requestInit.body = JSON.stringify(body);
+  }
+  return requestInit;
+}
+async function handleErrorResponse(response) {
+  let errorData = {};
+  try {
+    const text = await response.text();
+    if (text) {
+      errorData = JSON.parse(text);
+    }
+  } catch {}
+  const message = errorData.message ?? response.statusText;
+  switch (response.status) {
+    case 401:
+      return new SwappedAuthenticationError(message);
+    case 400:
+      return new SwappedValidationError(message, errorData.details);
+    case 404:
+      return new SwappedNotFoundError(message);
+    case 429:
+      return new SwappedRateLimitError(message);
+    default:
+      return new SwappedError(message, response.status, errorData.code, errorData.details);
+  }
+}
+async function request(config, method, path, options) {
+  const url = buildUrl(BASE_URL, path, options?.params);
+  const requestConfig = createRequestConfig(config, method, path, options?.body);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, config.timeout);
+  try {
+    const response = await withRetry(async () => {
+      const res = await fetch(url, {
+        ...requestConfig,
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw await handleErrorResponse(res);
+      }
+      return res;
+    }, {
+      maxRetries: config.retries,
+      timeout: config.timeout
+    });
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof SwappedError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new SwappedError(`Request timeout after ${config.timeout}ms`, 408, "TIMEOUT_ERROR");
+    }
+    throw new SwappedError(error instanceof Error ? error.message : "Network error occurred", 0, "NETWORK_ERROR");
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/resources/orders.ts
+async function listOrders(httpConfig, params) {
+  return request(httpConfig.config, "GET", "/v1/merchants/orders", {
+    params
+  });
+}
+async function getOrder(httpConfig, orderId) {
+  return request(httpConfig.config, "GET", `/v1/merchants/orders/${encodeURIComponent(orderId)}`);
+}
+async function refundOrder(httpConfig, orderId, params) {
+  return request(httpConfig.config, "POST", `/v1/merchants/orders/${encodeURIComponent(orderId)}/refund`, {
+    body: params
+  });
+}
+
+// src/resources/paymentLinks.ts
+async function createPaymentLink(httpConfig, params) {
+  return request(httpConfig.config, "POST", "/v1/orders", {
+    body: params
+  });
+}
+
+// src/resources/paymentRoutes.ts
+async function createPaymentRoute(httpConfig, params) {
+  return request(httpConfig.config, "POST", "/v1/merchants/payment-routes", {
+    body: params
+  });
+}
+
+// src/resources/payments.ts
+async function getPayment(httpConfig, paymentId) {
+  return request(httpConfig.config, "GET", `/v1/merchants/payments/${encodeURIComponent(paymentId)}`);
+}
+
+// src/resources/balances.ts
+async function listBalances(httpConfig, params) {
+  return request(httpConfig.config, "GET", "/v1/merchants/balances", {
+    params
+  });
+}
+async function getBalance(httpConfig, currencyId) {
+  return request(httpConfig.config, "GET", `/v1/merchants/balances/${encodeURIComponent(currencyId)}`);
+}
+
+// src/resources/quotes.ts
+async function getQuote(httpConfig, params) {
+  return request(httpConfig.config, "POST", "/v1/merchants/quotes", {
+    body: params
+  });
+}
+
+// src/resources/payouts.ts
+async function createPayout(httpConfig, params) {
+  return request(httpConfig.config, "POST", "/v1/merchants/payouts", {
+    body: params
+  });
+}
+async function listPayouts(httpConfig, params) {
+  return request(httpConfig.config, "GET", "/v1/merchants/payouts", {
+    params
+  });
+}
+async function getPayout(httpConfig, payoutId) {
+  return request(httpConfig.config, "GET", `/v1/merchants/payouts/${encodeURIComponent(payoutId)}`);
+}
+
+// src/resources/kyc.ts
+async function getKYCStatus(httpConfig, customerId) {
+  return request(httpConfig.config, "GET", `/v1/merchants/kyc/${encodeURIComponent(customerId)}`);
+}
+async function submitKYC(httpConfig, params) {
+  return request(httpConfig.config, "POST", "/v1/merchants/kyc", {
+    body: params
+  });
+}
+
+// src/utils/webhooks.ts
+async function verifyWebhookSignature(payload, signature, secret) {
+  try {
+    const encoder = new TextEncoder;
+    const keyData = encoder.encode(secret);
+    const key = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const payloadData = encoder.encode(payload);
+    const signatureBuffer = await crypto.subtle.sign("HMAC", key, payloadData);
+    const signatureArray = Array.from(new Uint8Array(signatureBuffer));
+    const expectedSignature = signatureArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    return constantTimeEqual(expectedSignature, signature);
+  } catch {
+    return false;
+  }
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0;i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+function parseWebhookEvent(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch (error) {
+    throw new Error(`Failed to parse webhook payload: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/client/createClient.ts
+var DEFAULT_CONFIG = {
+  environment: "production",
+  timeout: 30000,
+  retries: 3
+};
+var BASE_URL2 = "https://pay-api.swapped.com";
+function createClient(config) {
+  const requiredConfig = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  const httpConfig = {
+    config: requiredConfig,
+    baseUrl: BASE_URL2
+  };
+  return {
+    orders: {
+      list: (params) => listOrders(httpConfig, params),
+      get: (orderId) => getOrder(httpConfig, orderId),
+      refund: (orderId, params) => refundOrder(httpConfig, orderId, params)
+    },
+    paymentLinks: {
+      create: (params) => createPaymentLink(httpConfig, params)
+    },
+    paymentRoutes: {
+      create: (params) => createPaymentRoute(httpConfig, params)
+    },
+    payments: {
+      get: (paymentId) => getPayment(httpConfig, paymentId)
+    },
+    balances: {
+      list: (params) => listBalances(httpConfig, params),
+      get: (currencyId) => getBalance(httpConfig, currencyId)
+    },
+    quotes: {
+      get: (params) => getQuote(httpConfig, params)
+    },
+    payouts: {
+      create: (params) => createPayout(httpConfig, params),
+      list: (params) => listPayouts(httpConfig, params),
+      get: (payoutId) => getPayout(httpConfig, payoutId)
+    },
+    kyc: {
+      getStatus: (customerId) => getKYCStatus(httpConfig, customerId),
+      submit: (params) => submitKYC(httpConfig, params)
+    },
+    verifyWebhookSignature,
+    parseWebhookEvent
+  };
+}
+export {
+  verifyWebhookSignature,
+  parseWebhookEvent,
+  createValidationError,
+  createRateLimitError,
+  createNotFoundError,
+  createClient,
+  createAuthenticationError,
+  SwappedValidationError,
+  SwappedRateLimitError,
+  SwappedNotFoundError,
+  SwappedError,
+  SwappedAuthenticationError
+};

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "swapped-commerce-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "TypeScript SDK for Swapped Commerce Integration API - Functional, performant, and fully typed",
   "type": "module",
-  "main": "src/index.ts",
-  "module": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./src/index.ts",
   "exports": {
     ".": {
       "types": "./src/index.ts",
-      "import": "./src/index.ts",
-      "default": "./src/index.ts"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm",
+    "build:dev": "bun build src/index.ts --outdir dist --target node --format esm",
+    "prepublishOnly": "bun run build",
     "test": "bun test",
     "test:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
@@ -50,6 +52,7 @@
     "typescript": "^5"
   },
   "files": [
+    "dist",
     "src",
     "README.md",
     "LICENSE"