scrabble-game/ui/src/lib/transport.ts

// The real Connect-RPC + FlatBuffers transport. Every unary op rides the single
// Execute envelope (message_type + FlatBuffers payload); the live stream is
// Subscribe. The session token rides in the Authorization header; domain outcomes
// come back in result_code, edge failures as Connect error codes — both normalised to
// a thrown GatewayError. In dev the Vite proxy forwards the RPC path to the h2c
// gateway; in a packaged app VITE_GATEWAY_URL points at the real origin.

import { createClient } from '@connectrpc/connect';
import { createConnectTransport } from '@connectrpc/connect-web';
import { Gateway } from '../gen/edge/v1/edge_pb';
import { GatewayError, type GatewayClient } from './client';
import * as codec from './codec';
import { registerProbe, reportOffline, reportOnline } from './connection.svelte';
import { backoffMs, isConnectionCode, retryable, toGatewayError } from './retry';

const MAX_RETRIES = 6;
const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));

export function createTransport(baseUrl: string): GatewayClient {
  const origin = baseUrl || (typeof location !== 'undefined' ? location.origin : '');
  const transport = createConnectTransport({ baseUrl: origin, useBinaryFormat: true });
  const client = createClient(Gateway, transport);
  let token: string | null = null;

  const headers = (): Record<string, string> | undefined =>
    token ? { authorization: `Bearer ${token}` } : undefined;

  // The reachability probe the connection watcher fires while offline: a cheap authenticated read
  // (it must reject when there is no session, so the watcher keeps waiting rather than reporting up).
  registerProbe(async () => {
    if (!token) throw new Error('no session');
    await client.execute({ messageType: 'profile.get', payload: codec.empty(), requestId: '' }, { headers: headers() });
  });

  // exec runs one unary op, auto-retrying transient transport failures with capped backoff (so a
  // dropped connection or a rate-limit recovers seamlessly) and driving the global Connecting
  // indicator. A successful round-trip marks the gateway reachable; a domain result_code is final.
  async function exec(messageType: string, payload: Uint8Array): Promise<Uint8Array> {
    for (let attempt = 0; ; attempt++) {
      let res;
      try {
        res = await client.execute({ messageType, payload, requestId: '' }, { headers: headers() });
      } catch (e) {
        const err = toGatewayError(e);
        if (retryable(err.code, messageType) && attempt < MAX_RETRIES) {
          reportOffline();
          await sleep(backoffMs(attempt + 1));
          continue;
        }
        if (isConnectionCode(err.code)) reportOffline();
        throw err;
      }
      reportOnline();
      if (res.resultCode && res.resultCode !== 'ok') throw new GatewayError(res.resultCode);
      return res.payload;
    }
  }

  return {
    setToken(t) {
      token = t;
    },

    async authTelegram(initData) {
      return codec.decodeSession(await exec('auth.telegram', codec.encodeTelegramLogin(initData)));
    },
    async authGuest(locale) {
      return codec.decodeSession(await exec('auth.guest', codec.encodeGuestLogin(locale ?? '')));
    },
    async authEmailRequest(email) {
      await exec('auth.email.request', codec.encodeEmailRequest(email));
    },
    async authEmailLogin(email, code) {
      return codec.decodeSession(await exec('auth.email.login', codec.encodeEmailLogin(email, code)));
    },

    async profileGet() {
      return codec.decodeProfile(await exec('profile.get', codec.empty()));
    },
    async gamesList() {
      return codec.decodeGameList(await exec('games.list', codec.empty()));
    },

    async lobbyEnqueue(variant) {
      return codec.decodeMatchResult(await exec('lobby.enqueue', codec.encodeEnqueue(variant)));
    },
    async lobbyPoll() {
      return codec.decodeMatchResult(await exec('lobby.poll', codec.empty()));
    },
    async lobbyCancel() {
      await exec('lobby.cancel', codec.empty());
    },

    async gameState(id, includeAlphabet) {
      return codec.decodeStateView(await exec('game.state', codec.encodeStateRequest(id, includeAlphabet)));
    },
    async gameHistory(id) {
      return codec.decodeHistory(await exec('game.history', codec.encodeGameAction(id)));
    },
    async submitPlay(id, dir, tiles, variant) {
      return codec.decodeMoveResult(await exec('game.submit_play', codec.encodeSubmitPlay(id, dir, tiles, variant)));
    },
    async pass(id) {
      return codec.decodeMoveResult(await exec('game.pass', codec.encodeGameAction(id)));
    },
    async exchange(id, tiles, variant) {
      return codec.decodeMoveResult(await exec('game.exchange', codec.encodeExchange(id, tiles, variant)));
    },
    async resign(id) {
      return codec.decodeMoveResult(await exec('game.resign', codec.encodeGameAction(id)));
    },
    async hint(id) {
      return codec.decodeHintResult(await exec('game.hint', codec.encodeGameAction(id)));
    },
    async evaluate(id, dir, tiles, variant) {
      return codec.decodeEvalResult(await exec('game.evaluate', codec.encodeEval(id, dir, tiles, variant)));
    },
    async checkWord(id, word, variant) {
      return codec.decodeWordCheck(await exec('game.check_word', codec.encodeCheckWord(id, word, variant)));
    },
    async complaint(id, word, note) {
      await exec('game.complaint', codec.encodeComplaint(id, word, note));
    },
    async hideGame(id) {
      await exec('game.hide', codec.encodeGameAction(id));
    },
    async draftGet(id) {
      return codec.decodeDraftView(await exec('draft.get', codec.encodeGameAction(id)));
    },
    async draftSave(id, json) {
      await exec('draft.save', codec.encodeDraftSave(id, json));
    },

    async chatPost(id, body) {
      return codec.decodeChatMessage(await exec('chat.post', codec.encodeChatPost(id, body)));
    },
    async chatList(id) {
      return codec.decodeChatList(await exec('chat.list', codec.encodeGameAction(id)));
    },
    async nudge(id) {
      return codec.decodeChatMessage(await exec('chat.nudge', codec.encodeGameAction(id)));
    },

    async friendsList() {
      return codec.decodeFriendList(await exec('friends.list', codec.empty()));
    },
    async friendsIncoming() {
      return codec.decodeIncomingList(await exec('friends.incoming', codec.empty()));
    },
    async friendsOutgoing() {
      return codec.decodeOutgoingList(await exec('friends.outgoing', codec.empty()));
    },
    async friendRequest(accountId) {
      await exec('friends.request', codec.encodeTarget(accountId));
    },
    async friendRespond(requesterId, accept) {
      await exec('friends.respond', codec.encodeFriendRespond(requesterId, accept));
    },
    async friendCancel(accountId) {
      await exec('friends.cancel', codec.encodeTarget(accountId));
    },
    async unfriend(accountId) {
      await exec('friends.unfriend', codec.encodeTarget(accountId));
    },
    async friendCodeIssue() {
      return codec.decodeFriendCode(await exec('friends.code.issue', codec.empty()));
    },
    async friendCodeRedeem(code) {
      return codec.decodeRedeemResult(await exec('friends.code.redeem', codec.encodeRedeemCode(code)));
    },

    async blocksList() {
      return codec.decodeBlockList(await exec('blocks.list', codec.empty()));
    },
    async block(accountId) {
      await exec('blocks.add', codec.encodeTarget(accountId));
    },
    async unblock(accountId) {
      await exec('blocks.remove', codec.encodeTarget(accountId));
    },

    async invitationsList() {
      return codec.decodeInvitationList(await exec('invitation.list', codec.empty()));
    },
    async invitationCreate(inviteeIds, settings) {
      return codec.decodeInvitation(await exec('invitation.create', codec.encodeCreateInvitation(inviteeIds, settings)));
    },
    async invitationAccept(invitationId) {
      return codec.decodeInvitation(await exec('invitation.accept', codec.encodeInvitationAction(invitationId)));
    },
    async invitationDecline(invitationId) {
      return codec.decodeInvitation(await exec('invitation.decline', codec.encodeInvitationAction(invitationId)));
    },
    async invitationCancel(invitationId) {
      await exec('invitation.cancel', codec.encodeInvitationAction(invitationId));
    },

    async profileUpdate(p) {
      return codec.decodeProfile(await exec('profile.update', codec.encodeUpdateProfile(p)));
    },
    async linkEmailRequest(email) {
      await exec('link.email.request', codec.encodeLinkEmailRequest(email));
    },
    async linkEmailConfirm(email, code) {
      return codec.decodeLinkResult(await exec('link.email.confirm', codec.encodeLinkEmailConfirm(email, code)));
    },
    async linkEmailMerge(email, code) {
      return codec.decodeLinkResult(await exec('link.email.merge', codec.encodeLinkEmailConfirm(email, code)));
    },
    async linkTelegram(data) {
      return codec.decodeLinkResult(await exec('link.telegram.confirm', codec.encodeLinkTelegram(data)));
    },
    async linkTelegramMerge(data) {
      return codec.decodeLinkResult(await exec('link.telegram.merge', codec.encodeLinkTelegram(data)));
    },
    async statsGet() {
      return codec.decodeStats(await exec('stats.get', codec.empty()));
    },
    async exportGcg(gameId) {
      return codec.decodeGcg(await exec('game.gcg', codec.encodeGameAction(gameId)));
    },

    subscribe(onEvent, onError) {
      const ctrl = new AbortController();
      void (async () => {
        try {
          for await (const ev of client.subscribe({}, { headers: headers(), signal: ctrl.signal })) {
            const pe = codec.decodeEvent(ev.kind, ev.payload);
            if (pe) onEvent(pe);
          }
        } catch (e) {
          if (!ctrl.signal.aborted) onError?.(toGatewayError(e));
        }
      })();
      return () => ctrl.abort();
    },
  };
}