@roster-lock/match-agent 0.1.0

package/src/handle-room/version-1/room-handler-state/handleRoomWithErrors.ts

@@ -0,0 +1,55 @@
+import { RosterLockV1Config, UserInput } from "@roster-lock/types";
+
+import { IRoom } from "../globals/Room";
+import { waitForExternalError, waitForStoppedRoomHeartbeat } from "./roomErrors";
+import { handleRoomSelections } from "./handleRoomSelections";
+import { ExternalUserError, MATCHLOCK_SELECTION_STATE } from "../constants";
+import { IFolderDB } from "../globals/FolderDB";
+import { handleDownloads } from "../handleDownloads";
+
+type Results = Awaited<ReturnType<typeof doWork>>;
+
+export async function tryToHandleRoomVersion1(
+  folderDB: IFolderDB,
+  room: IRoom,
+  lockConfig: RosterLockV1Config,
+  selection: UserInput["userSelection"],
+): Promise<Results>{
+  const abortController = new AbortController();
+  try {
+    return await Promise.race([
+      doWork(folderDB, room, abortController.signal, lockConfig, selection),
+      waitForExternalError<Results>(room, abortController.signal),
+      waitForStoppedRoomHeartbeat<Results>(room, 10_000, abortController.signal),
+    ])
+  }catch(e){
+    console.log("Match To Start Failed", e);
+    if(!(e instanceof ExternalUserError) && e instanceof Error){
+      room.broadcast(MATCHLOCK_SELECTION_STATE.failure, e.message);
+    }
+    room.disconnect();
+    throw e;
+  }finally{
+    abortController.abort();
+  }
+}
+
+async function doWork(
+  db: IFolderDB,
+  room: IRoom,
+  abortSignal: AbortSignal,
+  lockConfig: RosterLockV1Config,
+  userSelection: UserInput["userSelection"],
+){
+  const finalSelection = await handleRoomSelections(room, abortSignal, lockConfig, userSelection);
+  const downloadResults = await handleDownloads(
+    db, lockConfig, finalSelection, {
+      onProgress: (event)=>{room.broadcast(event.type, event)},
+      abortSignal
+    }
+  );
+  return {
+    finalSelection,
+    downloadResults
+  };
+}

package/src/handle-room/version-1/room-handler-state/roomErrors.ts

@@ -0,0 +1,35 @@
+
+import { IRoom } from "../globals/Room/room";
+import { ExternalUserError, ROOM_EVENT, MATCHLOCK_DOWNLOAD_STATE, MATCHLOCK_SELECTION_STATE } from "../constants";
+
+import { waitForEvent, waitForEventTimeout } from "@roster-lock/utils";
+export async function waitForExternalError<T>(
+  room: IRoom, abortSignal: AbortSignal
+): Promise<T> {
+  const [userId, event, message] = await waitForEvent(
+    room.listen.filter((userId, event, message)=>{
+      if(event === ROOM_EVENT.userLeft) return true;
+      if(event === MATCHLOCK_SELECTION_STATE.failure) return true;
+      if(event === MATCHLOCK_DOWNLOAD_STATE.downloadFullFailure) return true;
+      return false;
+    }),
+    abortSignal
+  )
+  throw new ExternalUserError(userId, message);
+}
+
+export async function waitForStoppedRoomHeartbeat<T>(
+  room: IRoom, timeout: number, abortSignal: AbortSignal
+): Promise<T> {
+  await waitForEventTimeout(
+    room.listen.filter((userId, event, message)=>{
+      if(event === ROOM_EVENT.userLeft) return false;
+      if(event === MATCHLOCK_SELECTION_STATE.failure) return false;
+      if(event === MATCHLOCK_DOWNLOAD_STATE.downloadFullFailure) return false;
+      return true;
+    }),
+    timeout,
+    abortSignal
+  );
+  throw new Error("Heartbeat Timeout");
+}

package/src/handle-room/version-1/room-handler-state/user-selection.ts

