@fytkit/sdk 3.4.0 → 4.0.0

package/dist/index.js

@@ -1,6 +1,30 @@
-import { createORPCClient, ORPCError } from '@orpc/client';
+import { ORPCError, isORPCErrorJson, createORPCErrorFromJson, createORPCClient } from '@orpc/client';
 import { RPCLink } from '@orpc/client/fetch';
 
+// src/error.ts
+
+// src/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/refusal.ts
+function refusalData(error, reason) {
+  if (!isRecord(error) || typeof error.kind !== "string") return null;
+  const refusal = error.refusal;
+  if (!isRecord(refusal) || refusal.reason !== reason || !isRecord(refusal.data)) return null;
+  return refusal.data;
+}
+var MEMBER_CAP_QUOTA = "max_clients";
+function pickRefusal(data) {
+  if (!isRecord(data)) return {};
+  const { reason, ...rest } = data;
+  if (typeof reason === "string" && reason.length > 0) return { refusal: { reason, data: rest } };
+  if (data.quotaCode === MEMBER_CAP_QUOTA)
+    return { refusal: { reason: MEMBER_CAP_QUOTA, data: {} } };
+  return {};
+}
+
 // src/error.ts
 function pickIssues(data) {
   if (!data || typeof data !== "object") return null;
@@ -31,7 +55,8 @@ function normalizeError(err) {
         return {
           kind: "forbidden",
           reason: message || "Forbidden",
-          ...pickStringField(data, "code")
+          ...pickStringField(data, "code"),
+          ...pickRefusal(data)
         };
       case "PAYMENT_REQUIRED":
         return { kind: "payment_required", message: message || "Payment Required" };
@@ -39,25 +64,60 @@ function normalizeError(err) {
         return {
           kind: "conflict",
           message: message || "Conflict",
-          ...pickStringField(data, "enrollmentId")
+          ...pickStringField(data, "enrollmentId"),
+          ...pickRefusal(data)
         };
       case "NOT_FOUND":
-        return { kind: "not_found" };
+        return { kind: "not_found", ...pickRefusal(data) };
       case "TOO_MANY_REQUESTS":
-        return { kind: "rate_limited", retryAfter: pickRetryAfter(data) };
+        return { kind: "rate_limited", retryAfter: pickRetryAfter(data), ...pickRefusal(data) };
       case "BAD_REQUEST":
       case "UNPROCESSABLE_CONTENT": {
         const issues = pickIssues(data);
-        if (issues) return { kind: "validation", issues };
-        return { kind: "server", status, message, ...pickStringField(data, "code") };
+        if (issues) return { kind: "validation", issues, ...pickRefusal(data) };
+        return {
+          kind: "server",
+          status,
+          message,
+          ...pickStringField(data, "code"),
+          ...pickRefusal(data)
+        };
       }
       default:
-        return { kind: "server", status, message, ...pickStringField(data, "code") };
+        return {
+          kind: "server",
+          status,
+          message,
+          ...pickStringField(data, "code"),
+          ...pickRefusal(data)
+        };
     }
   }
   return { kind: "server", status: 0 };
 }
 
