sailfork / t3code-github / packages/ client-runtime/ src/ relay/ managedRelayState.ts

import type { EnvironmentId } from "@t3tools/contracts";
import { decodeRelayJwt } from "@t3tools/shared/relayJwt";
import * as Cause from "effect/Cause";
import * as Clock from "effect/Clock";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";

import { findErrorTraceId } from "../errors/errorTrace.ts";
import * as ManagedRelay from "./managedRelay.ts";
import { relayProtectedErrorMessage } from "./errorPresentation.ts";

const DEFAULT_STALE_TIME_MS = 15_000;
const DEFAULT_IDLE_TTL_MS = 5 * 60_000;
const CLERK_TOKEN_EXPIRY_SKEW_MS = 5_000;
const isManagedRelayRequestFailedError = Schema.is(ManagedRelay.ManagedRelayRequestFailedError);

export interface ManagedRelaySession {
  readonly accountId: string;
  readonly readClerkToken: () => Effect.Effect<string | null, ManagedRelaySessionError>;
}

export interface ManagedRelaySessionInput {
  readonly accountId: string;
  readonly readClerkToken: () => Promise<string | null>;
}

interface ManagedRelaySessionControl {
  readonly updateReadClerkToken: (
    readClerkToken: ManagedRelaySessionInput["readClerkToken"],
  ) => void;
}

export interface ManagedRelaySnapshotState<A> {
  readonly data: A | null;
  readonly error: string | null;
  readonly errorTraceId: string | null;
  readonly isPending: boolean;
}

export interface ManagedRelayQueryEvent {
  readonly operation: "environments" | "devices" | "t3chat-link";
  readonly stage: "clerk-token" | "relay-request";
  readonly phase: "start" | "success" | "failure";
  readonly accountId: string;
  readonly environmentId?: string;
  readonly message?: string;
  readonly traceId?: string | null;
}

export class ManagedRelaySessionError extends Schema.TaggedError<ManagedRelaySessionError>()(
  "ManagedRelaySessionError",
  {
    message: Schema.String,
    cause: Schema.optional(Schema.Defect()),
  },
) {}

export const managedRelaySessionAtom = Atom.make<ManagedRelaySession | null>(null).pipe(
  Atom.keepAlive,
  Atom.withLabel("managed-relay:session"),
);

const managedRelaySessionControls = new WeakMap<ManagedRelaySession, ManagedRelaySessionControl>();

export function createManagedRelaySession(input: ManagedRelaySessionInput): ManagedRelaySession {
  let cachedToken: { readonly token: string; readonly expiresAtMillis: number } | null = null;
  let pendingToken: Promise<string | null> | null = null;
  let readClerkToken = input.readClerkToken;
  let tokenProviderGeneration = 0;

  const readCachedClerkToken = async (nowMillis: number): Promise<string | null> => {
    if (cachedToken && cachedToken.expiresAtMillis > nowMillis + CLERK_TOKEN_EXPIRY_SKEW_MS) {
      return cachedToken.token;
    }
    if (pendingToken) {
      return await pendingToken;
    }

    const operationGeneration = tokenProviderGeneration;
    const operation = readClerkToken().then((token) => {
      if (operationGeneration !== tokenProviderGeneration) {
        return token;
      }
      if (!token) {
        cachedToken = null;
        return null;
      }
      const expiresAtSeconds = Effect.runSync(
        decodeRelayJwt(token).pipe(
          Effect.map((claims) => claims.exp),
          Effect.orElseSucceed(() => undefined),
        ),
      );
      cachedToken =
        typeof expiresAtSeconds === "number"
          ? { token, expiresAtMillis: expiresAtSeconds * 1_000 }
          : null;
      return token;
    });
    pendingToken = operation;
    try {
      return await operation;
    } finally {
      if (pendingToken === operation) {
        pendingToken = null;
      }
    }
  };

  const session: ManagedRelaySession = {
    accountId: input.accountId,
    readClerkToken: Effect.fn("clientRuntime.managedRelaySession.readClerkToken")(function* () {
      const nowMillis = yield* Clock.currentTimeMillis;
      return yield* Effect.tryPromise({
        try: () => readCachedClerkToken(nowMillis),
        catch: (cause) =>
          new ManagedRelaySessionError({
            message: "Could not obtain the T3 Connect session token.",
            cause,
          }),
      });
    }),
  };
  managedRelaySessionControls.set(session, {
    updateReadClerkToken: (nextReadClerkToken) => {
      readClerkToken = nextReadClerkToken;
      tokenProviderGeneration += 1;
      pendingToken = null;
    },
  });
  return session;
}

