CODEBASE: Validate AllGangs and StockMarket after loading with JSON.parse

package.json

@@ -24,6 +24,7 @@
     "acorn": "^8.11.3",
     "acorn-jsx-walk": "^2.0.0",
     "acorn-walk": "^8.3.2",
+    "ajv": "^8.17.1",
     "arg": "^5.0.2",
     "bcryptjs": "^2.4.3",
     "better-react-mathjax": "^2.0.3",

src/Gang/AllGangs.ts

@@ -1,12 +1,14 @@
 import { FactionName } from "@enums";
 import { Reviver } from "../utils/JSONReviver";
+import { JsonSchemaValidator } from "../JsonSchema/JsonSchemaValidator";
+import { dialogBoxCreate } from "../ui/React/DialogBox";
 
 interface GangTerritory {
   power: number;
   territory: number;
 }
 
-function getDefaultAllGangs() {
+export function getDefaultAllGangs() {
   return {
     [FactionName.SlumSnakes]: {
       power: 1,
@@ -46,7 +48,26 @@ export function resetGangs(): void {
 }
 
 export function loadAllGangs(saveString: string): void {
-  AllGangs = JSON.parse(saveString, Reviver);
+  let allGangsData: unknown;
+  let validate;
+  try {
+    allGangsData = JSON.parse(saveString, Reviver);
+    validate = JsonSchemaValidator.AllGangs;
+    if (!validate(allGangsData)) {
+      console.error("validate.errors:", validate.errors);
+      // validate.errors is an array of objects, so we need to use JSON.stringify.
+      throw new Error(JSON.stringify(validate.errors));
+    }
+  } catch (error) {
+    console.error(error);
+    console.error("Invalid AllGangsSave:", saveString);
+    resetGangs();
+    setTimeout(() => {
+      dialogBoxCreate(`Cannot load data of AllGangs. AllGangs is reset. Error: ${error}.`);
+    }, 1000);
+    return;
+  }
+  AllGangs = allGangsData;
 }
 
 export function getClashWinChance(thisGang: string, otherGang: string): number {

src/JsonSchema/Data/AllGangsSchema.ts

@@ -0,0 +1,42 @@
+import { JSONSchemaType } from "ajv";
+import type { AllGangs } from "../../Gang/AllGangs";
+import { FactionName } from "@enums";
+
+export const AllGangsSchema: JSONSchemaType<typeof AllGangs> = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  patternProperties: {
+    ".*": {
+      type: "object",
+      properties: {
+        power: {
+          type: "number",
+        },
+        territory: {
+          type: "number",
+        },
+      },
+      required: ["power", "territory"],
+    },
+  },
+  propertyNames: {
+    enum: [
+      FactionName.SlumSnakes,
+      FactionName.Tetrads,
+      FactionName.TheSyndicate,
+      FactionName.TheDarkArmy,
+      FactionName.SpeakersForTheDead,
+      FactionName.NiteSec,
+      FactionName.TheBlackHand,
+    ],
+  },
+  required: [
+    FactionName.SlumSnakes,
+    FactionName.Tetrads,
+    FactionName.TheSyndicate,
+    FactionName.TheDarkArmy,
+    FactionName.SpeakersForTheDead,
+    FactionName.NiteSec,
+    FactionName.TheBlackHand,
+  ],
+};

src/JsonSchema/Data/StockMarketSchema.ts

@@ -0,0 +1,138 @@
+import { OrderType, PositionType, StockSymbol } from "@enums";
+import { getKeyList } from "../../utils/helpers/getKeyList";
+import { Stock } from "../../StockMarket/Stock";
+import { Order } from "../../StockMarket/Order";
+
+const stockSymbolKeys = Object.keys(StockSymbol);
+const stockSymbolValues = Object.values(StockSymbol);
+const stockKeys = getKeyList(Stock);
+const orderKeys = getKeyList(Order);
+
+/**
+ * It's intentional to not use JSONSchemaType here. The data structure of StockMarket is not suitable for the usage of
+ * JSONSchemaType. These are 2 biggest problems:
+ * - IStockMarket is an intersection type. In our case, satisfying TS's type-checking for JSONSchemaType is too hard.
+ * - Stock and Order are classes, not interfaces or types. In those classes, we have functions, but functions are not
+ * supported by JSON (without ugly hacks). Let's use the "Order" class as an example. The Order class has the toJSON
+ * function, so ajv forces us to define the "toJSON" property. If we define it, we have to give it a "type". In
+ * JavaScript, a function is just an object, so the naive solution is to use {type:"object"}. However, the generated
+ * validation code uses "typeof" to check the data. "typeof functionName" is "function", not "object", so ajv sees it as
+ * invalid data. There are some ways to work around this problem, but all of them are complicated. In the end,
+ * JSONSchemaType is only a utility type. If our schema is designed and tested properly, after the validation, we can
+ * typecast the data.
+ */
+export const StockMarketSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  patternProperties: {
+    "^(?!.*(lastUpdate|Orders|storedCycles|ticksUntilCycle))": {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        b: {
+          type: "boolean",
+        },
+        cap: {
+          type: "number",
+        },
+        lastPrice: {
+          type: "number",
+        },
+        maxShares: {
+          type: "number",
+        },
+        mv: {
+          type: "number",
+        },
+        name: {
+          type: "string",
+          enum: [...stockSymbolKeys],
+        },
+        otlkMag: {
+          type: "number",
+        },
+        otlkMagForecast: {
+          type: "number",
+        },
+        playerAvgPx: {
+          type: "number",
+        },
+        playerAvgShortPx: {
+          type: "number",
+        },
+        playerShares: {
+          type: "number",
+        },
+        playerShortShares: {
+          type: "number",
+        },
+        price: {
+          type: "number",
+        },
+        shareTxForMovement: {
+          type: "number",
+        },
+        shareTxUntilMovement: {
+          type: "number",
+        },
+        spreadPerc: {
+          type: "number",
+        },
+        symbol: {
+          type: "string",
+          enum: [...stockSymbolValues],
+        },
+        totalShares: {
+          type: "number",
+        },
+      },
+      required: [...stockKeys],
+    },
+  },
+  properties: {
+    lastUpdate: { type: "number" },
+    Orders: {
+      type: "object",
+      patternProperties: {
+        ".*": {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              pos: {
+                type: "string",
+                enum: [PositionType.Long, PositionType.Short],
+              },
+              price: {
+                type: "number",
+              },
+              shares: {
+                type: "number",
+              },
+              stockSymbol: {
+                type: "string",
+                enum: [...stockSymbolValues],
+              },
+              type: {
+                type: "string",
+                enum: [OrderType.LimitBuy, OrderType.LimitSell, OrderType.StopBuy, OrderType.StopSell],
+              },
+            },
+            required: [...orderKeys],
+          },
+        },
+      },
+      propertyNames: {
+        enum: [...stockSymbolValues],
+      },
+      required: [],
+    },
+    storedCycles: { type: "number" },
+    ticksUntilCycle: { type: "number" },
+  },
+  propertyNames: {
+    enum: [...stockSymbolKeys, "lastUpdate", "Orders", "storedCycles", "ticksUntilCycle"],
+  },
+  required: ["lastUpdate", "Orders", "storedCycles", "ticksUntilCycle"],
+};

