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

// GatewayClient — the typed facade the screens call. Both the real Connect/
// FlatBuffers transport and the in-memory mock implement it. Domain failures (the
// gateway's result_code) and edge failures (Connect error codes) are normalised
// into a thrown GatewayError carrying a stable `code` the UI maps to an i18n
// message.

import type {
  AccountRef,
  BlockStatus,
  ChatMessage,
  EvalResult,
  FeedbackState,
  FriendCode,
  GameList,
  GameView,
  GcgExport,
  History,
  HintResult,
  Invitation,
  InvitationSettings,
  LinkResult,
  MatchResult,
  MoveResult,
  Profile,
  ProfileUpdate,
  PushEvent,
  Session,
  StateView,
  Stats,
  Tile,
  Variant,
  WordCheckResult,
} from './model';

/** GatewayError carries a stable code (the gateway result_code, or an edge code). */
export class GatewayError extends Error {
  readonly code: string;
  constructor(code: string, message?: string) {
    super(message ?? code);
    this.name = 'GatewayError';
    this.code = code;
  }
}

/** A tile the player is submitting (rack/blank already resolved to a letter). */
export interface PlacedTile {
  row: number;
  col: number;
  letter: string;
  blank: boolean;
}

/** Unsubscribe handle for the live stream. */
export type Unsubscribe = () => void;

export interface GatewayClient {
  // --- auth (unauthenticated) ---
  authTelegram(initData: string): Promise<Session>;
  authGuest(locale?: string): Promise<Session>;
  authEmailRequest(email: string): Promise<void>;
  authEmailLogin(email: string, code: string): Promise<Session>;

  // --- profile / lists ---
  profileGet(): Promise<Profile>;
  /** The caller's current manual block. Exempt from the backend's suspension gate, so a blocked
   *  client can still fetch it to render the blocked screen. */
  blockStatus(): Promise<BlockStatus>;
  gamesList(): Promise<GameList>;

  // --- lobby ---
  /** Start a quick game: human auto-match, or an honest-AI game against a robot when vsAi. */
  lobbyEnqueue(variant: Variant, multipleWords: boolean, vsAi: boolean): Promise<MatchResult>;
  lobbyPoll(): Promise<MatchResult>;
  /** Leave the auto-match pool (idempotent); a cancelled quick-match must not stay queued. */
  lobbyCancel(): Promise<void>;

  // --- game ---
  // The play loop exchanges alphabet indices, so submit/evaluate/exchange/
  // check-word take the game's variant (to map letters<->indices via the cached alphabet
  // table), and gameState's includeAlphabet asks the server to embed that table.
  gameState(gameId: string, includeAlphabet: boolean): Promise<StateView>;
  gameHistory(gameId: string): Promise<History>;
  submitPlay(gameId: string, tiles: PlacedTile[], variant: Variant): Promise<MoveResult>;
  pass(gameId: string): Promise<MoveResult>;
  exchange(gameId: string, tiles: string[], variant: Variant): Promise<MoveResult>;
  resign(gameId: string): Promise<MoveResult>;
  hint(gameId: string): Promise<HintResult>;
  evaluate(gameId: string, tiles: PlacedTile[], variant: Variant): Promise<EvalResult>;
  checkWord(gameId: string, word: string, variant: Variant): Promise<WordCheckResult>;
  complaint(gameId: string, word: string, note: string): Promise<void>;
  /** Hide a finished game from the caller's own lobby list; per-account, irreversible. */
  hideGame(gameId: string): Promise<void>;

  // --- draft ---
  /** The player's server-persisted client-side composition (rack order + board tiles), so a
   *  reload or a second device resumes the same arrangement. The JSON is opaque to the
   *  gateway; the client owns the {rack_order, board_tiles} shape. */
  draftGet(gameId: string): Promise<string>;
  draftSave(gameId: string, json: string): Promise<void>;

  // --- chat ---
  chatPost(gameId: string, body: string): Promise<ChatMessage>;
  chatList(gameId: string): Promise<ChatMessage[]>;
  nudge(gameId: string): Promise<ChatMessage>;

  // --- feedback ---
  /** feedbackSubmit sends a feedback message with an optional single attachment. */
  feedbackSubmit(body: string, attachment: Uint8Array | null, attachmentName: string, channel: string): Promise<void>;
  /** feedbackGet returns the feedback screen state and marks any pending reply delivered. */
  feedbackGet(): Promise<FeedbackState>;
  /** feedbackUnread reports whether an operator reply awaits delivery (the badge). */
  feedbackUnread(): Promise<boolean>;

  // --- friends ---
  friendsList(): Promise<AccountRef[]>;
  friendsIncoming(): Promise<AccountRef[]>;
  /** Addressees the caller has already requested (pending or declined); cannot re-request. */
  friendsOutgoing(): Promise<AccountRef[]>;
  friendRequest(accountId: string): Promise<void>;
  friendRespond(requesterId: string, accept: boolean): Promise<void>;
  friendCancel(accountId: string): Promise<void>;
  unfriend(accountId: string): Promise<void>;
  friendCodeIssue(): Promise<FriendCode>;
  friendCodeRedeem(code: string): Promise<AccountRef>;

  // --- blocks ---
  blocksList(): Promise<AccountRef[]>;
  block(accountId: string): Promise<void>;
  unblock(accountId: string): Promise<void>;

  // --- invitations ---
  invitationsList(): Promise<Invitation[]>;
  invitationCreate(inviteeIds: string[], settings: InvitationSettings): Promise<Invitation>;
  invitationAccept(invitationId: string): Promise<Invitation>;
  invitationDecline(invitationId: string): Promise<Invitation>;
  invitationCancel(invitationId: string): Promise<void>;

  // --- profile / stats / history ---
  profileUpdate(p: ProfileUpdate): Promise<Profile>;
  statsGet(): Promise<Stats>;
  exportGcg(gameId: string): Promise<GcgExport>;

  // --- account linking & merge ---
  linkEmailRequest(email: string): Promise<void>;
  linkEmailConfirm(email: string, code: string): Promise<LinkResult>;
  linkEmailMerge(email: string, code: string): Promise<LinkResult>;
  linkTelegram(data: string): Promise<LinkResult>;
  linkTelegramMerge(data: string): Promise<LinkResult>;

  // --- live stream ---
  subscribe(onEvent: (e: PushEvent) => void, onError?: (err: unknown) => void): Unsubscribe;

  /** Set or clear the bearer token used for authenticated calls and the stream. */
  setToken(token: string | null): void;
}

export type { GameView, Tile };