+// src/app.ts
+var UNEXPECTED_NOT_MODIFIED = { kind: "server", status: 304 };
+function createAppNamespace(transport) {
+  const bootstrap = async (options = {}) => {
+    const etag = options.etag ?? null;
+    let output;
+    try {
+      output = await transport.client.app.bootstrap(void 0, {
+        context: etag === null ? {} : { ifNoneMatch: etag }
+      });
+    } catch (error) {
+      throw normalizeError(error);
+    }
+    if (output === void 0 || output === null) {
+      if (etag === null) throw UNEXPECTED_NOT_MODIFIED;
+      return { status: "unchanged", etag };
+    }
+    return { status: "ok", data: output.data, etag: output.meta.etag };
+  };
+  return { bootstrap };
+}
+
 // src/events.ts
 function createEventBus() {
   const listeners = /* @__PURE__ */ new Set();
@@ -198,6 +258,10 @@ function createAuthNamespace(opts) {
   const confirmEmail = async (input) => {
     await call(() => opts.transport.client.auth.confirmEmail(input));
   };
+  const resendVerification = async () => {
+    const result = await call(() => opts.transport.client.auth.resendVerification({}));
+    return result.data;
+  };
   const verifyTotp = async (input) => {
     const result = await call(
       () => opts.transport.client.auth.verifyTotp({ token: input.challenge.token, code: input.code })
@@ -271,6 +335,9 @@ function createAuthNamespace(opts) {
   const changeEmail = async (input) => {
     await call(() => opts.transport.client.auth.changeEmail(input));
   };
+  const confirmEmailChange = async (input) => {
+    await call(() => opts.transport.client.auth.confirmEmailChange(input));
+  };
   const listSessions = async () => {
     const result = await call(() => opts.transport.client.auth.listSessions());
     return result.data;
@@ -327,6 +394,7 @@ function createAuthNamespace(opts) {
     requestPasswordReset,
     confirmPasswordReset,
     confirmEmail,
+    resendVerification,
     verifyTotp,
     verifyBackupCode,
     requestEmailOtp,
@@ -338,6 +406,7 @@ function createAuthNamespace(opts) {
     regenerateBackupCodes,
     changePassword,
     changeEmail,
+    confirmEmailChange,
     listSessions,
     revokeSession,
     revokeOtherSessions,
@@ -347,6 +416,9 @@ function createAuthNamespace(opts) {
   };
 }
 
+// src/base-url.ts
+var DEFAULT_BASE_URL = "https://api.fytkit.com";
+
 // src/data.ts
 function wrapSlice(slice) {
   const cache = /* @__PURE__ */ new Map();
@@ -385,9 +457,15 @@ function createDataNamespaces(transport) {
     sessionLogs: wrapSlice(c.sessionLog),
     progression: wrapSlice(c.progression),
     bodyMetrics: wrapSlice(c.bodyMetric),
+    bodyMeasurements: wrapSlice(c.bodyMeasurement),
+    progressPhotos: wrapSlice(c.progressPhoto),
+    checkIns: wrapSlice(c.checkin),
+    messages: wrapSlice(c.message),
+    timeline: wrapSlice(c.timeline),
+    health: wrapSlice(c.health),
+    habits: wrapSlice(c.habit),
     progress: wrapSlice(c.progress),
     media: wrapSlice(c.media),
-    appConfig: wrapSlice(c.appConfig),
     subscription: wrapSlice(c.subscription),
     profile: wrapSlice(c.profile),
     nutritionLog: wrapSlice(c.nutritionLog),
@@ -445,18 +523,71 @@ function createMemoryStorageAdapter() {
     }
   };
 }
+
+// src/retry-after.ts
+var DELAY_SECONDS = /^\d+$/;
+function retryAfterHeaderMs(value, now) {
+  if (value === null) return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  if (DELAY_SECONDS.test(trimmed)) return Number(trimmed) * 1e3;
+  if (!/[a-z]/i.test(trimmed)) return null;
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function hintedBody(body, waitMs) {
+  if (isRecord(body) && isRecord(body.json) && typeof body.json.code === "string") {
+    const error = body.json;
+    const data = isRecord(error.data) ? error.data : {};
+    if (typeof data.retryAfterMs === "number") return null;
+    return { ...body, json: { ...error, data: { ...data, retryAfterMs: waitMs } } };
+  }
+  return {
+    json: {
+      defined: false,
+      code: "TOO_MANY_REQUESTS",
+      status: 429,
+      message: "Too Many Requests",
+      data: { retryAfterMs: waitMs }
+    }
+  };
+}
+async function withRetryAfterHint(response, now) {
+  if (response.status !== 429) return response;
+  const waitMs = retryAfterHeaderMs(response.headers.get("retry-after"), now);
+  if (waitMs === null) return response;
+  const hinted = hintedBody(parseJson(await response.clone().text()), waitMs);
+  if (hinted === null) return response;
+  const headers = new Headers(response.headers);
+  headers.set("content-type", "application/json");
+  headers.delete("content-length");
+  return new Response(JSON.stringify(hinted), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+
+// src/transport.ts
 function createTransport(options) {
   let interceptor = null;
   const baseFetch = options.fetch ?? fetch.bind(globalThis);
-  const wrappedFetch = (input, init) => {
+  const wrappedFetch = async (input, init) => {
     const request = input instanceof Request ? input : new Request(input, init);
     const next = (req) => baseFetch(req);
-    if (!interceptor) return next(request);
-    return interceptor(request, next);
+    const response = interceptor ? await interceptor(request, next) : await next(request);
+    return withRetryAfterHint(response, Date.now());
   };
   const link = new RPCLink({
     url: () => `${options.baseUrl}/rpc`,
-    headers: () => {
+    headers: ({ context }) => {
       const session = options.getSession();
       const headers = {
         "X-Fytkit-Client-Id": options.clientId
@@ -464,6 +595,9 @@ function createTransport(options) {
       if (session) {
         headers.Authorization = `Bearer ${session.accessToken}`;
       }
+      if (context.ifNoneMatch !== void 0) {
+        headers["If-None-Match"] = context.ifNoneMatch;
+      }
       return headers;
     },
     fetch: wrappedFetch
@@ -483,6 +617,7 @@ var CREDENTIAL_PROCEDURES = [
   "auth/requestPasswordReset",
   "auth/confirmPasswordReset",
   "auth/confirmEmail",
+  "auth/confirmEmailChange",
   "auth/verifyTotp",
   "auth/verifyBackupCode",
   "auth/requestEmailOtp",
@@ -550,9 +685,331 @@ function attachRefreshInterceptor(opts) {
     return retried;
   });
 }
+var INACTIVE = {
+  kind: "not_found",
+  refusal: { reason: "join_code_inactive", data: {} }
+};
+var IGNORED_SEPARATORS = /[\s\-\u2010-\u2015\u2212]/g;
+var PATH_SAFE_CODE = /^[A-Za-z0-9]{1,64}$/;
+function pathSafeJoinCode(input) {
+  const candidate = input.replace(IGNORED_SEPARATORS, "");
+  return PATH_SAFE_CODE.test(candidate) ? candidate.toUpperCase() : null;
+}
+async function readJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+function refusalOf(response, body) {
+  const wait = () => retryAfterHeaderMs(response.headers.get("retry-after"), Date.now()) ?? 0;
+  if (isORPCErrorJson(body)) {
+    const error = normalizeError(createORPCErrorFromJson(body));
+    if (error.kind === "rate_limited" && error.retryAfter === 0) {
+      return { ...error, retryAfter: wait() };
+    }
+    return error;
+  }
+  if (response.status === 429) return { kind: "rate_limited", retryAfter: wait() };
+  return { kind: "server", status: response.status };
+}
+async function resolveJoinCode(code, options = {}) {
+  const canonical = pathSafeJoinCode(code);
+  if (canonical === null) throw INACTIVE;
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const doFetch = options.fetch ?? fetch.bind(globalThis);
+  let response;
+  try {
+    response = await doFetch(`${baseUrl}/api/v1/join/${canonical}`, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    });
+  } catch (error) {
+    throw normalizeError(error);
+  }
+  const body = await readJson(response);
+  if (response.ok) {
+    if (isRecord(body) && isRecord(body.data)) {
+      return body.data;
+    }
+    throw { kind: "server", status: response.status };
+  }
+  throw refusalOf(response, body);
+}
+
+// src/payment-policy.ts
+var PLAN_INFO = { mode: "plan_info" };
+function resolvePaymentMode(policy, options) {
+  if (!policy || !Array.isArray(policy.linkOut)) return PLAN_INFO;
+  const storefront = options.storefront?.trim().toUpperCase() ?? "";
+  if (storefront === "") return PLAN_INFO;
+  const rule = policy.linkOut.find(
+    (entry) => entry?.platform === options.platform && typeof entry.storefront === "string" && entry.storefront.toUpperCase() === storefront
+  );
+  if (!rule || !Array.isArray(rule.conditions)) return PLAN_INFO;
+  const met = new Set(options.conditionsMet ?? []);
+  if (!rule.conditions.every((condition) => met.has(condition))) return PLAN_INFO;
+  return { mode: "link_out", conditions: rule.conditions };
+}
+
+// src/realtime.ts
+var MESSAGES_FALLBACK_POLL_MS = {
+  conversation: 1e4,
+  unreadCount: 6e4
+};
+var THREAD_CHANGED_EVENT = "thread_changed";
+var MEMBER_TOPIC_PREFIX = "member:";
+var TOKEN_RENEW_BEFORE_MS = 6e4;
+var TOKEN_MIN_DELAY_MS = 5e3;
+var RETRY_MS = 6e4;
+var REJOIN_DELAYS_MS = [5e3, 15e3, 6e4];
+var SIGNED_OUT_EVENTS = /* @__PURE__ */ new Set([
+  "signed_out",
+  "signed_out_due_to_token_reuse"
+]);
+var FINAL_ERROR_KINDS = /* @__PURE__ */ new Set([
+  "auth_required",
+  "forbidden",
+  "not_found",
+  "validation"
+]);
+function isFinalError(error) {
+  if (typeof error !== "object" || error === null || !("kind" in error)) return false;
+  const kind = error.kind;
+  return typeof kind === "string" && FINAL_ERROR_KINDS.has(kind);
+}
+function isMemberTopic(topic) {
+  return typeof topic === "string" && topic.startsWith(MEMBER_TOPIC_PREFIX) && topic.length > MEMBER_TOPIC_PREFIX.length;
+}
+function isConnection(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("url" in value) || !("anonKey" in value)) return false;
+  return typeof value.url === "string" && value.url.length > 0 && typeof value.anonKey === "string" && value.anonKey.length > 0;
+}
+function renewalDelay(expiresAt, now) {
+  const expiry = Date.parse(expiresAt);
+  if (Number.isNaN(expiry)) return RETRY_MS;
+  return Math.max(TOKEN_MIN_DELAY_MS, expiry - TOKEN_RENEW_BEFORE_MS - now);
+}
+function isUsable(expiresAt, now) {
+  return Date.parse(expiresAt) - now > TOKEN_MIN_DELAY_MS;
+}
+function rejoinDelay(closures) {
+  const last = REJOIN_DELAYS_MS.length - 1;
+  return REJOIN_DELAYS_MS[Math.min(Math.max(closures - 1, 0), last)];
+}
+function ignore() {
+}
+function authorise(client, token) {
+  return new Promise((resolve) => {
+    resolve(client.realtime.setAuth(token));
+  }).then(ignore, ignore);
+}
+function subscribeToMessages(client, options) {
+  let closed = false;
+  let lastStatus = null;
+  let timer = null;
+  let renewing = false;
+  let connection = null;
+  let socket = null;
+  let held = null;
+  let channel = null;
+  let rejoinTimer = null;
+  let closures = 0;
+  let stopAuthListener = null;
+  const report = (status) => {
+    if (closed || status === lastStatus) return;
+    lastStatus = status;
+    options.onStatus?.(status);
+  };
+  const clearTimer = () => {
+    if (timer === null) return;
+    clearTimeout(timer);
+    timer = null;
+  };
+  const after = (delayMs, run) => {
+    clearTimer();
+    if (closed) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void run();
+    }, delayMs);
+  };
+  const cancelRejoin = () => {
+    if (rejoinTimer !== null) clearTimeout(rejoinTimer);
+    rejoinTimer = null;
+  };
+  const drop = () => {
+    const open = socket;
+    const joined = channel;
+    socket = null;
+    held = null;
+    channel = null;
+    cancelRejoin();
+    closures = 0;
+    if (open === null) return;
+    if (joined !== null) Promise.resolve(open.removeChannel(joined)).then(ignore, ignore);
+    open.realtime.disconnect();
+  };
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    clearTimer();
+    drop();
+    const stop = stopAuthListener;
+    stopAuthListener = null;
+    stop?.();
+  };
+  const finish = (status) => {
+    if (closed) return;
+    const changed = status !== lastStatus;
+    lastStatus = status;
+    close();
+    if (changed) options.onStatus?.(status);
+  };
+  const join = (joinTopic, open) => {
+    if (closed || socket !== open || channel !== null) return;
+    const joined = open.channel(joinTopic, { config: { private: true } });
+    channel = joined;
+    const current = () => !closed && channel === joined;
+    joined.on("broadcast", { event: THREAD_CHANGED_EVENT }, () => {
+      if (current()) options.onChange();
+    }).subscribe((status) => {
+      if (!current()) return;
+      if (status === "SUBSCRIBED") {
+        closures = 0;
+        report("live");
+        options.onChange();
+        return;
+      }
+      report("fallback");
+      if (status === "CLOSED") {
+        channel = null;
+        scheduleRejoin();
+      }
+    });
+  };
+  const authoriseAndJoin = (grant, open) => {
+    void authorise(open, grant.token).then(() => join(grant.topic, open));
+  };
+  const rejoin = () => {
+    const open = socket;
+    const grant = held;
+    if (closed || open === null || grant === null || channel !== null) return;
+    if (!isUsable(grant.expiresAt, Date.now())) {
+      void renew();
+      return;
+    }
+    authoriseAndJoin(grant, open);
+  };
+  const scheduleRejoin = () => {
+    if (closed || rejoinTimer !== null) return;
+    closures += 1;
+    rejoinTimer = setTimeout(() => {
+      rejoinTimer = null;
+      rejoin();
+    }, rejoinDelay(closures));
+  };
+  const connect = (grant, settings) => {
+    let opened;
+    try {
+      opened = options.realtime(settings);
+    } catch {
+      finish("fallback");
+      return;
+    }
+    socket = opened;
+    held = grant;
+    after(renewalDelay(grant.expiresAt, Date.now()), renew);
+    authoriseAndJoin(grant, opened);
+  };
+  const openGrant = async (grant) => {
+    if (!isMemberTopic(grant.topic)) {
+      finish("fallback");
+      return;
+    }
+    if (connection === null) {
+      let realtime;
+      try {
+        const bootstrap = await client.app.bootstrap();
+        realtime = bootstrap.status === "ok" ? bootstrap.data.realtime : void 0;
+      } catch (error) {
+        if (closed) return;
+        if (isFinalError(error)) {
+          finish("fallback");
+          return;
+        }
+        report("fallback");
+        after(RETRY_MS, start);
+        return;
+      }
+      if (closed) return;
+      if (!isConnection(realtime)) {
+        finish("fallback");
+        return;
+      }
+      connection = realtime;
+    }
+    connect(grant, connection);
+  };
+  const renew = async () => {
+    if (renewing) return;
+    renewing = true;
+    let grant;
+    try {
+      grant = (await client.messages.realtimeToken({})).data;
+    } catch (error) {
+      if (closed) return;
+      if (isFinalError(error)) finish("refused");
+      else after(RETRY_MS, renew);
+      return;
+    } finally {
+      renewing = false;
+    }
+    const current = socket;
+    if (closed || current === null || held === null) return;
+    if (grant.topic !== held.topic) {
+      drop();
+      report("connecting");
+      await openGrant(grant);
+      return;
+    }
+    held = grant;
+    after(renewalDelay(grant.expiresAt, Date.now()), renew);
+    if (channel !== null) {
+      void authorise(current, grant.token);
+      return;
+    }
+    cancelRejoin();
+    authoriseAndJoin(grant, current);
+  };
+  const start = async () => {
+    let grant;
+    try {
+      grant = (await client.messages.realtimeToken({})).data;
+    } catch (error) {
+      if (closed) return;
+      if (isFinalError(error)) {
+        finish("refused");
+        return;
+      }
+      report("fallback");
+      after(RETRY_MS, start);
+      return;
+    }
+    if (closed) return;
+    await openGrant(grant);
+  };
+  report("connecting");
+  stopAuthListener = client.auth?.onAuthStateChange((event) => {
+    if (SIGNED_OUT_EVENTS.has(event.type)) finish("refused");
+  }) ?? null;
+  void start();
+  return close;
+}
 
 // src/index.ts
-var DEFAULT_BASE_URL = "https://api.fytkit.com";
 function createFytkitClient(options) {
   if (!options || typeof options.clientId !== "string" || options.clientId.length === 0) {
     throw new Error("createFytkitClient: `clientId` is required");
@@ -571,6 +1028,7 @@ function createFytkitClient(options) {
   attachRefreshInterceptor({ transport, auth: authInstance });
   const data = createDataNamespaces(transport);
   return {
+    clientId: options.clientId,
     auth: {
       signUp: authInstance.signUp,
       signIn: authInstance.signIn,
@@ -580,6 +1038,7 @@ function createFytkitClient(options) {
       requestPasswordReset: authInstance.requestPasswordReset,
       confirmPasswordReset: authInstance.confirmPasswordReset,
       confirmEmail: authInstance.confirmEmail,
+      resendVerification: authInstance.resendVerification,
       verifyTotp: authInstance.verifyTotp,
       verifyBackupCode: authInstance.verifyBackupCode,
       requestEmailOtp: authInstance.requestEmailOtp,
@@ -591,15 +1050,17 @@ function createFytkitClient(options) {
       regenerateBackupCodes: authInstance.regenerateBackupCodes,
       changePassword: authInstance.changePassword,
       changeEmail: authInstance.changeEmail,
+      confirmEmailChange: authInstance.confirmEmailChange,
       listSessions: authInstance.listSessions,
       revokeSession: authInstance.revokeSession,
       revokeOtherSessions: authInstance.revokeOtherSessions,
       closeAccount: authInstance.closeAccount
     },
-    ...data
+    ...data,
+    app: createAppNamespace(transport)
   };
 }
 
-export { createFytkitClient, createLocalStorageAdapter, createMemoryStorageAdapter };
+export { MESSAGES_FALLBACK_POLL_MS, createFytkitClient, createLocalStorageAdapter, createMemoryStorageAdapter, refusalData, resolveJoinCode, resolvePaymentMode, subscribeToMessages };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map