src/JsonSchema/JsonSchemaValidator.ts

@@ -0,0 +1,10 @@
+import Ajv from "ajv";
+import { AllGangsSchema } from "./Data/AllGangsSchema";
+import { StockMarketSchema } from "./Data/StockMarketSchema";
+
+const ajv = new Ajv();
+
+export const JsonSchemaValidator = {
+  AllGangs: ajv.compile(AllGangsSchema),
+  StockMarket: ajv.compile(StockMarketSchema),
+};

src/StockMarket/StockMarket.tsx

@@ -16,13 +16,19 @@ import { Reviver } from "../utils/JSONReviver";
 import { NetscriptContext } from "../Netscript/APIWrapper";
 import { helpers } from "../Netscript/NetscriptHelpers";
 import { getRandomIntInclusive } from "../utils/helpers/getRandomIntInclusive";
+import { JsonSchemaValidator } from "../JsonSchema/JsonSchemaValidator";
+import { Player } from "../Player";
 
-export let StockMarket: IStockMarket = {
-  lastUpdate: 0,
-  Orders: {},
-  storedCycles: 0,
-  ticksUntilCycle: 0,
-} as IStockMarket; // Maps full stock name -> Stock object
+export function getDefaultEmptyStockMarket(): IStockMarket {
+  return {
+    lastUpdate: 0,
+    Orders: {},
+    storedCycles: 0,
+    ticksUntilCycle: 0,
+  } as IStockMarket;
+}
+
+export let StockMarket = getDefaultEmptyStockMarket(); // Maps full stock name -> Stock object
 // Gross type, needs to be addressed
 export const SymbolToStockMap: Record<string, Stock> = {}; // Maps symbol -> Stock object
 
