sailfork / t3code-github / apps/ mobile/ src/ state/ preview.ts

import { useAtomValue } from "@effect/atom-react";
import { parseScopedThreadKey, scopedThreadKey } from "@t3tools/client-runtime/environment";
import { PREVIEW_STREAM_BASE_PATH } from "@t3tools/client-runtime/preview/server-browser-stream";
import { createPreviewEnvironmentAtoms } from "@t3tools/client-runtime/state/preview";
import { resolveDeviceHubAccess } from "@t3tools/client-runtime/state/deviceHubAccess";
import type {
  EnvironmentId,
  PreviewEvent,
  PreviewListResult,
  PreviewSessionSnapshot,
  ThreadId,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import { AsyncResult, Atom } from "effect/reactivity";

import { connectionAtomRuntime } from "../connection/runtime";
import { appAtomRegistry } from "./atom-registry";
import { useEnvironmentQuery } from "./query";
import { environmentSession, usePreparedConnection } from "./session";

export const previewEnvironment = createPreviewEnvironmentAtoms(connectionAtomRuntime);

interface ThreadPreviewTabs {
  readonly serverEpoch: string | null;
  readonly revision: number;
  readonly sessions: ReadonlyArray<PreviewSessionSnapshot>;
  readonly listed: boolean;
}

const EMPTY_TABS: ThreadPreviewTabs = {
  serverEpoch: null,
  revision: 0,
  sessions: [],
  listed: false,
};
const emptyTabsAtom = Atom.make(EMPTY_TABS).pipe(Atom.withLabel("mobile-preview-tabs:empty"));

const MAX_REPLAY_EVENTS = 200;

function applyEvent(current: ThreadPreviewTabs, event: PreviewEvent): ThreadPreviewTabs {
  if (event.revision <= current.revision) return current;
  const index = current.sessions.findIndex((session) => session.tabId === event.tabId);
  const sessions = [...current.sessions];
  if (event.type === "closed") {
    if (index !== -1) sessions.splice(index, 1);
  } else if (event.type === "failed") {
    const existing = sessions[index];
    if (existing) {
      sessions[index] = {
        ...existing,
        navStatus: {
          _tag: "LoadFailed",
          url: event.url,
          title: event.title,
          code: event.code,
          description: event.description,
        },
        updatedAt: event.createdAt,
      };
    }
  } else {
    sessions[index === -1 ? sessions.length : index] = event.snapshot;
  }
  return { ...current, serverEpoch: event.serverEpoch, revision: event.revision, sessions };
}

const threadPreviewTabsAtom = Atom.family((threadKey: string) => {
  const ref = parseScopedThreadKey(threadKey);
  if (ref === null) return emptyTabsAtom;
  const listAtom = previewEnvironment.list({
    environmentId: ref.environmentId,
    input: { threadId: ref.threadId },
  });
  const eventsAtom = previewEnvironment.events({ environmentId: ref.environmentId, input: {} });
  return Atom.make((get) => {
    let disposed = false;
    let state = EMPTY_TABS;
    // Lists can land after events they predate; replay newer events on each list.
    let list: PreviewListResult | null = null;
    let events: ReadonlyArray<PreviewEvent> = [];
    const publish = (next: ThreadPreviewTabs) => {
      if (next === state) return;
      state = next;
      get.setSelf(next);
    };
    const applyList = (result: PreviewListResult) => {
      if (list?.serverEpoch === result.serverEpoch && result.revision < list.revision) return;
      list = result;
      events = events.filter(
        (event) => event.serverEpoch === result.serverEpoch && event.revision > result.revision,
      );
      return events.reduce<ThreadPreviewTabs>(applyEvent, { ...result, listed: true });
    };
    get.addFinalizer(() => {
      disposed = true;
    });
    get.subscribe(listAtom, (result) => {
      if (!AsyncResult.isSuccess(result)) return;
      const next = applyList(result.value);
      if (next) publish(next);
    });
    get.subscribe(eventsAtom, (result) => {
      if (!AsyncResult.isSuccess(result) || result.value.threadId !== ref.threadId) return;
      const event = result.value;
      if (list?.serverEpoch === event.serverEpoch && event.revision <= list.revision) return;
      events = [...events.slice(1 - MAX_REPLAY_EVENTS), event];
      // A restarted server resets revisions; only a fresh list is authoritative.
      if (state.serverEpoch !== null && event.serverEpoch !== state.serverEpoch) {
        get.refresh(listAtom);
        return;
      }
      publish(applyEvent(state, event));
    });
    get.mount(listAtom);
    get.mount(eventsAtom);
    const cached = get.once(listAtom);
    if (AsyncResult.isSuccess(cached)) state = applyList(cached.value) ?? state;
    queueMicrotask(() => {
      if (!disposed) get.refresh(listAtom);
    });
    return state;
  }).pipe(Atom.setIdleTTL(1_000), Atom.withLabel(`mobile-preview-tabs:${threadKey}`));
});

export function useThreadServerBrowserTabs(input: {
  readonly environmentId: EnvironmentId;
  readonly threadId: ThreadId;
  readonly enabled: boolean;
}) {
  const tabs = useAtomValue(
    input.enabled
      ? threadPreviewTabsAtom(
          scopedThreadKey({ environmentId: input.environmentId, threadId: input.threadId }),
        )
      : emptyTabsAtom,
  );
  const sessions = tabs.sessions.filter((session) => session.runtime === "server");
  return { tabs: sessions, loaded: tabs.listed };
}

// The earliest time the next access request may go out.
const previewStreamNotBeforeAtom = Atom.family((environmentId: EnvironmentId) =>
  Atom.make(0).pipe(Atom.withLabel(`mobile-preview-stream-retry:${environmentId}`)),
);

const previewStreamAccessAtom = Atom.family((environmentId: EnvironmentId) =>
  connectionAtomRuntime
    .atom((get) => {
      const prepared = Option.getOrNull(
        get(environmentSession.preparedConnectionValueAtom(environmentId)),
      );
      const notBefore = get(previewStreamNotBeforeAtom(environmentId));
      if (prepared === null) return Effect.never;
      const resolve = resolveDeviceHubAccess({ prepared, hubBasePath: PREVIEW_STREAM_BASE_PATH });
      // A recompute interrupts the wait, so only the newest retry resolves.
      const wait = notBefore - Date.now();
      return wait > 0 ? Effect.andThen(Effect.sleep(wait), resolve) : resolve;
    })
    .pipe(Atom.setIdleTTL(60_000), Atom.withLabel(`mobile-preview-stream-access:${environmentId}`)),
);

/** Resolves fresh stream access once `delayMs` has passed. */
function retryPreviewStreamAccess(environmentId: EnvironmentId, delayMs: number) {
  appAtomRegistry.set(previewStreamNotBeforeAtom(environmentId), Date.now() + delayMs);
}

export function usePreviewStreamAccess(environmentId: EnvironmentId) {
  const prepared = usePreparedConnection(environmentId);
  const query = useEnvironmentQuery(previewStreamAccessAtom(environmentId));
  const access = query.data && query.error === null && Option.isSome(prepared) ? query.data : null;
  return {
    access,
    error: query.error,
    refresh: query.refresh,
    retryAfter: (delayMs: number) => retryPreviewStreamAccess(environmentId, delayMs),
  };
}