@workoutx/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,573 @@
+// src/errors.ts
+var WorkoutXError = class extends Error {
+  constructor(args) {
+    super(args.message);
+    this.name = "WorkoutXError";
+    this.status = args.status;
+    this.path = args.path;
+    this.body = args.body;
+    this.code = args.code;
+    this.tip = args.tip;
+    this.docs = args.docs;
+  }
+  /** True for 429 (rate limit / quota). */
+  get isRateLimited() {
+    return this.status === 429;
+  }
+  /** True for 401/403 (auth/plan problems). */
+  get isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  /** True for 404. */
+  get isNotFound() {
+    return this.status === 404;
+  }
+};
+var WorkoutXConnectionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "WorkoutXConnectionError";
+    this.cause = cause;
+  }
+};
+
+// src/http.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(baseUrl.replace(/\/$/, "") + path);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+    }
+  }
+  return url.toString();
+}
+var HttpClient = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  async request(path, opts = {}) {
+    const method = opts.method ?? "GET";
+    const url = buildUrl(this.cfg.baseUrl, path, opts.query);
+    const headers = {
+      Accept: opts.raw ? "*/*" : "application/json",
+      ...this.cfg.defaultHeaders
+    };
+    if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+    if (opts.auth === "bearer") {
+      const token = await this.resolveBearer();
+      if (!token) {
+        throw new WorkoutXError({
+          status: 401,
+          path,
+          body: null,
+          code: "Unauthorized",
+          message: "Body-scan endpoints require authentication. Provide `scan.token` or `scan.email`/`scan.password` when constructing the client."
+        });
+      }
+      headers["Authorization"] = `Bearer ${token}`;
+    } else if (this.cfg.apiKey) {
+      headers["X-WorkoutX-Key"] = this.cfg.apiKey;
+    }
+    let lastErr;
+    for (let attempt = 0; attempt <= this.cfg.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.cfg.timeout);
+      const signal = opts.signal ? anySignal([opts.signal, controller.signal]) : controller.signal;
+      let res;
+      try {
+        res = await this.cfg.fetch(url, {
+          method,
+          headers,
+          body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+          signal
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        lastErr = err;
+        if (attempt < this.cfg.maxRetries) {
+          await sleep(backoffMs(attempt));
+          continue;
+        }
+        throw new WorkoutXConnectionError(
+          `Request to ${path} failed: ${err?.message ?? err}`,
+          err
+        );
+      }
+      clearTimeout(timer);
+      if ((res.status === 429 || res.status >= 500) && attempt < this.cfg.maxRetries) {
+        const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+        await sleep(retryAfter ?? backoffMs(attempt));
+        continue;
+      }
+      if (!res.ok) throw await toError(res, path);
+      if (opts.raw) return await res.arrayBuffer();
+      const text = await res.text();
+      if (!text) return void 0;
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    throw lastErr instanceof Error ? lastErr : new WorkoutXConnectionError(`Request to ${path} failed after retries.`);
+  }
+  async resolveBearer() {
+    if (!this.cfg.getBearer) return void 0;
+    const v = this.cfg.getBearer();
+    return v instanceof Promise ? await v : v;
+  }
+};
+function backoffMs(attempt) {
+  return Math.min(2e3, 250 * 2 ** attempt) + Math.random() * 100;
+}
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  const secs = Number(header);
+  if (!Number.isNaN(secs)) return secs * 1e3;
+  const date = Date.parse(header);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+async function toError(res, path) {
+  let body = null;
+  let parsed = {};
+  const text = await res.text().catch(() => "");
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+      body = parsed;
+    } catch {
+      body = text;
+    }
+  }
+  const message = parsed.message || parsed.error || `${res.status} ${res.statusText} for ${path}`;
+  return new WorkoutXError({
+    status: res.status,
+    path,
+    body,
+    message,
+    code: parsed.error,
+    tip: parsed.tip,
+    docs: parsed.docs
+  });
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const s of signals) {
+    if (s.aborted) {
+      controller.abort();
+      break;
+    }
+    s.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+  return controller.signal;
+}
+
+// src/resources/exercises.ts
+var ExercisesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List exercises (paginated). */
+  list(params = {}) {
+    return this.http.request("/v1/exercises", { query: { ...params } });
+  }
+  /**
+   * Look up a single exercise by its exact numeric ID (e.g. "0001").
+   *
+   * Note: IDs are not sequential — there are gaps. To resolve a human name
+   * like "lunges", use {@link byName} instead. See {@link find} for a helper
+   * that tries an ID first and falls back to a name search.
+   */
+  get(id) {
+    return this.http.request(`/v1/exercises/${encodeURIComponent(id)}`);
+  }
+  /** Find exercises whose name contains the given text. */
+  byName(name, params = {}) {
+    return this.http.request(`/v1/exercises/name/${encodeURIComponent(name)}`, {
+      query: { ...params }
+    });
+  }
+  /** Filter exercises by body part (e.g. "back"). */
+  byBodyPart(bodyPart, params = {}) {
+    return this.http.request(`/v1/exercises/bodyPart/${encodeURIComponent(bodyPart)}`, {
+      query: { ...params }
+    });
+  }
+  /** Filter exercises by target muscle (e.g. "abs"). */
+  byTarget(target, params = {}) {
+    return this.http.request(`/v1/exercises/target/${encodeURIComponent(target)}`, {
+      query: { ...params }
+    });
+  }
+  /** Filter exercises by equipment (e.g. "barbell"). */
+  byEquipment(equipment, params = {}) {
+    return this.http.request(`/v1/exercises/equipment/${encodeURIComponent(equipment)}`, {
+      query: { ...params }
+    });
+  }
+  /** Multi-filter search (plan-gated: requires the `multiFilter` feature). */
+  search(params = {}) {
+    return this.http.request("/v1/exercises/search", { query: { ...params } });
+  }
+  /** Exercises similar to the given exercise ID. */
+  similar(id, params = {}) {
+    return this.http.request(`/v1/exercises/${encodeURIComponent(id)}/similar`, {
+      query: { ...params }
+    });
+  }
+  /** Alternatives that hit the same target with different equipment. */
+  alternatives(id, params = {}) {
+    return this.http.request(`/v1/exercises/${encodeURIComponent(id)}/alternatives`, {
+      query: { ...params }
+    });
+  }
+  /** Estimated calories burned for an exercise. */
+  calories(id, params = {}) {
+    return this.http.request(`/v1/exercises/${encodeURIComponent(id)}/calories`, {
+      query: { ...params }
+    });
+  }
+  /** Dataset changelog (plan-gated: requires the `datasetSync` feature). */
+  changes(params = {}) {
+    return this.http.request("/v1/exercises/changes", { query: { ...params } });
+  }
+  /** List of all body parts. */
+  bodyPartList() {
+    return this.http.request("/v1/exercises/bodyPartList");
+  }
+  /** List of all target muscles. */
+  targetList() {
+    return this.http.request("/v1/exercises/targetList");
+  }
+  /** List of all equipment types. */
+  equipmentList() {
+    return this.http.request("/v1/exercises/equipmentList");
+  }
+  /** List of all secondary muscles. */
+  secondaryMuscleList() {
+    return this.http.request("/v1/exercises/secondaryMuscleList");
+  }
+  /**
+   * Convenience resolver: treat `idOrName` as an ID first, and if that 404s,
+   * fall back to a name search and return the first match. Saves callers from
+   * the common "/v1/exercises/lunges → 404" mistake.
+   *
+   * Returns `null` when neither an ID nor a name match is found.
+   */
+  async find(idOrName) {
+    try {
+      return await this.get(idOrName);
+    } catch (err) {
+      if (!(err instanceof WorkoutXError) || !err.isNotFound) throw err;
+    }
+    const matches = await this.byName(idOrName, { limit: 1 });
+    return matches[0] ?? null;
+  }
+};
+
+// src/resources/gifs.ts
+var GifsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Fetch an exercise GIF as raw bytes.
+   *
+   * Accepts both "0001" and "0001.gif". On the free plan the API serves a
+   * watermarked variant; paid plans get the original. Returns the binary
+   * payload — wrap it in `Blob`/`Buffer` as needed.
+   */
+  async get(filename) {
+    const name = /\.gif$/i.test(filename) ? filename : `${filename}.gif`;
+    return this.http.request(`/v1/gifs/${encodeURIComponent(name)}`, {
+      raw: true
+    });
+  }
+  /**
+   * Build the direct GIF URL (no request made). Useful for `<img src>`.
+   * The API key still needs to be supplied — by default via the `api-key`
+   * query param, which works for `<img>` tags that can't set headers.
+   */
+  url(filename, opts) {
+    const name = /\.gif$/i.test(filename) ? filename : `${filename}.gif`;
+    const u = new URL(`${opts.baseUrl.replace(/\/$/, "")}/v1/gifs/${encodeURIComponent(name)}`);
+    if (opts.apiKey) u.searchParams.set("api-key", opts.apiKey);
+    return u.toString();
+  }
+};
+
+// src/resources/workout.ts
+var WorkoutResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Generate a single workout (plan-gated: requires `workoutGenerator`). */
+  generate(params = {}) {
+    return this.http.request("/v1/workout/generate", { query: { ...params } });
+  }
+  /** Generate a multi-week program (plan-gated: requires `workoutPrograms`). */
+  program(params = {}) {
+    return this.http.request("/v1/workout/program", { query: { ...params } });
+  }
+};
+
+// src/resources/supplements.ts
+var SupplementsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List supplements (paginated). */
+  list(params = {}) {
+    return this.http.request("/v1/supplements", { query: { ...params } });
+  }
+  /** Available supplement filters. */
+  filters() {
+    return this.http.request("/v1/supplements/filters");
+  }
+  /** Build a recommended stack (plan-gated: requires `supplementStacks`). */
+  stack(params = {}) {
+    return this.http.request("/v1/supplements/stack", { query: { ...params } });
+  }
+  /** Supplements recommended for a given exercise. */
+  forExercise(exerciseId) {
+    return this.http.request(`/v1/supplements/exercise/${encodeURIComponent(exerciseId)}`);
+  }
+  /** Get a single supplement by ID. */
+  get(id) {
+    return this.http.request(`/v1/supplements/${encodeURIComponent(id)}`);
+  }
+};
+
+// src/resources/scan.ts
+var ScanResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Body-scan credit balance + usage stats for the current user. */
+  credits() {
+    return this.http.request("/v1/scan/credits", { auth: "bearer" });
+  }
+  /** Current user's body-scan profile. */
+  me() {
+    return this.http.request("/v1/scan/me", { auth: "bearer" });
+  }
+  /** Paginated scan history. */
+  history(params = {}) {
+    return this.http.request("/v1/scan/history", { auth: "bearer", query: { ...params } });
+  }
+  /** List the user's body-scan API keys. */
+  listKeys() {
+    return this.http.request("/v1/scan/keys", { auth: "bearer" });
+  }
+  /** Create a body-scan API key. */
+  createKey(name) {
+    return this.http.request("/v1/scan/keys", { auth: "bearer", method: "POST", body: { name } });
+  }
+  /** Delete a body-scan API key by ID. */
+  deleteKey(id) {
+    return this.http.request(`/v1/scan/keys/${encodeURIComponent(id)}`, {
+      auth: "bearer",
+      method: "DELETE"
+    });
+  }
+  /** Create a Stripe checkout session for a credit pack. */
+  checkout(body = {}) {
+    return this.http.request("/v1/scan/checkout", { auth: "bearer", method: "POST", body });
+  }
+  /** Public list of available credit packs (no auth required). */
+  packs() {
+    return this.http.request("/v1/scan/packs");
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(http, onLogin) {
+    this.http = http;
+    this.onLogin = onLogin;
+  }
+  /** Create a new account. Sends a verification email; no token is issued yet. */
+  register(params) {
+    return this.http.request("/v1/auth/register", { method: "POST", body: params });
+  }
+  /** Log in and receive a Bearer token (also used by `scan.*`). */
+  async login(email, password) {
+    const result = await this.http.request("/v1/auth/login", {
+      method: "POST",
+      body: { email, password }
+    });
+    this.onLogin?.(result.token);
+    return result;
+  }
+  /** Get the current user's profile. */
+  me() {
+    return this.http.request("/v1/auth/me", { auth: "bearer" });
+  }
+  /** Update the current user's display name. */
+  updateMe(name) {
+    return this.http.request("/v1/auth/me", { auth: "bearer", method: "PATCH", body: { name } });
+  }
+  /** Change the current user's password. */
+  changePassword(currentPassword, newPassword) {
+    return this.http.request("/v1/auth/change-password", {
+      auth: "bearer",
+      method: "POST",
+      body: { currentPassword, newPassword }
+    });
+  }
+  /** List the current user's API keys (exercises/gifs/workout/supplements product). */
+  listKeys() {
+    return this.http.request("/v1/auth/keys", { auth: "bearer" });
+  }
+  /** Create a new API key. */
+  createKey(name) {
+    return this.http.request("/v1/auth/keys", { auth: "bearer", method: "POST", body: { name } });
+  }
+  /** Delete an API key by ID. */
+  deleteKey(id) {
+    return this.http.request(`/v1/auth/keys/${encodeURIComponent(id)}`, {
+      auth: "bearer",
+      method: "DELETE"
+    });
+  }
+  /** Change the plan assigned to an API key. */
+  updateKeyPlan(id, planId) {
+    return this.http.request(`/v1/auth/keys/${encodeURIComponent(id)}/plan`, {
+      auth: "bearer",
+      method: "PATCH",
+      body: { planId }
+    });
+  }
+  /** Usage statistics for the current user (optionally filtered to one API key). */
+  usage(params = {}) {
+    return this.http.request("/v1/auth/usage", { auth: "bearer", query: { ...params } });
+  }
+  /** Request a password-reset email. Always succeeds (no email enumeration). */
+  forgotPassword(email) {
+    return this.http.request("/v1/auth/forgot-password", { method: "POST", body: { email } });
+  }
+  /** Complete a password reset using the token emailed by `forgotPassword`. */
+  resetPassword(token, password) {
+    return this.http.request("/v1/auth/reset-password", {
+      method: "POST",
+      body: { token, password }
+    });
+  }
+  /** Verify an email address using the token from the verification email. */
+  verifyEmail(token) {
+    return this.http.request("/v1/auth/verify-email", { query: { token } });
+  }
+  /** Resend the verification email. Always succeeds (no email enumeration). */
+  resendVerification(email) {
+    return this.http.request("/v1/auth/resend-verification", {
+      method: "POST",
+      body: { email }
+    });
+  }
+  /** Get the current user's registered webhook URL. */
+  getWebhook() {
+    return this.http.request("/v1/auth/webhook", { auth: "bearer" });
+  }
+  /** Set (or clear, with `null`) the webhook URL. */
+  setWebhook(webhookUrl) {
+    return this.http.request("/v1/auth/webhook", {
+      auth: "bearer",
+      method: "PATCH",
+      body: { webhookUrl }
+    });
+  }
+  /** Send a test event to the registered webhook URL. */
+  testWebhook() {
+    return this.http.request("/v1/auth/webhook/test", { auth: "bearer", method: "POST" });
+  }
+};
+
+// src/resources/billing.ts
+var BillingResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Current subscription status, plan, and renewal date for the logged-in user. */
+  status() {
+    return this.http.request("/v1/billing/status", { auth: "bearer" });
+  }
+  /** Create a Stripe Checkout session for upgrading to a paid plan. */
+  checkout(planId, billingCycle = "monthly") {
+    return this.http.request("/v1/billing/checkout", {
+      auth: "bearer",
+      method: "POST",
+      body: { planId, billingCycle }
+    });
+  }
+  /** Open the Stripe Customer Portal for the logged-in user to manage/cancel their subscription. */
+  portal() {
+    return this.http.request("/v1/billing/portal", { auth: "bearer", method: "POST" });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.workoutxapp.com";
+var WorkoutX = class {
+  constructor(opts = {}) {
+    const fetchImpl = opts.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new Error(
+        "No global fetch available. Use Node 18+ or pass a `fetch` implementation in options."
+      );
+    }
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.apiKey = opts.apiKey;
+    this.scanAuth = opts.scan;
+    if (opts.scan && "token" in opts.scan) this.cachedToken = opts.scan.token;
+    this.http = new HttpClient({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      getBearer: () => this.getBearerToken(),
+      timeout: opts.timeout ?? 3e4,
+      maxRetries: opts.maxRetries ?? 2,
+      defaultHeaders: { "User-Agent": "workoutx-sdk-js/0.1.0", ...opts.headers },
+      fetch: fetchImpl.bind(globalThis)
+    });
+    this.exercises = new ExercisesResource(this.http);
+    this.gifs = new GifsResource(this.http);
+    this.workout = new WorkoutResource(this.http);
+    this.supplements = new SupplementsResource(this.http);
+    this.scan = new ScanResource(this.http);
+    this.auth = new AuthResource(this.http, (token) => this.setScanToken(token));
+    this.billing = new BillingResource(this.http);
+  }
+  /** Build a direct GIF URL with the API key baked into the query string. */
+  gifUrl(filename) {
+    return this.gifs.url(filename, { baseUrl: this.baseUrl, apiKey: this.apiKey });
+  }
+  /** Manually set/replace the body-scan Bearer token. */
+  setScanToken(token) {
+    this.cachedToken = token;
+  }
+  /** Resolve a Bearer token, logging in with email/password if needed. */
+  async getBearerToken() {
+    if (this.cachedToken) return this.cachedToken;
+    if (!this.scanAuth || !("email" in this.scanAuth)) return void 0;
+    if (!this.loginInFlight) {
+      const creds = this.scanAuth;
+      this.loginInFlight = this.auth.login(creds.email, creds.password).then((res) => res.token).finally(() => {
+        this.loginInFlight = void 0;
+      });
+    }
+    return this.loginInFlight;
+  }
+};
+export {
+  AuthResource,
+  BillingResource,
+  DEFAULT_BASE_URL,
+  ExercisesResource,
+  GifsResource,
+  ScanResource,
+  SupplementsResource,
+  WorkoutResource,
+  WorkoutX,
+  WorkoutXConnectionError,
+  WorkoutXError
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@workoutx/sdk",
+  "version": "0.1.0",
+  "description": "Official TypeScript/JavaScript SDK for the WorkoutX API — exercises, GIFs, workouts, supplements, and body scan.",
+  "license": "MIT",
+  "author": "WorkoutX",
+  "homepage": "https://workoutxapp.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/furkanuruk/workoutxapi.git",
+    "directory": "sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/furkanuruk/workoutxapi/issues"
+  },
+  "keywords": [
+    "workoutx",
+    "fitness",
+    "exercise",
+    "exercisedb",
+    "workout",
+    "supplements",
+    "body-scan",
+    "api",
+    "sdk"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  }
+}