@trolleroof/tui 0.2.5 → 0.2.6

package/src/sync/game-start-queue.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { GameStartQueue } from "./game-start-queue.js";
+
+describe("GameStartQueue", () => {
+  it("gates a direct launch until the configured backend identity is verified", async () => {
+    let resolveIdentity!: (userId: string) => void;
+    const identity = new Promise<string>((resolve) => { resolveIdentity = resolve; });
+    const starts: Array<{ game: string; userId: string }> = [];
+    const queue = new GameStartQueue({
+      resolveRecording: async () => ({ userId: await identity }),
+      start: (request, recording) => starts.push({ game: request.game, userId: recording.userId }),
+    });
+
+    const pending = queue.request({ game: "2048", variation: "classic", source: "direct" });
+    await Promise.resolve();
+    expect(starts).toEqual([]);
+    resolveIdentity("usr_backend");
+    await pending;
+    expect(starts).toEqual([{ game: "2048", userId: "usr_backend" }]);
+  });
+
+  it("starts only the latest fast menu selection after identity resolution", async () => {
+    let resolveIdentity!: (userId: string) => void;
+    const identity = new Promise<string>((resolve) => { resolveIdentity = resolve; });
+    const starts: string[] = [];
+    const queue = new GameStartQueue({
+      resolveRecording: async () => ({ userId: await identity }),
+      start: (request) => starts.push(request.game),
+    });
+
+    const first = queue.request({ game: "2048", variation: "classic", source: "menu" });
+    const second = queue.request({ game: "tetris", variation: "classic", source: "menu" });
+    resolveIdentity("usr_backend");
+    await Promise.all([first, second]);
+    expect(starts).toEqual(["tetris"]);
+  });
+
+  it("makes a delayed restart non-interactive until identity resolves", async () => {
+    let resolveIdentity!: (userId: string) => void;
+    const identity = new Promise<string>((resolve) => { resolveIdentity = resolve; });
+    let mutations = 0;
+    const starts: string[] = [];
+    const queue = new GameStartQueue({
+      resolveRecording: async () => ({ userId: await identity }),
+      start: (request) => starts.push(request.game),
+    });
+
+    const pending = queue.request({ game: "2048", variation: "classic", source: "restart" });
+    if (!queue.pending) mutations++;
+    expect(queue.pending).toBe(true);
+    expect(mutations).toBe(0);
+
+    resolveIdentity("usr_backend");
+    await pending;
+    expect(queue.pending).toBe(false);
+    expect(starts).toEqual(["2048"]);
+  });
+
+  it("cancels a delayed restart on quit so it cannot reopen later", async () => {
+    let resolveIdentity!: (userId: string) => void;
+    const identity = new Promise<string>((resolve) => { resolveIdentity = resolve; });
+    const starts: string[] = [];
+    const queue = new GameStartQueue({
+      resolveRecording: async () => ({ userId: await identity }),
+      start: (request) => starts.push(request.game),
+    });
+
+    const pending = queue.request({ game: "2048", variation: "classic", source: "restart" });
+    expect(queue.pending).toBe(true);
+    queue.cancel();
+    expect(queue.pending).toBe(false);
+    resolveIdentity("usr_backend");
+    await pending;
+    expect(starts).toEqual([]);
+  });
+
+  it("cancels a queued direct launch before identity resolves", async () => {
+    let resolveIdentity!: (userId: string) => void;
+    const identity = new Promise<string>((resolve) => { resolveIdentity = resolve; });
+    const starts: string[] = [];
+    const queue = new GameStartQueue({
+      resolveRecording: async () => ({ userId: await identity }),
+      start: (request) => starts.push(request.game),
+    });
+
+    const pending = queue.request({ game: "2048", variation: "classic", source: "direct" });
+    queue.cancel();
+    resolveIdentity("usr_backend");
+    await pending;
+    expect(queue.pending).toBe(false);
+    expect(starts).toEqual([]);
+  });
+});

package/src/sync/game-start-queue.ts