@@ -0,0 +1,98 @@
+import {
+  PieceType, UserId,
+  runSelection,
+} from "@roster-lock/shared";
+import {
+  RosterLockV1Config, SelectedPiece,
+  UserInput, FinalSelection,
+} from "@roster-lock/types";
+import { JSONSchemaType } from "ajv";
+
+// Using 'as unknown as' because AJV's JSONSchemaType doesn't handle recursive $ref well
+export const selectedPieceSchema: JSONSchemaType<SelectedPiece> = {
+  $id: "SelectedPiece",
+  type: "object",
+  required: ["id", "required"],
+  additionalProperties: false,
+  properties: {
+    id: { type: "string" },
+    required: {
+      type: "object",
+      required: [],
+      additionalProperties: {
+        type: "array",
+        items: { $ref: "SelectedPiece" },
+      },
+    },
+  },
+} as unknown as JSONSchemaType<SelectedPiece>;
+
+export const userInputSchema: JSONSchemaType<UserInput> = {
+  type: "object",
+  required: ["randomSeed", "userSelection"],
+  additionalProperties: false,
+  properties: {
+    randomSeed: { type: "string" },
+    userSelection: {
+      type: "object",
+      required: [],
+      additionalProperties: {
+        type: "array",
+        items: selectedPieceSchema,
+      },
+    },
+  },
+}
+
+import { PluginHandler } from "@roster-lock/plugin-runtime";
+export function finalizeSelection(
+  config: RosterLockV1Config,
+  gameControlledSelections: Record<PieceType, Array<SelectedPiece> | Record<UserId, Array<SelectedPiece>>>,
+  userInputs: Record<UserId, UserInput>,
+  pluginRuntime: PluginHandler
+): Promise<FinalSelection> {
+
+  return runSelection(
+    config,
+    gameControlledSelections,
+    userInputs,
+    (script)=>(pluginRuntime.runUntrustedScript(script))
+  )
+}
+
+export const finalSelectionSchema: JSONSchemaType<FinalSelection> = {
+  type: "object",
+  required: [],
+  additionalProperties: {
+    anyOf: [
+      {
+        type: "object",
+        required: ["type", "value"],
+        additionalProperties: false,
+        properties: {
+          type: { type: "string", const: "shared" },
+          value: {
+            type: "array",
+            items: selectedPieceSchema,
+          },
+        },
+      },
+      {
+        type: "object",
+        required: ["type", "value"],
+        additionalProperties: false,
+        properties: {
+          type: { type: "string", const: "personal" },
+          value: {
+            type: "object",
+            required: [],
+            additionalProperties: {
+              type: "array",
+              items: selectedPieceSchema,
+            },
+          },
+        },
+      },
+    ],
+  }
+}

package/src/handle-room/version-1/schema/count.ts

@@ -0,0 +1,13 @@
+
+import { Count } from "@roster-lock/types";
+import { z } from "zod";
+
+export const CountSchema: z.ZodType<Count> = z.union([
+  z.number().positive(),
+  z.literal("*"),
+  z.tuple([z.number().min(0), z.union([z.number().positive(), z.literal("*")])]),
+]).refine((count) => {
+  if(!Array.isArray(count)) return true;
+  if(count[1] === "*") return true;
+  return count[0] < count[1];
+}, { message: "maximum should be greater than the minimum" });

package/src/handle-room/version-1/schema/lock.ts

@@ -0,0 +1,47 @@
+import { RosterLockV1Config, RosterLockPiece } from "@roster-lock/types";
+import z, { ZodType } from "zod";
+
+import { CountSchema } from "./count";
+
+export const engineCaster: ZodType<RosterLockV1Config["engine"]> = z.object({
+  name: z.string(),
+  version: z.string(),
+  pieceDefinitions: z.record(z.string(), z.object({
+      selectionStrategy: z.enum(["mandatory", "personal", "shared", "on demand"]),
+      requires: z.array(z.string()),
+      pathVariables: z.array(z.string()),
+      assets: z.array(z.object({
+        name: z.string(),
+        classification: z.enum(["logic", "media", "doc"]),
+        count: CountSchema,
+        glob: z.array(z.string()),
+      })),
+  })),
+})
+
+const pieceObjectCaster = z.object({
+  id: z.string(),
+  version: z.object({
+    logic: z.string(),
+    media: z.string(),
+    docs: z.string(),
+  }),
+  humanInfo: z.object({
+    name: z.string(),
+    author: z.string(),
+    url: z.string(),
+    image: z.string().optional(),
+  }),
+  downloadSources: z.array(z.string()),
+  pathVariables: z.record(z.string(), z.string()),
+  requiredPieces: z.record(z.string(), z.object({
+      expected: z.array(z.string()),
+      selectable: z.boolean(),
+  })),
+})
+
+export const pieceCaster: ZodType<RosterLockPiece> = pieceObjectCaster;
+
+// Piece file routes only resolve a piece's on-disk folder (by content hash +
+// pathVariables), so they don't need the rest of RosterLockPiece.
+export const pieceFileInfoCaster = pieceObjectCaster.pick({ version: true, pathVariables: true });

