New saving/loading behaviors to fix bugs related to saving

components/databaseHandler.ts

@@ -23,6 +23,7 @@ import { serializeSession, deserializeSession } from "./sessionSerialization"
 import { castUserProfile } from "./utils"
 import { getConfig } from "./configSwizzleManager"
 import { log, LogLevel } from "./loggingInterop"
+import { unlink, readdir } from "fs/promises"
 
 /**
  * Container for functions that handle file read/writes,
@@ -216,33 +217,50 @@ export async function writeExternalUserData(
 /**
  * Reads a contract session from the contractSessions folder.
  *
- * @param sessionId The ID of the session to load.
+ * @param identifier The identifier for the saved session, in the format of token_sessionID.
  * @returns The contract session.
  */
 export async function getContractSession(
-    sessionId: string,
+    identifier: string,
 ): Promise<ContractSession> {
+    const files = await readdir("contractSessions")
+    const filtered = files.filter((fn) => fn.endsWith(`_${identifier}.json`))
+
+    if (filtered.length === 0) {
+        throw new Error(`No session saved with identifier ${identifier}`)
+    }
+
+    // The filtered files have the same identifier, they are just stored at different slots
+    // So we can read any of them and it will be the same.
     return deserializeSession(
         JSON.parse(
-            (
-                await readFile(join("contractSessions", `${sessionId}.json`))
-            ).toString(),
+            (await readFile(join("contractSessions", filtered[0]))).toString(),
         ),
     )
 }
 
 /**
  * Writes a contract session to the contractsSessions folder.
  *
- * @param sessionId The session's ID.
+ * @param identifier The identifier for the saved session, in the format of slot_token_sessionID.
  * @param session The contract session.
  */
 export async function writeContractSession(
-    sessionId: string,
+    identifier: string,
     session: ContractSession,
 ): Promise<void> {
     return await writeFile(
-        join("contractSessions", `${sessionId}.json`),
+        join("contractSessions", `${identifier}.json`),
         JSON.stringify(serializeSession(session)),
     )
 }
+
+/**
+ * Deletes a saved contract session from the contractsSessions folder.
+ *
+ * @param fileName The identifier for the saved session, in the format of slot_token_sessionID.
+ * @throws ENOENT if the file is not found.
+ */
+export async function deleteContractSession(fileName: string): Promise<void> {
+    return await unlink(join("contractSessions", `${fileName}.json`))
+}

components/eventHandler.ts

@@ -33,19 +33,13 @@ import {
 import { extractToken, ServerVer } from "./utils"
 import { json as jsonMiddleware } from "body-parser"
 import { log, LogLevel } from "./loggingInterop"
-import {
-    getContractSession,
-    getUserData,
-    writeContractSession,
-    writeUserData,
-} from "./databaseHandler"
+import { getUserData, writeUserData } from "./databaseHandler"
 import { controller } from "./controller"
 import { swapToLocationStatus } from "./discordRp"
 import { randomUUID } from "crypto"
 import { liveSplitManager } from "./livesplit/liveSplitManager"
 import { handleMultiplayerEvent } from "./multiplayer/multiplayerService"
 import { handleEvent } from "@peacockproject/statemachine-parser"
-import picocolors from "picocolors"
 import { encodePushMessage } from "./multiplayer/multiplayerUtils"
 import {
     ActorTaggedC2SEvent,
@@ -65,6 +59,7 @@ import {
     SpottedC2SEvent,
     WitnessesC2SEvent,
 } from "./types/events"
+import picocolors from "picocolors"
 
 const eventRouter = Router()
 
@@ -682,14 +677,20 @@ function saveEvents(
             case "IntroCutEnd":
                 if (!session.timerStart) {
                     session.timerStart = event.Timestamp
+                    log(
+                        LogLevel.DEBUG,
+                        `Mission started at: ${session.timerStart}`,
+                    )
                 }
                 break
             case "exit_gate":
                 session.timerEnd = event.Timestamp
+                log(LogLevel.DEBUG, `Mission ended at: ${session.timerEnd}`)
                 break
             case "ContractEnd":
                 if (!session.timerEnd) {
                     session.timerEnd = event.Timestamp
+                    log(LogLevel.DEBUG, `Mission ended at: ${session.timerEnd}`)
                 }
                 break
             case "ObjectiveCompleted":
@@ -799,31 +800,4 @@ function saveEvents(
     return response
 }
 
-export async function saveSession(
-    sessionId: string,
-    token: string,
-): Promise<void> {
-    if (!contractSessions.has(sessionId)) {
-        log(LogLevel.WARN, `Refusing to save ${sessionId} as it doesn't exist`)
-        return
-    }
-
-    await writeContractSession(
-        token + "_" + sessionId,
-        contractSessions.get(sessionId)!,
-    )
-}
-
-export async function loadSession(
-    sessionId: string,
-    token: string,
-    sessionData?: ContractSession,
-): Promise<void> {
-    if (!sessionData) {
-        sessionData = await getContractSession(token + "_" + sessionId)
-    }
-
-    contractSessions.set(sessionId, sessionData)
-}
-
 export { eventRouter }