suunto-api-wrapper 1.0.0

package/dist/index.js

@@ -0,0 +1,414 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_USER_AGENT: () => DEFAULT_USER_AGENT,
+  GearResource: () => GearResource,
+  HttpClient: () => HttpClient,
+  HttpError: () => HttpError,
+  SPORTS_TRACKER_API: () => SPORTS_TRACKER_API,
+  SuuntoClient: () => SuuntoClient,
+  UsersResource: () => UsersResource,
+  WorkoutsResource: () => WorkoutsResource,
+  generateXtotp: () => generateXtotp,
+  getLatestGear: () => getLatestGear,
+  getOwnWorkouts: () => getOwnWorkouts,
+  getUserByName: () => getUserByName,
+  getWorkouts: () => getWorkouts,
+  login: () => login,
+  searchUsers: () => searchUsers,
+  secondsUntilRollover: () => secondsUntilRollover,
+  sessionTokenFrom: () => sessionTokenFrom
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http/types.ts
+var HttpError = class extends Error {
+  constructor(message, init) {
+    super(message);
+    this.name = "HttpError";
+    this.status = init.status;
+    this.url = init.url;
+    this.method = init.method;
+    this.body = init.body;
+  }
+};
+
+// src/http/index.ts
+var DEFAULTS = {
+  timeoutMs: 3e4,
+  retries: 2,
+  retryBackoffMs: 300
+};
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]);
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var HttpClient = class {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl?.replace(/\/+$/, "") ?? "";
+    this.defaultHeaders = options.headers ?? {};
+    this.timeoutMs = options.timeoutMs ?? DEFAULTS.timeoutMs;
+    this.retries = options.retries ?? DEFAULTS.retries;
+    this.retryBackoffMs = options.retryBackoffMs ?? DEFAULTS.retryBackoffMs;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.beforeRequest = options.beforeRequest;
+    if (typeof this.fetchImpl !== "function") {
+      throw new TypeError(
+        "No fetch implementation available. Use Node 18+ or pass `fetch` in options."
+      );
+    }
+  }
+  get(path, options) {
+    return this.request("GET", path, options);
+  }
+  delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  post(path, options) {
+    return this.request("POST", path, options);
+  }
+  put(path, options) {
+    return this.request("PUT", path, options);
+  }
+  patch(path, options) {
+    return this.request("PATCH", path, options);
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const maxAttempts = (options.retries ?? this.retries) + 1;
+    const retryable = IDEMPOTENT_METHODS.has(method.toUpperCase());
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const response = await this.attempt(method, url, options);
+        if (!response.ok && retryable && RETRYABLE_STATUS.has(response.status) && attempt < maxAttempts - 1) {
+          await sleep(this.backoff(attempt, response.headers));
+          continue;
+        }
+        return await this.toResult(response, method, url);
+      } catch (err) {
+        lastError = err;
+        if (isAbortError(err) && options.signal?.aborted) throw err;
+        if (!retryable || attempt >= maxAttempts - 1) throw err;
+        await sleep(this.backoff(attempt));
+      }
+    }
+    throw lastError;
+  }
+  async attempt(method, url, options) {
+    const headers = {
+      ...this.defaultHeaders,
+      ...options.headers
+    };
+    let body = options.body;
+    if (body == null && options.json !== void 0) {
+      body = JSON.stringify(options.json);
+      headers["content-type"] ?? (headers["content-type"] = "application/json");
+    }
+    if (!("accept" in headers)) headers["accept"] = "application/json";
+    const ctx = { method, url, headers, body };
+    if (this.beforeRequest) {
+      const next = await this.beforeRequest(ctx);
+      if (next) Object.assign(ctx, next);
+    }
+    const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+    const signal = mergeSignals(options.signal, timeoutMs);
+    return this.fetchImpl(ctx.url, {
+      method: ctx.method,
+      headers: ctx.headers,
+      body: ctx.body,
+      signal
+    });
+  }
+  async toResult(response, method, url) {
+    const data = await parseBody(response);
+    if (!response.ok) {
+      throw new HttpError(
+        `${method} ${url} failed with status ${response.status}`,
+        { status: response.status, url, method, body: data }
+      );
+    }
+    return { data, status: response.status, headers: response.headers };
+  }
+  backoff(attempt, headers) {
+    const retryAfter = headers?.get("retry-after");
+    if (retryAfter) {
+      const seconds = Number(retryAfter);
+      if (Number.isFinite(seconds)) return seconds * 1e3;
+    }
+    const jitter = Math.random() * this.retryBackoffMs;
+    return this.retryBackoffMs * 2 ** attempt + jitter;
+  }
+  buildUrl(path, query) {
+    const suffixedPath = path.startsWith("/") ? path : `/${path}`;
+    const base = /^https?:\/\//i.test(path) ? path : `${this.baseUrl}${suffixedPath}`;
+    if (!query) return base;
+    const url = new URL(base);
+    for (const [key, value] of Object.entries(query)) {
+      if (value == null) continue;
+      const values = Array.isArray(value) ? value : [value];
+      for (const v of values) {
+        if (v != null) url.searchParams.append(key, String(v));
+      }
+    }
+    return url.toString();
+  }
+};
+async function parseBody(response) {
+  if (response.status === 204 || response.status === 205) return void 0;
+  const contentType = response.headers.get("content-type") ?? "";
+  const text = await response.text();
+  if (!text) return void 0;
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return text;
+}
+function mergeSignals(userSignal, timeoutMs) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (!userSignal) return timeoutSignal;
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([userSignal, timeoutSignal]);
+  }
+  return userSignal;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+
+// src/otp/index.ts
+var import_node_crypto = __toESM(require("crypto"));
+var PART1 = "FBkubDYmN28bWVQLLTsWWhI+NAtILCNlPQc5Y";
+var PART2 = "BgiMRYjKA99Jj4HHFIqLmomOFttBQchNzcZU0QrODcDWz4hekc1QGNTPlciNhEKGl5GPDkzFyVX";
+var XOR_KEY = Buffer.from("Bh8nsTyCeC0Ql2drMen78awk84AE3ZxW");
+var RAW = Buffer.from(PART1 + PART2, "base64");
+var SHARED = Buffer.from(
+  RAW.map((b, i) => b ^ XOR_KEY[i % XOR_KEY.length])
+);
+var PBKDF2_ITERATIONS = 100;
+var PBKDF2_KEY_LENGTH = 32;
+var TOTP_PERIOD_MS = 3e4;
+var TOTP_DIGITS = 6;
+function generateXtotp(email, now = Date.now()) {
+  const key = import_node_crypto.default.pbkdf2Sync(
+    SHARED,
+    Buffer.from(email, "utf8"),
+    PBKDF2_ITERATIONS,
+    PBKDF2_KEY_LENGTH,
+    "sha1"
+  );
+  const counter = BigInt(Math.floor(now / TOTP_PERIOD_MS));
+  const msg = Buffer.allocUnsafe(8);
+  msg.writeBigUInt64BE(counter);
+  const mac = import_node_crypto.default.createHmac("sha1", key).update(msg).digest();
+  const offset = mac[mac.length - 1] & 15;
+  const binary = mac.readUInt32BE(offset) & 2147483647;
+  const code = binary % 10 ** TOTP_DIGITS;
+  return code.toString().padStart(TOTP_DIGITS, "0");
+}
+function secondsUntilRollover(now = Date.now()) {
+  const periodSeconds = TOTP_PERIOD_MS / 1e3;
+  return periodSeconds - Math.floor(now / 1e3) % periodSeconds;
+}
+
+// src/auth/index.ts
+var SPORTS_TRACKER_API = "https://api.sports-tracker.com";
+var DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36";
+async function login(options) {
+  const {
+    email,
+    password,
+    version = "2",
+    userAgent = DEFAULT_USER_AGENT,
+    baseUrl = SPORTS_TRACKER_API,
+    fetch: fetchImpl,
+    timeoutMs
+  } = options;
+  const http = new HttpClient({ baseUrl, fetch: fetchImpl, timeoutMs });
+  const body = new URLSearchParams({ l: email, p: password, version });
+  const response = await http.post("/apiserver/v1/login2", {
+    body,
+    headers: {
+      "user-agent": userAgent,
+      "x-totp": generateXtotp(email),
+      "content-type": "application/x-www-form-urlencoded"
+    }
+  });
+  return response.data;
+}
+function sessionTokenFrom(response) {
+  return response.sessionkey;
+}
+
+// src/workouts/index.ts
+async function getWorkouts(client, username, params = {}) {
+  const { limit = 40, sortonst = true } = params;
+  const res = await client.get(
+    `/apiserver/v1/workouts/${encodeURIComponent(username)}/public`,
+    { query: { limit, sortonst } }
+  );
+  return res.data;
+}
+async function getOwnWorkouts(client, params = {}) {
+  const { offset = 0, limit = 50, since = 0 } = params;
+  const searchParams = new URLSearchParams();
+  searchParams.append("offset", String(offset));
+  searchParams.append("limit", String(limit));
+  searchParams.append("since", String(since));
+  const res = await client.get(
+    `/apiserver/v1/workouts?${searchParams.toString()}`
+  );
+  return res.data;
+}
+var WorkoutsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** The authenticated user's own workouts. */
+  own(params) {
+    return getOwnWorkouts(this.client, params);
+  }
+  /** A given user's public workouts. */
+  public(username, params) {
+    return getWorkouts(this.client, username, params);
+  }
+};
+
+// src/users/index.ts
+async function getUserByName(client, username) {
+  const res = await client.get(
+    `/apiserver/v1/user/name/${encodeURIComponent(username)}`
+  );
+  return res.data;
+}
+async function searchUsers(client, searchTerms) {
+  const res = await client.get(
+    `/apiserver/v1/user/search/${encodeURIComponent(searchTerms)}`
+  );
+  return res.data;
+}
+var UsersResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** A user's public profile, by username. */
+  byName(username) {
+    return getUserByName(this.client, username);
+  }
+  /** Search for users by name/username. */
+  search(searchTerms) {
+    return searchUsers(this.client, searchTerms);
+  }
+};
+
+// src/gear/index.ts
+async function getLatestGear(client, username, params = {}) {
+  const { allTypes = true } = params;
+  const res = await client.get(
+    `/apiserver/v1/gear/${encodeURIComponent(username)}/latest`,
+    { query: { allTypes } }
+  );
+  return res.data;
+}
+var GearResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** A user's latest (?) gear. */
+  latest(username, params) {
+    return getLatestGear(this.client, username, params);
+  }
+};
+
+// src/client.ts
+var SuuntoClient = class _SuuntoClient {
+  constructor(options) {
+    const {
+      email,
+      sessionKey,
+      userAgent = DEFAULT_USER_AGENT,
+      baseUrl,
+      headers,
+      ...rest
+    } = options;
+    this.sessionKey = sessionKey;
+    this.http = new HttpClient({
+      baseUrl: baseUrl ?? SPORTS_TRACKER_API,
+      headers: { "user-agent": userAgent, ...headers },
+      ...rest,
+      beforeRequest: (ctx) => {
+        if (email) ctx.headers["x-totp"] = generateXtotp(email);
+        if (sessionKey) ctx.headers["sttauthorization"] = sessionKey;
+      }
+    });
+    this.workouts = new WorkoutsResource(this.http);
+    this.users = new UsersResource(this.http);
+    this.gear = new GearResource(this.http);
+  }
+  /** Log in with email/password and return an authenticated client. */
+  static async login(options) {
+    const session = await login(options);
+    const sessionKey = sessionTokenFrom(session);
+    const { password: _password, version: _version, ...clientOptions } = options;
+    return new _SuuntoClient({ ...clientOptions, sessionKey });
+  }
+  /**
+   * Create a client with no credentials, for unauthenticated endpoints only
+   * (e.g. {@link UsersResource.byName}). No `x-totp` or session header is sent.
+   */
+  static unauthenticated(options = {}) {
+    return new _SuuntoClient(options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_USER_AGENT,
+  GearResource,
+  HttpClient,
+  HttpError,
+  SPORTS_TRACKER_API,
+  SuuntoClient,
+  UsersResource,
+  WorkoutsResource,
+  generateXtotp,
+  getLatestGear,
+  getOwnWorkouts,
+  getUserByName,
+  getWorkouts,
+  login,
+  searchUsers,
+  secondsUntilRollover,
+  sessionTokenFrom
+});