package/src/handle-room/version-1/schema/selected.ts

@@ -0,0 +1,14 @@
+import { UserInput, SelectedPiece } from "@roster-lock/types";
+import { z, ZodType } from "zod";
+
+const SelectedPieceSchema: ZodType<SelectedPiece> = z.lazy(() =>
+  z.object({
+    id: z.string(),
+    required: z.record(z.string(), z.object({
+      mandatory: z.array(SelectedPieceSchema),
+      selectable: z.array(SelectedPieceSchema),
+    })),
+  }).strict()
+);
+
+export const UserSelectionSchema: z.ZodType<UserInput["userSelection"]> = z.record(z.string(), z.array(SelectedPieceSchema));

package/src/handle-room/version-1/select.ts

@@ -0,0 +1,130 @@
+
+import { RosterLockPiece, RosterLockV1Config, DownloadResult } from "@roster-lock/types";
+import { jsonBody, HTTPRequestHandler, HTTPError } from "../../utils/http-router";
+import { WebSocketHandlerCallback } from "../../utils/websocket-router";
+import { handlePagination } from "../../utils/pagination"
+import { MessageBridge } from "@roster-lock/utils";
+import z, { ZodType } from "zod";
+import { engineCaster, pieceCaster } from "./schema/lock";
+import { V1Env } from "./globals/types";
+
+type GetPieceInfo = {
+  engine: RosterLockV1Config["engine"]
+  pieceType: string
+  piece: RosterLockPiece
+}
+
+const ensurePieceSchema: ZodType<GetPieceInfo> = z.object({
+  engine: engineCaster,
+  pieceType: z.string(),
+  piece: pieceCaster,
+})
+
+export const ensurePieceDownloaded: HTTPRequestHandler = async function(
+  this: V1Env, { req, res }
+){
+  const { fileDB } = this;
+  const body = await jsonBody(req)
+  const parseResult = ensurePieceSchema.safeParse(body);
+  if(!parseResult.success){
+    throw new HTTPError(400, "Bad Form", parseResult.error);
+  }
+  const { engine, pieceType, piece } = parseResult.data;
+
+  const abortController = new AbortController();
+  req.on("close", ()=>abortController.abort());
+
+  const pieceFolder = await fileDB.ensurePieceExists(
+    engine, pieceType, piece, {
+      onProgress: ()=>{},
+      abortSignal: abortController.signal,
+    }
+  );
+
+  const dlResult: DownloadResult = {
+    pieceType,
+    pieceId: piece.id,
+    pieceVersions: { logic: piece.version.logic, media: piece.version.media },
+    folder: pieceFolder,
+  }
+
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(dlResult));
+}
+
+export const ensurePieceDownloadedWs: WebSocketHandlerCallback = async function(
+  this: V1Env, { ws }, params, next
+){
+  const { fileDB } = this;
+  try {
+    const bridge = new MessageBridge((message)=>ws.send(JSON.stringify(message)));
+    ws.on("message", (message)=>{
+      bridge.handleMessage(JSON.parse(message.toString()));
+    });
+
+    const abortController = new AbortController();
+    ws.on("close", ()=>abortController.abort());
+
+    bridge.onRequest("ensure-piece", async (body)=>{
+      const parseResult = ensurePieceSchema.safeParse(body);
+      if(!parseResult.success){
+        throw new Error("Bad Form: " + parseResult.error.message);
+      }
+      const { engine, pieceType, piece } = parseResult.data;
+
+      const pieceFolder = await fileDB.ensurePieceExists(
+        engine, pieceType, piece, {
+          onProgress: (update)=>{bridge.sendEvent("download-progress", update)},
+          abortSignal: abortController.signal,
+        }
+      );
+
+      const dlResult: DownloadResult = {
+        pieceType,
+        pieceId: piece.id,
+        pieceVersions: { logic: piece.version.logic, media: piece.version.media },
+        folder: pieceFolder,
+      }
+      return dlResult;
+    });
+    bridge.sendEvent("ready", {});
+  }catch(e){
+    ws.terminate();
+    next(e);
+  }
+}
+
+
+type ListDownloadedPiecesDirect = {
+  engineName: string,
+  pieceType: string,
+  logicIds: Array<string>,
+}
+
+const listPiecesDirectSchema: ZodType<ListDownloadedPiecesDirect> = z.object({
+  engineName: z.string(),
+  pieceType: z.string(),
+  logicIds: z.array(z.string()),
+})
+
+export const listDownloadedPiecesDirect: HTTPRequestHandler = async function(
+  this: V1Env, { req, res }, routeInfo
+){
+  const { fileDB } = this;
+  const { page, limit } = handlePagination(routeInfo.url.searchParams);
+
+  const body = await jsonBody(req)
+  const parseResult = listPiecesDirectSchema.safeParse(body);
+  if(!parseResult.success) throw new HTTPError(400, "Bad Form", parseResult.error);
+  const config = parseResult.data;
+
+  const pieces = await fileDB.listPieces(
+    config.engineName,
+    config.pieceType,
+    config.logicIds,
+    { page, limit }
+  );
+  res.writeHead(200, { "content-type": "application/json"});
+  res.end(JSON.stringify(pieces));
+}
+

