@dreamboard-games/cli 0.1.30-alpha.0

package/dist/runtime-packages/ui-host-runtime/src/session-ingress.ts

@@ -0,0 +1,219 @@
+import type {
+  HostSessionEvent,
+  HostSessionSnapshot,
+} from "@dreamboard-games/api-client";
+import type {
+  GameplayPerspective,
+  GameplayViewport,
+  SessionContext,
+} from "./session-model.js";
+import {
+  contextFromHostEventContext,
+  contextFromHostSnapshot,
+  gameplayViewportFromSnapshot,
+} from "./session-model.js";
+
+type WireSessionIngressSnapshot = HostSessionSnapshot;
+type WireSessionIngressEvent = HostSessionEvent;
+interface WireSessionIngressActionSubmitResponse {
+  success: boolean;
+  version: number;
+  actionSetVersion: string;
+  accepted?: boolean | null;
+  durabilityStatus?: "COMMITTED" | null;
+  update?: WireSessionIngressEvent | null;
+  errorCode?: string | null;
+  message?: string | null;
+  clientActionId?: string | null;
+}
+
+export type HostSessionWireSnapshot = WireSessionIngressSnapshot;
+export type HostSessionWireEvent = WireSessionIngressEvent;
+export type HostActionSubmitWireResponse =
+  WireSessionIngressActionSubmitResponse;
+
+export type NormalizedSessionSnapshot =
+  | {
+      type: "lobby";
+      context: SessionContext;
+      gameplay: null;
+      preferredPlayerId: string | null;
+    }
+  | {
+      type: "gameplay";
+      context: SessionContext;
+      perspective: GameplayPerspective;
+      gameplay: GameplayViewport;
+    }
+  | {
+      type: "ended";
+      context: SessionContext;
+      gameplay: null;
+      preferredPlayerId: string | null;
+    };
+
+export type NormalizedSessionEvent =
+  | {
+      type: "session.snapshot";
+      snapshot: NormalizedSessionSnapshot;
+      context: SessionContext;
+      gameplay: GameplayViewport | null;
+    }
+  | {
+      type: "session.lobbyUpdated";
+      context: SessionContext | null;
+      gameplay: GameplayViewport | null;
+    }
+  | {
+      type: "session.gameplayUpdated";
+      context: SessionContext | null;
+      gameplay: GameplayViewport;
+      perspective: GameplayPerspective;
+    }
+  | {
+      type: "session.historyUpdated";
+      context: SessionContext | null;
+      gameplay: GameplayViewport | null;
+    }
+  | {
+      type: "session.ended";
+      context: SessionContext | null;
+      gameplay: GameplayViewport | null;
+    }
+  | {
+      type: "session.error";
+      message: string;
+      code?: string;
+      context: SessionContext | null;
+      gameplay: GameplayViewport | null;
+    };
+
+export type NormalizedSubmitResponse = NormalizedSessionEvent | null;
+
+export function normalizeSnapshot(
+  snapshot: HostSessionWireSnapshot,
+  options: {
+    userId: string | null;
+    previousGameplay?: GameplayViewport | null;
+  },
+): NormalizedSessionSnapshot {
+  const context = contextFromHostSnapshot(snapshot, options.userId);
+  if (snapshot.type !== "gameplay") {
+    return {
+      type: snapshot.type,
+      context,
+      gameplay: null,
+      preferredPlayerId: null,
+    };
+  }
+  return {
+    type: "gameplay",
+    context,
+    perspective: { playerId: snapshot.gameplay.perspectivePlayerId },
+    gameplay: gameplayViewportFromSnapshot(
+      snapshot.gameplay,
+      options.previousGameplay,
+    ),
+  };
+}
+
+export function normalizeEvent(
+  event: HostSessionWireEvent,
+  options: {
+    currentContext: SessionContext | null;
+    currentGameplay: GameplayViewport | null;
+    userId: string | null;
+  },
+): NormalizedSessionEvent {
+  const context = options.currentContext;
+  switch (event.type) {
+    case "session.snapshot": {
+      const normalized = normalizeSnapshot(event.snapshot, {
+        userId: options.userId,
+        previousGameplay: options.currentGameplay,
+      });
+      return {
+        type: "session.snapshot",
+        snapshot: normalized,
+        context: normalized.context,
+        gameplay: normalized.gameplay,
+      };
+    }
+    case "session.lobbyUpdated":
+      return {
+        type: "session.lobbyUpdated",
+        context: context
+          ? contextFromHostEventContext(
+              { ...context, userId: options.userId },
+              event.context,
+              event.lobby,
+            )
+          : null,
+        gameplay: options.currentGameplay,
+      };
+    case "session.gameplayUpdated":
+      return {
+        type: "session.gameplayUpdated",
+        context: context
+          ? contextFromHostEventContext(
+              { ...context, userId: options.userId },
+              event.context,
+            )
+          : null,
+        gameplay: gameplayViewportFromSnapshot(
+          event.gameplay,
+          options.currentGameplay,
+        ),
+        perspective: { playerId: event.gameplay.perspectivePlayerId },
+      };
+    case "session.historyUpdated":
+      return {
+        type: "session.historyUpdated",
+        context: context
+          ? contextFromHostEventContext(
+              { ...context, userId: options.userId },
+              event.context,
+            )
+          : null,
+        gameplay: options.currentGameplay,
+      };
+    case "session.ended":
+      return {
+        type: "session.ended",
+        context: context
+          ? contextFromHostEventContext(
+              { ...context, userId: options.userId },
+              event.context,
+              event.lobby,
+            )
+          : null,
+        gameplay: options.currentGameplay,
+      };
+    case "session.error":
+      return {
+        type: "session.error",
+        message: event.message,
+        code: event.code,
+        context,
+        gameplay: options.currentGameplay,
+      };
+  }
+}
+
+export function normalizeSubmitResponse(
+  response: HostActionSubmitWireResponse,
+  options: {
+    currentContext: SessionContext | null;
+    currentGameplay: GameplayViewport | null;
+    userId: string | null;
+  },
+): NormalizedSubmitResponse {
+  if (!response.accepted || !response.update) {
+    return null;
+  }
+  return normalizeEvent(response.update, {
+    currentContext: options.currentContext,
+    currentGameplay: options.currentGameplay,
+    userId: options.userId,
+  });
+}

