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 { Code, ConnectError, 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';

function toGatewayError(e: unknown): GatewayError {
  if (e instanceof ConnectError) {
    switch (e.code) {
      case Code.Unauthenticated:
        return new GatewayError('session_invalid', e.message);
      case Code.ResourceExhausted:
        return new GatewayError('rate_limited', e.message);
      case Code.Unavailable:
        return new GatewayError('unavailable', e.message);
      case Code.NotFound:
        return new GatewayError('not_found', e.message);
      default:
        return new GatewayError('internal', e.message);
    }
  }
  return new GatewayError('unavailable', String(e));
}

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;

  async function exec(messageType: string, payload: Uint8Array): Promise<Uint8Array> {
    let res;
    try {
      res = await client.execute({ messageType, payload, requestId: '' }, { headers: headers() });
    } catch (e) {
      throw toGatewayError(e);
    }
    if (res.resultCode && res.resultCode !== 'ok') throw new GatewayError(res.resultCode);
    return res.payload;
  }

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

    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 gameState(id) {
      return codec.decodeStateView(await exec('game.state', codec.encodeStateRequest(id)));
    },
    async gameHistory(id) {
      return codec.decodeHistory(await exec('game.history', codec.encodeGameAction(id)));
    },
    async submitPlay(id, dir, tiles) {
      return codec.decodeMoveResult(await exec('game.submit_play', codec.encodeSubmitPlay(id, dir, tiles)));
    },
    async pass(id) {
      return codec.decodeMoveResult(await exec('game.pass', codec.encodeGameAction(id)));
    },
    async exchange(id, tiles) {
      return codec.decodeMoveResult(await exec('game.exchange', codec.encodeExchange(id, tiles)));
    },
    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) {
      return codec.decodeEvalResult(await exec('game.evaluate', codec.encodeEval(id, dir, tiles)));
    },
    async checkWord(id, word) {
      return codec.decodeWordCheck(await exec('game.check_word', codec.encodeCheckWord(id, word)));
    },
    async complaint(id, word, note) {
      await exec('game.complaint', codec.encodeComplaint(id, word, note));
    },

    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 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 emailBindRequest(email) {
      await exec('email.bind.request', codec.encodeEmailBind(email));
    },
    async emailBindConfirm(email, code) {
      return codec.decodeProfile(await exec('email.bind.confirm', codec.encodeEmailConfirm(email, code)));
    },
    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();
    },
  };
}