package/src/handle-room/version-1/validateUnknown.ts

@@ -0,0 +1,11 @@
+import { JSON_Unknown } from "@roster-lock/utils";
+import { Ajv, JSONSchemaType } from "ajv";
+
+export function validateUnknown<T>(schema: JSONSchemaType<T>, data: JSON_Unknown): T {
+  const ajv = new Ajv();
+  const validate = ajv.compile(schema);
+  if(!validate(data)){
+    throw new Error("Invalid Data");
+  }
+  return data;
+}

package/src/index.old.ts

@@ -0,0 +1,71 @@
+
+import {
+  MatchLockRestrictionConfig,
+  MatchLockSelectionConfig,
+  GamePiece
+} from "@match-lock/shared";
+import { PublicKeyMap, validateSignedSelection } from "./validateSelection";
+
+import { handleConnection } from "./handleConnection";
+
+
+export function prepareGame(){
+  
+  return new MatchLockPrepare();
+}
+
+class MatchLockPrepare extends Promise<boolean> {
+  constructor(
+    public pieceFolder: string,
+    public roomClient: RoomClient,
+    public restrictionConfig: MatchLockRestrictionConfig,
+    public userSelection: MatchLockSelectionConfig
+  ) {
+    super((res, rej)=>{
+      Promise.resolve().then(async ()=>{
+        const { publicKeys } = await roomClient.getUsers();
+
+      }).then(()=>{
+        res(true);
+      }, rej)
+    });
+  }
+}
+
+import { ISimpleEventEmitter } from "@match-lock/shared";
+
+interface RoomClient {
+  getUsers(): Promise<{ publicKeys: PublicKeyMap }>
+  sendSelection(selection: MatchLockSelectionConfig): Promise<boolean>
+  recieveSelection: ISimpleEventEmitter<[MatchLockSelectionConfig]>
+  onDestroy: ISimpleEventEmitter<[MatchLockSelectionConfig]>
+}
+
+interface ClientConnection{
+  handlePrivateKey(): Promise<string>
+  handleSelection(): Promise<MatchLockSelectionConfig>
+  onPiece: ISimpleEventEmitter<[GamePiece]>
+  sendPieceProgress(pieceId: string, part: "logic" | "media", progress: number): Promise<void>
+  onFinished(): Promise<void>
+
+  onClose: ISimpleEventEmitter<[reason?: string]>
+
+  connect(): void
+}
+
+
+interface DownloadProgress {
+  onProgress: ISimpleEventEmitter<[number]>
+  onFinished: ISimpleEventEmitter<[]>
+}
+
+function downloadPiece(restriction: MatchLockRestrictionConfig, peice: GamePiece): DownloadProgress {
+  
+
+
+}
+
+function resolveDownloadable(url: string){
+
+
+}