package/dist/runtime-packages/ui-host-runtime/src/session-live-runtime.ts

@@ -0,0 +1,117 @@
+import type { HostSessionWireEvent } from "./session-ingress.js";
+import type { SSEManager, SSERecoveryEvent } from "./sse-manager.js";
+
+export interface SSEManagerLike {
+  connect: (
+    sessionId: string,
+    options: {
+      source?: string;
+      playerId?: string;
+    },
+  ) => Promise<void> | void;
+  disconnect: () => void;
+  on: SSEManager["on"];
+  onAnyMessage: SSEManager["onAnyMessage"];
+}
+
+export interface SessionLiveRuntime {
+  connectSession: (
+    sessionId: string,
+    options: { source?: string; playerId?: string },
+  ) => void;
+  reconnectGameplay: (
+    sessionId: string,
+    playerId: string,
+    source: string,
+  ) => void;
+  requestGameplayResync: (
+    sessionId: string,
+    playerId: string,
+    source: string,
+  ) => void;
+  closeStreams: () => void;
+  getConnectedSessionId: () => string | null;
+}
+
+export function createSessionLiveRuntime(options: {
+  createSseManager: () => SSEManagerLike;
+  onConnectionChange: (
+    channel: "lobby" | "gameplay",
+    connected: boolean,
+  ) => void;
+  onConnectionError: (error: unknown) => void;
+  onConnectionRecovering: (details: SSERecoveryEvent) => void;
+  onLiveMessage: (message: HostSessionWireEvent) => void;
+}): SessionLiveRuntime {
+  let connectedSessionId: string | null = null;
+  let sessionManager: SSEManagerLike | null = null;
+  let unsubscribeSession: (() => void) | null = null;
+
+  const attachConnectionHandlers = (
+    manager: SSEManagerLike,
+    channel: "lobby" | "gameplay",
+  ) => {
+    manager.on("connected", () => options.onConnectionChange(channel, true));
+    manager.on("disconnected", () =>
+      options.onConnectionChange(channel, false),
+    );
+    manager.on("error", (error) => {
+      options.onConnectionChange(channel, false);
+      options.onConnectionError(error);
+    });
+    manager.on("recovering", (details) => {
+      options.onConnectionChange(channel, false);
+      options.onConnectionRecovering(details);
+    });
+  };
+
+  const closeStreams = () => {
+    unsubscribeSession?.();
+    unsubscribeSession = null;
+    sessionManager?.disconnect();
+    sessionManager = null;
+    connectedSessionId = null;
+    options.onConnectionChange("lobby", false);
+    options.onConnectionChange("gameplay", false);
+  };
+
+  const openSession = (
+    sessionId: string,
+    playerId: string | undefined,
+    source: string,
+  ) => {
+    closeStreams();
+    connectedSessionId = sessionId;
+    sessionManager = options.createSseManager();
+    attachConnectionHandlers(sessionManager, playerId ? "gameplay" : "lobby");
+    unsubscribeSession = sessionManager.onAnyMessage(options.onLiveMessage);
+    void sessionManager.connect(sessionId, {
+      source,
+      playerId,
+    });
+  };
+
+  return {
+    connectSession: (sessionId, connectOptions) => {
+      openSession(
+        sessionId,
+        connectOptions.playerId,
+        connectOptions.source ?? "connect-session",
+      );
+    },
+    reconnectGameplay: (sessionId, playerId, source) => {
+      openSession(sessionId, playerId, source);
+    },
+    requestGameplayResync: (sessionId, playerId, source) => {
+      if (!sessionManager) {
+        return;
+      }
+      void sessionManager.connect(sessionId, {
+        source,
+        playerId,
+      });
+    },
+    closeStreams,
+    getConnectedSessionId: () => connectedSessionId,
+  };
+}