export function setManagedRelaySession(
  registry: AtomRegistry.AtomRegistry,
  input: ManagedRelaySessionInput | null,
): void {
  const current = registry.get(managedRelaySessionAtom);
  if (input === null) {
    if (current !== null) {
      registry.set(managedRelaySessionAtom, null);
    }
    return;
  }
  if (current?.accountId === input.accountId) {
    const control = managedRelaySessionControls.get(current);
    if (control) {
      // Clerk can replace its token reader during routine same-account refreshes.
      // Keep the session stable so those refreshes do not invalidate queries or reconnect leases.
      control.updateReadClerkToken(input.readClerkToken);
      return;
    }
  }
  registry.set(managedRelaySessionAtom, createManagedRelaySession(input));
}

export function managedRelayAccountChanges(
  registry: AtomRegistry.AtomRegistry,
): Stream.Stream<string | null> {
  return AtomRegistry.toStream(registry, managedRelaySessionAtom).pipe(
    Stream.map((session) => session?.accountId ?? null),
    Stream.changes,
    Stream.drop(1),
  );
}

function readSessionClerkToken(
  session: ManagedRelaySession,
): Effect.Effect<string, ManagedRelaySessionError> {
  return session.readClerkToken().pipe(
    Effect.filterOrFail(
      (token): token is string => Boolean(token),
      () =>
        new ManagedRelaySessionError({
          message: "The T3 Connect session token is unavailable.",
        }),
    ),
  );
}

function requireSessionClerkToken(
  registry: AtomRegistry.AtomRegistry,
  accountId: string,
  action: string,
): Effect.Effect<string, ManagedRelaySessionError> {
  const session = registry.get(managedRelaySessionAtom);
  if (!session || session.accountId !== accountId) {
    return Effect.fail(
      new ManagedRelaySessionError({ message: `Sign in to T3 Connect before ${action}.` }),
    );
  }
  return readSessionClerkToken(session);
}

export const deregisterManagedRelayEnvironment = Effect.fn(
  "clientRuntime.managedRelaySession.deregisterEnvironment",
)(function* (
  registry: AtomRegistry.AtomRegistry,
  input: { readonly accountId: string; readonly environmentId: EnvironmentId },
) {
  const clerkToken = yield* requireSessionClerkToken(
    registry,
    input.accountId,
    "deregistering an environment",
  );
  const relay = yield* ManagedRelay.ManagedRelayClient;
  yield* relay.unlinkEnvironment({ clerkToken, environmentId: input.environmentId });
});

/** Returns the T3 Chat page URL where the signed-in user confirms the link. */
export const createManagedRelayT3ChatLinkRequest = Effect.fn(
  "clientRuntime.managedRelaySession.createT3ChatLinkRequest",
)(function* (registry: AtomRegistry.AtomRegistry, input: { readonly accountId: string }) {
  const clerkToken = yield* requireSessionClerkToken(registry, input.accountId, "linking T3 Chat");
  const relay = yield* ManagedRelay.ManagedRelayClient;
  return (yield* relay.createT3ChatLinkRequest({ clerkToken })).url;
});

export const unlinkManagedRelayT3Chat = Effect.fn("clientRuntime.managedRelaySession.unlinkT3Chat")(
  function* (registry: AtomRegistry.AtomRegistry, input: { readonly accountId: string }) {
    const clerkToken = yield* requireSessionClerkToken(
      registry,
      input.accountId,
      "unlinking T3 Chat",
    );
    const relay = yield* ManagedRelay.ManagedRelayClient;
    yield* relay.unlinkT3Chat({ clerkToken });
  },
);

function requireClerkToken(
  get: Atom.AtomContext,
  accountId: string,
): Effect.Effect<string, ManagedRelaySessionError> {
  const session = get(managedRelaySessionAtom);
  if (!session || session.accountId !== accountId) {
    return Effect.fail(
      new ManagedRelaySessionError({
        message: "Sign in to T3 Connect before loading relay data.",
      }),
    );
  }
  return readSessionClerkToken(session);
}

function describeManagedRelayFailure(cause: Cause.Cause<unknown>): {
  readonly message: string;
  readonly traceId: string | null;
} {
  const error = Cause.squash(cause);
  return {
    message:
      isManagedRelayRequestFailedError(error) && error.relayError
        ? relayProtectedErrorMessage(error.relayError)
        : error instanceof Error
          ? error.message
          : "Could not load T3 Connect data.",
    traceId: findErrorTraceId(error),
  };
}

export function readManagedRelaySnapshotState<A>(
  result: AsyncResult.AsyncResult<A, unknown>,
): ManagedRelaySnapshotState<A> {
  const failure = result._tag === "Failure" ? describeManagedRelayFailure(result.cause) : null;
  return {
    data: AsyncResult.getOrElse(result, () => null),
    error: failure?.message ?? null,
    errorTraceId: failure?.traceId ?? null,
    isPending: result.waiting,
  };
}

