refactor: Make inventory class-based (#678)

<!-- Thanks for contributing to Peacock! Here's a bit of a template to
help make sure everything relevant is covered. -->

## Scope

<!-- List any relevant changes you have made here. Be sure to link any
issues fixed, or that are relevant to these changes. -->
Two big changes here:
1. inventory is a class now, so the stateful parts are not stored on a
module level
2. controller instance can be overridden for tests, so that code which
hasn't yet been migrated to the IoC model can use the intended
controller instance.

## Test Plan

<!-- List how you have verified these changes work as intended. -->

- Start the server, verify that logging in still works

## Checklist

<!--
Once you create the PR, the checklist will be added below this comment
automatically (based on what files you've changed).
It's just a few reminders to make sure everything is perfect. You can
place an "X" in the boxes to tick them off.
When you have completed the checklist, press the "Ready for review"
button.
-->


--------
#### General
- [x] I've run Prettier to format any changed files
- [x] I've verified that my changes work, and included a test plan

--------
#### Testing
- [x] I have added or considered adding unit/integration tests that
cover any code changes

Author: RDIL

components/candle/challengeService.ts

@@ -68,7 +68,6 @@ import { getVersionedConfig } from "../configSwizzleManager"
 import { SyncHook } from "../hooksImpl"
 import { getUserEscalationProgress } from "../contracts/escalations/escalationService"
 
-import { getUnlockableById } from "../inventory"
 import { enqueueEvent } from "../eventHandler"
 import { randomUUID } from "crypto"
 
@@ -1574,7 +1573,7 @@ export class ChallengeService extends ChallengeRegistry {
         isDestination = false,
     ): CompiledChallengeTreeData {
         const drops = challenge.Drops.map((e) =>
-            getUnlockableById(e, gameVersion),
+            this.controller.inventoryService.getUnlockableById(e, gameVersion),
         ).filter(Boolean) as Unlockable[]
 
         if (drops.length !== challenge.Drops.length) {

components/candle/masteryService.ts

@@ -47,7 +47,7 @@ import {
     xpRequiredForSniperLevel,
 } from "../utils"
 
-import { getUnlockablesById } from "../inventory"
+import { controller } from "../controller"
 import assert from "assert"
 
 export class MasteryService {
@@ -395,7 +395,7 @@ export class MasteryService {
         }
 
         // Get all unlockables with matching Ids
-        const unlockableData = getUnlockablesById(
+        const unlockableData = controller.inventoryService.getUnlockablesById(
             Array.from(dropIdSet),
             gameVersion,
         )

components/candle/progressionService.ts

@@ -18,7 +18,6 @@
 
 import { getSubLocationByName } from "../contracts/dataGen"
 import { controller } from "../controller"
-import { getUnlockablesById, grantDrops } from "../inventory"
 import type {
     ContractSession,
     GameVersion,
@@ -74,11 +73,11 @@ export class ProgressionService {
         // Award provided drops. E.g. From challenges. Don't run this function
         // if there aren't any drops being granted.
         if (dropIds.length > 0) {
-            grantDrops(
+            controller.inventoryService.grantDrops(
                 userProfile.Id,
-                getUnlockablesById(dropIds, contractSession.gameVersion).filter(
-                    Boolean,
-                ) as Unlockable[],
+                controller.inventoryService
+                    .getUnlockablesById(dropIds, contractSession.gameVersion)
+                    .filter(Boolean) as Unlockable[],
             )
         }
 
@@ -116,7 +115,10 @@ export class ProgressionService {
             .filter((drop) => drop.Level > minLevel && drop.Level <= maxLevel)
             .map((drop) => drop.Id)
 
-        const unlockables = getUnlockablesById(unlockableIds, gameVersion)
+        const unlockables = controller.inventoryService.getUnlockablesById(
+            unlockableIds,
+            gameVersion,
+        )
 
         /**
          * If missions type is evergreen, checks if any of the unlockables has unlockable gear, and award those too
@@ -134,7 +136,7 @@ export class ProgressionService {
 
             if (evergreenGearUnlockables.length) {
                 unlockables.push(
-                    ...getUnlockablesById(
+                    ...controller.inventoryService.getUnlockablesById(
                         evergreenGearUnlockables,
                         gameVersion,
                     ),
@@ -234,7 +236,10 @@ export class ProgressionService {
                         previousLevel,
                         locationData.Level,
                     ).filter(Boolean) as Unlockable[]
-                    grantDrops(userProfile.Id, masteryLocationDrops)
+                    controller.inventoryService.grantDrops(
+                        userProfile.Id,
+                        masteryLocationDrops,
+                    )
                 }
             }
 

components/controller.ts

@@ -47,6 +47,7 @@ import { log, LogLevel } from "./loggingInterop"
 import * as axios from "axios"
 import {
     addDashesToPublicId,
+    deprecated,
     fastClone,
     getRemoteService,
     hitmapsUrl,
@@ -69,12 +70,14 @@ import { ChallengeFilterType, Pro1FilterType } from "./candle/challengeHelpers"
 import { MasteryService } from "./candle/masteryService"
 import { MasteryPackage } from "./types/mastery"
 import { ProgressionService } from "./candle/progressionService"
+import { InventoryService } from "./inventory"
 import generatedPeacockRequireTable from "./generatedPeacockRequireTable"
 import { escalationTypes } from "./contracts/escalations/escalationService"
 import { orderedETAs } from "./contracts/elusiveTargetArcades"
 import { SMFSupport } from "./smfSupport"
 import { glob } from "fast-glob"
 import { asyncGuard } from "./databaseHandler"
+import { createDelegatingProxy } from "./delegation"
 
 /**
  * An array of string arrays that contains the IDs of the featured contracts.
@@ -392,6 +395,7 @@ export class Controller {
     public masteryService!: MasteryService
     escalationMappings: Map<string, Record<string, string>> = new Map()
     public progressionService!: ProgressionService
+    public inventoryService!: InventoryService
     public smf!: SMFSupport
     private _pubIdToContractId: Map<string, string> = new Map()
     /** Internal elusive target contracts - only accessible during bootstrap. */
@@ -420,6 +424,49 @@ export class Controller {
             onEscalationReset: new SyncHook(),
             onUserLogin: new SyncHook(),
         }
+
+        this.inventoryService = new InventoryService(this)
+    }
+
+    private _patchRequireTableInventory(): void {
+        const inventoryServiceMethods = new Set([
+            "clearInventoryFor",
+            "clearInventoryCache",
+            "getUnlockableById",
+            "getUnlockablesById",
+            "getDefaultSuitFor",
+            "createInventory",
+            "grantDrops",
+        ])
+
+        const service = this.inventoryService
+
+        const key =
+            "@peacockproject/core/inventory" as keyof typeof generatedPeacockRequireTable
+
+        const original = generatedPeacockRequireTable[key]
+
+        // @ts-expect-error Patching the generated table at runtime.
+        generatedPeacockRequireTable[key] = new Proxy(original, {
+            get(target, prop, receiver) {
+                if (
+                    typeof prop === "string" &&
+                    inventoryServiceMethods.has(prop)
+                ) {
+                    deprecated(
+                        `inventory.${prop}`,
+                        `controller.inventoryService.${prop}`,
+                        "v9",
+                    )
+
+                    return (...args: unknown[]) =>
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        (service as any)[prop](...args)
+                }
+
+                return Reflect.get(target, prop, receiver)
+            },
+        })
     }
 
     /**
@@ -467,11 +514,7 @@ export class Controller {
      * @throws {Error} If all hope is lost. (In theory, this should never happen)
      */
     async boot(pluginDevHost: boolean): Promise<void> {
-        // this should never actually be hit, but it makes IntelliJ not
-        // complain that it's unused, so...
-        if (!this.configManager) {
-            throw new Error("All hope is lost.")
-        }
+        this._patchRequireTableInventory()
 
         log(
             LogLevel.INFO,
@@ -1526,4 +1569,18 @@ export async function preserveContracts(
     }
 }
 
-export const controller = new Controller()
+// We need to be able to swap out the global controller instance in tests without invalidating the module graph.
+// This lets us do that until we can get everything to use the IoC model.
+const controllerContainer = { instance: new Controller() }
+
+export const controller: Controller = createDelegatingProxy(controllerContainer)
+
+/**
+ * Replaces the global controller instance. Don't use outside of tests.
+ * @internal
+ */
+export function _dangerouslyOverwriteController(
+    newController: Controller,
+): void {
+    controllerContainer.instance = newController
+}

components/delegation.ts

@@ -0,0 +1,57 @@
+/*
+ *     The Peacock Project - a HITMAN server replacement.
+ *     Copyright (C) 2021-2026 The Peacock Project Team
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU Affero General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU Affero General Public License for more details.
+ *
+ *     You should have received a copy of the GNU Affero General Public License
+ *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+interface DelegationContainer<T extends object> {
+    instance: T
+}
+
+/**
+ * Creates a proxy that transparently delegates all operations to
+ * `container.instance`. Swapping `container.instance` changes what
+ * the proxy delegates to, without changing the proxy's identity.
+ */
+export function createDelegatingProxy<T extends object>(
+    container: DelegationContainer<T>,
+): T {
+    return new Proxy(Object.create(null) as T, {
+        get(_target, prop, receiver) {
+            const value = Reflect.get(container.instance, prop, receiver)
+
+            if (typeof value === "function") {
+                return value.bind(container.instance)
+            }
+
+            return value
+        },
+        set(_target, prop, value) {
+            return Reflect.set(container.instance, prop, value)
+        },
+        has(_target, prop) {
+            return Reflect.has(container.instance, prop)
+        },
+        ownKeys() {
+            return Reflect.ownKeys(container.instance)
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            return Reflect.getOwnPropertyDescriptor(container.instance, prop)
+        },
+        getPrototypeOf() {
+            return Reflect.getPrototypeOf(container.instance)
+        },
+    })
+}