@@ -0,0 +1,45 @@
+export interface GameStartRequest {
+  game: string;
+  variation: string;
+  source: "direct" | "menu" | "restart";
+}
+
+export interface GameStartQueueOptions<
+  T extends { source: GameStartRequest["source"] },
+  R,
+> {
+  resolveRecording: () => Promise<R>;
+  start: (request: T, recording: R) => void;
+}
+
+export class GameStartQueue<
+  T extends { source: GameStartRequest["source"] } = GameStartRequest,
+  R = { userId: string },
+> {
+  private generation = 0;
+  private pendingGeneration: number | null = null;
+
+  constructor(private readonly options: GameStartQueueOptions<T, R>) {}
+
+  get pending(): boolean {
+    return this.pendingGeneration !== null;
+  }
+
+  async request(request: T): Promise<void> {
+    const generation = ++this.generation;
+    this.pendingGeneration = generation;
+    try {
+      const recording = await this.options.resolveRecording();
+      if (generation !== this.generation) return;
+      this.pendingGeneration = null;
+      this.options.start(request, recording);
+    } finally {
+      if (this.pendingGeneration === generation) this.pendingGeneration = null;
+    }
+  }
+
+  cancel(): void {
+    this.generation++;
+    this.pendingGeneration = null;
+  }
+}

package/src/sync/identity-client.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { IdentityClient } from "./identity-client.js";
+import type { BackendConfig } from "./config.js";
+
+const config: BackendConfig = {
+  baseUrl: "https://retro.example",
+  token: "retro_user_token",
+  meUrl: "https://retro.example/v1/me",
+  eventChunksUrl: "https://retro.example/v1/game-event-chunks",
+  gameResultsUrl: "https://retro.example/v1/game-results",
+};
+
+describe("IdentityClient", () => {
+  it("returns the token-selected user from /v1/me", async () => {
+    let authorization = "";
+    const client = new IdentityClient(config, async (_input, init) => {
+      authorization = (init?.headers as Record<string, string>).Authorization ?? "";
+      return Response.json({ user_id: "usr_backend" });
+    });
+    await expect(client.resolve()).resolves.toBe("usr_backend");
+    expect(authorization).toBe("Bearer retro_user_token");
+  });
+
+  it("rejects unauthorized and malformed identity responses", async () => {
+    await expect(new IdentityClient(
+      config,
+      async () => new Response("unauthorized", { status: 401 }),
+    ).resolve()).rejects.toThrow("HTTP 401");
+    await expect(new IdentityClient(
+      config,
+      async () => Response.json({ user_id: "not a v2 user" }),
+    ).resolve()).rejects.toThrow("invalid user_id");
+  });
+});

package/src/sync/identity-client.ts

@@ -0,0 +1,43 @@
+import type { BackendConfig } from "./config.js";
+
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+const USER_ID = /^usr_[A-Za-z0-9._-]+$/;
+
+export class IdentityClient {
+  constructor(
+    private readonly config: BackendConfig,
+    private readonly request: Fetch = globalThis.fetch,
+    private readonly timeoutMs = 10_000,
+  ) {}
+
+  async resolve(signal?: AbortSignal): Promise<string> {
+    const controller = new AbortController();
+    const abort = () => controller.abort(signal?.reason);
+    if (signal?.aborted) abort();
+    else signal?.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    timeout.unref?.();
+    try {
+      const response = await this.request(this.config.meUrl, {
+        headers: { Authorization: `Bearer ${this.config.token}` },
+        signal: controller.signal,
+      });
+      if (response.status !== 200) {
+        throw new Error(`identity lookup returned HTTP ${response.status}`);
+      }
+      const value: unknown = await response.json();
+      if (
+        typeof value !== "object" || value === null ||
+        !("user_id" in value) || typeof value.user_id !== "string" ||
+        !USER_ID.test(value.user_id)
+      ) {
+        throw new Error("identity lookup returned an invalid user_id");
+      }
+      return value.user_id;
+    } finally {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+}