@@ -130,27 +136,41 @@ export function cancelOrder(params: ICancelOrderParams, ctx?: NetscriptContext):
 }
 
 export function loadStockMarket(saveString: string): void {
-  if (saveString === "") {
-    StockMarket = {
-      lastUpdate: 0,
-      Orders: {},
-      storedCycles: 0,
-      ticksUntilCycle: 0,
-    } as IStockMarket;
-  } else StockMarket = JSON.parse(saveString, Reviver);
+  let stockMarketData: unknown;
+  let validate;
+  try {
+    stockMarketData = JSON.parse(saveString, Reviver);
+    validate = JsonSchemaValidator.StockMarket;
+    if (!validate(stockMarketData)) {
+      console.error("validate.errors:", validate.errors);
+      // validate.errors is an array of objects, so we need to use JSON.stringify.
+      throw new Error(JSON.stringify(validate.errors));
+    }
+  } catch (error) {
+    console.error(error);
+    console.error("Invalid StockMarketSave:", saveString);
+    deleteStockMarket();
+    if (Player.hasWseAccount) {
+      initStockMarket();
+    }
+    const errorMessage = `Cannot load data of StockMarket. StockMarket is reset.`;
+    setTimeout(() => {
+      dialogBoxCreate(errorMessage);
+    }, 1000);
+    return;
+  }
+  // Typecasting here is fine because we validated the loaded data.
+  StockMarket = stockMarketData as IStockMarket;
 }
 
 export function deleteStockMarket(): void {
-  StockMarket = {
-    lastUpdate: 0,
-    Orders: {},
-    storedCycles: 0,
-    ticksUntilCycle: 0,
-  } as IStockMarket;
+  StockMarket = getDefaultEmptyStockMarket();
 }
 
 export function initStockMarket(): void {
+  console.log(Object.getOwnPropertyNames(StockMarket));
   for (const stockName of Object.getOwnPropertyNames(StockMarket)) {
+    console.log(stockName);
     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
     delete StockMarket[stockName];
   }

test/jest/JsonSchema/AllGangsSchema.test.ts

@@ -0,0 +1,41 @@
+import { getDefaultAllGangs } from "../../../src/Gang/AllGangs";
+import { JsonSchemaValidator } from "../../../src/JsonSchema/JsonSchemaValidator";
+
+describe("Success", () => {
+  test("Default AllGangs", () => {
+    const defaultAllGangs = getDefaultAllGangs();
+    expect(JsonSchemaValidator.AllGangs(defaultAllGangs)).toStrictEqual(true);
+  });
+});
+
+describe("Failure", () => {
+  test("Do not have all gangs", () => {
+    const defaultAllGangs = getDefaultAllGangs() as Record<string, unknown>;
+    delete defaultAllGangs["Slum Snakes"];
+    expect(JsonSchemaValidator.AllGangs(defaultAllGangs)).toStrictEqual(false);
+  });
+  test("Have an unexpected gang", () => {
+    const defaultAllGangs = getDefaultAllGangs() as Record<string, unknown>;
+    defaultAllGangs["CyberSec"] = {
+      power: 1,
+      territory: 1 / 7,
+    };
+    expect(JsonSchemaValidator.AllGangs(defaultAllGangs)).toStrictEqual(false);
+  });
+  test("Have invalid power", () => {
+    const defaultAllGangs = getDefaultAllGangs() as Record<string, unknown>;
+    defaultAllGangs["Slum Snakes"] = {
+      power: "1",
+      territory: 1 / 7,
+    };
+    expect(JsonSchemaValidator.AllGangs(defaultAllGangs)).toStrictEqual(false);
+  });
+  test("Have invalid territory", () => {
+    const defaultAllGangs = getDefaultAllGangs() as Record<string, unknown>;
+    defaultAllGangs["Slum Snakes"] = {
+      power: 1,
+      territory: "1 / 7",
+    };
+    expect(JsonSchemaValidator.AllGangs(defaultAllGangs)).toStrictEqual(false);
+  });
+});