@triformine/nexis-sdk 0.1.0-next.6d96464

package/src/codec.ts

@@ -0,0 +1,48 @@
+import { Packr, Unpackr } from "msgpackr";
+import type { Envelope } from "./types";
+
+export interface Codec {
+  readonly name: "json" | "msgpack";
+  encode(message: Envelope): Uint8Array;
+  decode(bytes: Uint8Array): Envelope;
+}
+
+export class JsonCodec implements Codec {
+  readonly name = "json" as const;
+
+  encode(message: Envelope): Uint8Array {
+    return new TextEncoder().encode(JSON.stringify(message));
+  }
+
+  decode(bytes: Uint8Array): Envelope {
+    const text = new TextDecoder().decode(bytes);
+    const parsed = JSON.parse(text);
+    return parsed as Envelope;
+  }
+}
+
+export class MsgpackCodec implements Codec {
+  readonly name = "msgpack" as const;
+  private readonly packr = new Packr({
+    useRecords: false,
+    structuredClone: false,
+    bundleStrings: false,
+    maxSharedStructures: 0,
+  });
+  private readonly unpackr = new Unpackr({
+    useRecords: false,
+  });
+
+  encode(message: Envelope): Uint8Array {
+    return this.packr.pack(message);
+  }
+
+  decode(bytes: Uint8Array): Envelope {
+    const decoded = this.unpackr.unpack(bytes);
+    return decoded as Envelope;
+  }
+}
+
+export function codecFor(name: "json" | "msgpack"): Codec {
+  return name === "msgpack" ? new MsgpackCodec() : new JsonCodec();
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./codec";
+export * from "./patch";
+export * from "./rpc";
+export * from "./client";

package/src/patch.ts

@@ -0,0 +1,128 @@
+import type { PatchOp, StatePatchPayload, StateSnapshotPayload } from "./types";
+
+function keyFromPath(path: string): string {
+  if (!path.startsWith("/")) {
+    throw new Error(`Invalid patch path: ${path}`);
+  }
+  const key = path.slice(1);
+  if (!key || key.includes("/")) {
+    throw new Error(`Invalid patch path: ${path}`);
+  }
+  return key.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+export function applyPatch<T extends Record<string, unknown>>(
+  state: T,
+  patch: PatchOp[],
+): T {
+  const next: Record<string, unknown> = { ...state };
+
+  for (const op of patch) {
+    const key = keyFromPath(op.path);
+    if (op.op === "set") {
+      next[key] = op.value;
+      continue;
+    }
+    delete next[key];
+  }
+
+  return next as T;
+}
+
+function canonicalize(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalize(item));
+  }
+
+  if (value && typeof value === "object") {
+    const sortedEntries = Object.entries(value as Record<string, unknown>).sort(
+      ([left], [right]) => left.localeCompare(right),
+    );
+    const normalized: Record<string, unknown> = {};
+    for (const [key, item] of sortedEntries) {
+      normalized[key] = canonicalize(item);
+    }
+    return normalized;
+  }
+
+  return value;
+}
+
+export async function computeStateChecksum(state: unknown): Promise<string> {
+  const cryptoApi = globalThis.crypto?.subtle;
+  if (!cryptoApi) {
+    throw new Error("crypto.subtle is unavailable");
+  }
+
+  const canonicalJson = JSON.stringify(canonicalize(state));
+  const bytes = new TextEncoder().encode(canonicalJson);
+  const digest = await cryptoApi.digest("SHA-256", bytes);
+  const hashBytes = new Uint8Array(digest);
+
+  return Array.from(hashBytes)
+    .map((value) => value.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+export function parsePatchPayload(payload: unknown): StatePatchPayload | null {
+  if (Array.isArray(payload)) {
+    return {
+      seq: 0,
+      checksum: undefined,
+      ops: payload as PatchOp[],
+    };
+  }
+
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+
+  const candidate = payload as {
+    seq?: unknown;
+    checksum?: unknown;
+    ops?: unknown;
+  };
+  if (
+    typeof candidate.seq !== "number" ||
+    !Array.isArray(candidate.ops) ||
+    (candidate.checksum !== undefined && typeof candidate.checksum !== "string")
+  ) {
+    return null;
+  }
+
+  return {
+    seq: candidate.seq,
+    checksum: candidate.checksum as string | undefined,
+    ops: candidate.ops as PatchOp[],
+  };
+}
+
+export function parseSnapshotPayload(
+  payload: unknown,
+): StateSnapshotPayload | null {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+
+  const candidate = payload as {
+    seq?: unknown;
+    checksum?: unknown;
+    state?: unknown;
+  };
+  if (
+    typeof candidate.seq !== "number" ||
+    (candidate.checksum !== undefined &&
+      typeof candidate.checksum !== "string") ||
+    !candidate.state ||
+    typeof candidate.state !== "object" ||
+    Array.isArray(candidate.state)
+  ) {
+    return null;
+  }
+
+  return {
+    seq: candidate.seq,
+    checksum: candidate.checksum as string | undefined,
+    state: candidate.state as Record<string, unknown>,
+  };
+}

package/src/rpc.ts

@@ -0,0 +1,54 @@
+import type { Envelope } from "./types";
+
+export class UnknownRidError extends Error {
+  constructor(rid: string) {
+    super(`Unknown RPC rid: ${rid}`);
+  }
+}
+
+export class RpcClient {
+  private nextId = 1;
+  private pending = new Map<
+    string,
+    { resolve: (payload: unknown) => void; reject: (error: Error) => void }
+  >();
+
+  createRequest(
+    type: string,
+    payload: unknown,
+    room?: string,
+  ): { message: Envelope; promise: Promise<unknown> } {
+    const rid = `rpc-${this.nextId++}`;
+    const message: Envelope = { v: 1, t: type, rid, p: payload };
+    if (room !== undefined) {
+      message.room = room;
+    }
+    const promise = new Promise<unknown>((resolve, reject) => {
+      this.pending.set(rid, { resolve, reject });
+    });
+
+    return { message, promise };
+  }
+
+  resolveResponse(response: Envelope): void {
+    const rid = response.rid;
+    if (!rid) {
+      throw new UnknownRidError("missing");
+    }
+
+    const pending = this.pending.get(rid);
+    if (!pending) {
+      throw new UnknownRidError(rid);
+    }
+
+    this.pending.delete(rid);
+    pending.resolve(response.p);
+  }
+
+  rejectAll(error: Error): void {
+    for (const pending of this.pending.values()) {
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+}

package/src/types.ts

@@ -0,0 +1,82 @@
+export type Envelope = {
+  v: number;
+  t: string;
+  rid?: string;
+  room?: string;
+  p?: unknown;
+};
+
+export type HandshakeRequest = {
+  v: number;
+  codecs: string[];
+  project_id: string;
+  token: string;
+  session_id?: string;
+};
+
+export type ConnectOptions = {
+  projectId?: string;
+  token?: string;
+  codecs?: Array<"msgpack" | "json">;
+  sessionId?: string;
+  autoJoinMatchedRoom?: boolean;
+  autoReconnect?: boolean;
+  reconnectInitialDelayMs?: number;
+  reconnectMaxDelayMs?: number;
+  reconnectMaxAttempts?: number;
+};
+
+export type RoomSummary = {
+  id: string;
+  room_type: string;
+  members: number;
+};
+
+export type RoomListResponse = {
+  ok: boolean;
+  rooms: RoomSummary[];
+};
+
+export type MatchFound = {
+  room: string;
+  roomType: string;
+  size: number;
+  participants: string[];
+};
+
+export type MatchmakingQueueResponse = {
+  ok: boolean;
+  queued?: boolean;
+  matched?: boolean;
+  room_type?: string;
+  size?: number;
+  position?: number;
+};
+
+export type MatchmakingDequeueResponse = {
+  ok: boolean;
+  removed: boolean;
+};
+
+export type PatchOp =
+  | { op: "set"; path: string; value: unknown }
+  | { op: "del"; path: string };
+
+export type StatePatchPayload = {
+  seq: number;
+  checksum?: string;
+  ops: PatchOp[];
+};
+
+export type StateSnapshotPayload = {
+  seq: number;
+  checksum?: string;
+  state: Record<string, unknown>;
+};
+
+export type RoomMessageType = string | number;
+
+export type RoomMessagePayload = {
+  type: RoomMessageType;
+  data: unknown;
+};