trackrev 0.1.0 → 0.3.0

package/src/sdk/client.js

@@ -0,0 +1,177 @@
+import { attribution } from "./resources/attribution.js";
+import { channels } from "./resources/channels.js";
+import { clicks } from "./resources/clicks.js";
+import { commissions } from "./resources/commissions.js";
+import { credits } from "./resources/credits.js";
+import { domains } from "./resources/domains.js";
+import { exportCsv } from "./resources/export.js";
+import { folders } from "./resources/folders.js";
+import { keys } from "./resources/keys.js";
+import { links } from "./resources/links.js";
+import { orders } from "./resources/orders.js";
+import { partners } from "./resources/partners.js";
+import { payouts } from "./resources/payouts.js";
+import { programs } from "./resources/programs.js";
+import { referrals } from "./resources/referrals.js";
+import { retargeting } from "./resources/retargeting.js";
+import { revenue } from "./resources/revenue.js";
+import { settings } from "./resources/settings.js";
+import { visitors } from "./resources/visitors.js";
+import { webhooks } from "./resources/webhooks.js";
+export const VERSION = "0.3.0";
+const DEFAULT_API_URL = "https://app.trackrev.io/api/v1";
+
+const RETRYABLE_POSTS = new Set([
+  "/referrals/enroll",
+  "/referrals/report-signup",
+  "/referrals/report-purchase"
+])
+
+const sleep = (ms) => new Promise ((resolve)=> setTimeout(resolve, ms))
+
+export class TrackRevError extends Error {
+  constructor({ status, code, message }) {
+    super(message);
+
+    this.name = "TrackRevError";
+    this.status = status;
+    this.code = code;
+  }
+}
+export class TrackRevConnectionError extends TrackRevError {
+  constructor(message) {
+    super({
+      status: 0,
+      code: "connection_error",
+      message
+    });
+
+    this.name = "TrackRevConnectionError";
+  }
+}
+
+export class TrackRev {
+  constructor(key, {
+    apiUrl = DEFAULT_API_URL,
+    timeoutMs=15000,
+    maxRetries=3
+  } = {}) {
+    this.key = key;
+    this.apiUrl = apiUrl;
+    this.timeoutMs = timeoutMs;
+    this.maxRetries = maxRetries;
+    // One way to reach the API, handed to every resource, so a resource
+    // file never touches fetch or the key itself.
+    const call = (method, path, options) => this.request(method, path, options);
+
+    this.attribution = attribution(call);
+    this.channels = channels(call);
+    this.clicks = clicks(call);
+    this.commissions = commissions(call);
+    this.credits = credits(call);
+    this.domains = domains(call);
+    this.export = exportCsv(call);
+    this.folders = folders(call);
+    this.keys = keys(call);
+    this.links = links(call);
+    this.orders = orders(call);
+    this.partners = partners(call);
+    this.payouts = payouts(call);
+    this.programs = programs(call);
+    this.referrals = referrals(call);
+    this.retargeting = retargeting(call);
+    this.revenue = revenue(call);
+    this.settings = settings(call);
+    this.visitors = visitors(call);
+    this.webhooks = webhooks(call);
+  }
+
+  // Who am I, and what can this key do.
+  me() {
+    return this.request("GET", "/me");
+  }
+
+ 
+async request(method, path, options) {
+  const bare = path.split("?")[0];
+
+  const safeToRepeat =
+    method === "GET" || RETRYABLE_POSTS.has(bare);
+
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await this.#send(method, path, options);
+    } catch (e) {
+      const mightWorkLater =
+        e instanceof TrackRevConnectionError ||
+        e.status === 429 ||
+        e.status >= 500;
+
+      if (
+        !safeToRepeat ||
+        !mightWorkLater ||
+        attempt >= this.maxRetries
+      ) {
+        throw e;
+      }
+
+      const waitMs =
+        e.retryAfterMs ??
+        400 * 2 ** attempt + Math.random() * 200;
+
+      await sleep(waitMs);
+    }
+  }
+}
+  async #send(method, path, { body } = {}) {       
+    const url = this.apiUrl + path;
+    const payload = body ? JSON.stringify(body) : undefined;
+    let response;
+    let text;
+    try {
+      response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.key}`,
+          "Content-Type": "application/json"
+        },
+        body: payload,
+        signal: this.timeoutMs > 0 ? AbortSignal.timeout(this.timeoutMs): undefined
+      });
+      text= await response.text();
+    } catch (e) {
+      // fetch itself failed — server unreachable, DNS error. No response exists, timeout
+      if(e.name === 'TimeoutError'){
+        throw new TrackRevConnectionError(`Request timed out after ${this.timeoutMs}ms`);
+      }
+      throw new TrackRevConnectionError(e.message || "Network error");
+    }
+
+    // The API sends { error: { code, message } }, but never assume the
+    // body parses — a proxy in front of it can send HTML or nothing.
+    let data = text;
+    if(response.headers.get("Content-Type")?.includes("application/json")){
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = null;  
+      }
+    }
+   
+
+    if (!response.ok) {
+      const err =  new TrackRevError({
+        status: response.status,
+        code: data?.error?.code ?? "unknown_error",
+        message: data?.error?.message ?? `HTTP ${response.status}`
+      });
+      const retryAfter = Number(response.headers.get('Retry-After'));
+      if(retryAfter>0){
+        err.retryAfterMs = retryAfter * 1000;
+      }
+      throw err;
+    }
+
+    return data;
+  }
+}