@fytkit/sdk 3.4.0 → 3.5.0

package/dist/index.js

@@ -1,6 +1,29 @@
 import { createORPCClient, ORPCError } 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 +54,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,20 +63,33 @@ 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 };
@@ -385,6 +422,8 @@ function createDataNamespaces(transport) {
     sessionLogs: wrapSlice(c.sessionLog),
     progression: wrapSlice(c.progression),
     bodyMetrics: wrapSlice(c.bodyMetric),
+    checkIns: wrapSlice(c.checkin),
+    messages: wrapSlice(c.message),
     progress: wrapSlice(c.progress),
     media: wrapSlice(c.media),
     appConfig: wrapSlice(c.appConfig),
@@ -445,14 +484,67 @@ 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`,
@@ -551,6 +643,261 @@ function attachRefreshInterceptor(opts) {
   });
 }
 
+// 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 {
+        realtime = (await client.appConfig.get()).data.realtime;
+      } 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) {
@@ -600,6 +947,6 @@ function createFytkitClient(options) {
   };
 }
 
-export { createFytkitClient, createLocalStorageAdapter, createMemoryStorageAdapter };
+export { MESSAGES_FALLBACK_POLL_MS, createFytkitClient, createLocalStorageAdapter, createMemoryStorageAdapter, refusalData, subscribeToMessages };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map