// Logged where the listing runs so each failed fetch reports once, however many
// components read the atom.
const logListingFailure =
  (label: string) =>
  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
    self.pipe(
      Effect.tapCause((cause) => {
        if (Cause.hasInterruptsOnly(cause)) return Effect.void;
        const { message, traceId } = describeManagedRelayFailure(cause);
        return Effect.logError(`[t3-cloud] Relay ${label} listing failed`).pipe(
          Effect.annotateLogs({ message, traceId }),
        );
      }),
    );

export function createManagedRelayQueryManager(
  runtime: Atom.AtomRuntime<ManagedRelay.ManagedRelayClient>,
  options?: {
    readonly staleTimeMs?: number;
    readonly idleTtlMs?: number;
    readonly onQueryEvent?: (event: ManagedRelayQueryEvent) => void;
  },
) {
  const staleTime = options?.staleTimeMs ?? DEFAULT_STALE_TIME_MS;
  const idleTtl = options?.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
  const observe = Effect.fn("managedRelayState.observe")(function* <A, E, R>(
    input: Omit<ManagedRelayQueryEvent, "phase" | "message" | "traceId">,
    effect: Effect.Effect<A, E, R>,
  ): Effect.fn.Return<A, E, R> {
    options?.onQueryEvent?.({ ...input, phase: "start" });
    return yield* effect.pipe(
      Effect.onExit((exit) =>
        Effect.sync(() => {
          if (exit._tag === "Success") {
            options?.onQueryEvent?.({ ...input, phase: "success" });
            return;
          }
          const error = Cause.squash(exit.cause);
          options?.onQueryEvent?.({
            ...input,
            phase: "failure",
            message: error instanceof Error ? error.message : String(error),
            traceId: findErrorTraceId(error),
          });
        }),
      ),
    );
  });

  const environmentsAtom = Atom.family((accountId: string) =>
    runtime
      .atom((get) =>
        Effect.gen(function* () {
          const base = { operation: "environments" as const, accountId };
          const clerkToken = yield* observe(
            { ...base, stage: "clerk-token" },
            requireClerkToken(get, accountId),
          );
          const relay = yield* ManagedRelay.ManagedRelayClient;
          return yield* observe(
            { ...base, stage: "relay-request" },
            relay.listEnvironments({ clerkToken }),
          );
        }).pipe(logListingFailure("environment")),
      )
      .pipe(
        Atom.swr({ staleTime, revalidateOnMount: true }),
        Atom.setIdleTTL(idleTtl),
        Atom.withLabel(`managed-relay:environments:${accountId}`),
      ),
  );

  const devicesAtom = Atom.family((accountId: string) =>
    runtime
      .atom((get) =>
        Effect.gen(function* () {
          const base = { operation: "devices" as const, accountId };
          const clerkToken = yield* observe(
            { ...base, stage: "clerk-token" },
            requireClerkToken(get, accountId),
          );
          const relay = yield* ManagedRelay.ManagedRelayClient;
          return yield* observe(
            { ...base, stage: "relay-request" },
            relay.listDevices({ clerkToken }),
          );
        }).pipe(logListingFailure("device")),
      )
      .pipe(
        Atom.swr({ staleTime, revalidateOnMount: true }),
        Atom.setIdleTTL(idleTtl),
        Atom.withLabel(`managed-relay:devices:${accountId}`),
      ),
  );

  const t3ChatLinkAtom = Atom.family((accountId: string) =>
    runtime
      .atom((get) =>
        Effect.gen(function* () {
          const base = { operation: "t3chat-link" as const, accountId };
          const clerkToken = yield* observe(
            { ...base, stage: "clerk-token" },
            requireClerkToken(get, accountId),
          );
          const relay = yield* ManagedRelay.ManagedRelayClient;
          return yield* observe(
            { ...base, stage: "relay-request" },
            relay.getT3ChatLink({ clerkToken }),
          );
        }),
      )
      .pipe(
        Atom.swr({ staleTime, revalidateOnMount: true }),
        Atom.setIdleTTL(idleTtl),
        Atom.withLabel(`managed-relay:t3chat-link:${accountId}`),
      ),
  );

  return {
    environmentsAtom,
    devicesAtom,
    t3ChatLinkAtom,
    refreshEnvironments(registry: AtomRegistry.AtomRegistry, accountId: string): void {
      registry.refresh(environmentsAtom(accountId));
    },
    refreshDevices(registry: AtomRegistry.AtomRegistry, accountId: string): void {
      registry.refresh(devicesAtom(accountId));
    },
    refreshT3ChatLink(registry: AtomRegistry.AtomRegistry, accountId: string): void {
      registry.refresh(t3ChatLinkAtom(accountId));
    },
  };
}