Add PD2 damage calculator

api/.env.example

@@ -18,7 +18,7 @@ REDIS_PASSWORD=
 # Season Configuration (for default)
 CURRENT_SEASON=13
 
-# CORS
+# CORS (comma-separated origins are supported)
 CORS_ORIGIN=*
 
 # Rate Limiting

api/src/config/index.ts

@@ -3,6 +3,20 @@ import logger from "node-color-log";
 
 dotenv.config();
 
+const defaultCorsOrigins = [
+  "http://localhost:4173",
+  "http://127.0.0.1:4173",
+  "http://localhost:4174",
+  "http://127.0.0.1:4174",
+  "http://localhost:5173",
+  "http://127.0.0.1:5173",
+];
+
+const corsOrigins = (process.env.CORS_ORIGIN || defaultCorsOrigins.join(","))
+  .split(",")
+  .map((origin) => origin.trim())
+  .filter(Boolean);
+
 export const config = {
   // Node environment
   nodeEnv: process.env.NODE_ENV || "development",
@@ -33,7 +47,7 @@ export const config = {
   currentSeason: parseInt(process.env.CURRENT_SEASON || "13", 10),
 
   // CORS
-  corsOrigin: process.env.CORS_ORIGIN || "http://localhost:5173",
+  corsOrigin: corsOrigins.length === 1 ? corsOrigins[0] : corsOrigins,
 
   // Rate limiting
   rateLimit: {

api/src/index.ts

@@ -1,18 +1,23 @@
 import { createServer, startServer } from "./server";
-import { closeAllDatabases } from "./database";
+import { characterDB, closeAllDatabases, economyDB } from "./database";
 import { initializeRedis, closeRedis } from "./utils/cache";
 import { logger as mainLogger } from "./config";
 
 const logger = mainLogger.createNamedLogger("API");
 
-// Initialize Redis
-initializeRedis().catch((err) => {
-  logger.error("Failed to initialize Redis on startup", { error: err });
-});
+async function main(): Promise<void> {
+  try {
+    await Promise.all([characterDB.ready, economyDB.ready, initializeRedis()]);
+
+    const app = createServer();
+    startServer(app);
+  } catch (error) {
+    logger.error("Failed to initialize API", { error });
+    process.exit(1);
+  }
+}
 
-// Create and start the server
-const app = createServer();
-startServer(app);
+void main();
 
 // Graceful shutdown
 process.on("SIGTERM", async () => {

api/src/jobs.ts

@@ -2,19 +2,29 @@ import { startCharacterScraper } from "./jobs/character-scraper";
 import { startOnlinePlayersTracker } from "./jobs/online-players-tracker";
 import { startLeaderboardUpdater } from "./jobs/leaderboard-updater";
 import { logger as mainLogger } from "./config";
+import { characterDB, economyDB } from "./database";
 
 const logger = mainLogger.createNamedLogger("Jobs");
 /* We use a seperate jobs.ts file instead of placing it all in the main index.ts since we scale to 20 instances of the API in production */
 
-//Start background jobs
-startCharacterScraper().catch((error) => {
-  logger.error("Failed to start character scraper:", error);
-});
+async function main(): Promise<void> {
+  await Promise.all([characterDB.ready, economyDB.ready]);
 
-startOnlinePlayersTracker().catch((error) => {
-  logger.error("Failed to start online players tracker:", error);
-});
+  // Start background jobs after the database schema is ready.
+  startCharacterScraper().catch((error) => {
+    logger.error("Failed to start character scraper:", error);
+  });
+
+  startOnlinePlayersTracker().catch((error) => {
+    logger.error("Failed to start online players tracker:", error);
+  });
+
+  startLeaderboardUpdater().catch((error) => {
+    logger.error("Failed to start leaderboard updater:", error);
+  });
+}
 
-startLeaderboardUpdater().catch((error) => {
-  logger.error("Failed to start leaderboard updater:", error);
+void main().catch((error) => {
+  logger.error("Failed to initialize jobs", { error });
+  process.exit(1);
 });

api/src/routes/characters.ts

@@ -11,12 +11,46 @@ import {
   deleteCachePattern,
 } from "../utils/cache";
 import { calculateTotalSkills } from "../utils/skill-calculator";
-import { CharacterResponse } from "../types";
+import { CharacterResponse, CharacterData } from "../types";
 import fetch from "node-fetch";
+import { calculateDamage } from "../utils/damage-calculator";
+import { enrichArmoryPayload } from "../utils/armory-payload";
 
 const logger = mainLogger.createNamedLogger("API");
 const router = Router();
 
+function hasDamageCalculatorInput(
+  data: Partial<CharacterData> | null | undefined
+): data is CharacterData {
+  const character = data?.character;
+
+  return Boolean(
+    character &&
+      Array.isArray(data?.items) &&
+      Array.isArray(character.skills) &&
+      character.class?.name &&
+      character.attributes
+  );
+}
+
+function attachDamageCalculation(
+  data: Partial<CharacterData> | null | undefined
+) {
+  if (!hasDamageCalculatorInput(data)) {
+    return;
+  }
+
+  try {
+    enrichArmoryPayload(data);
+    data.damageCalculation = calculateDamage(data);
+  } catch (error: unknown) {
+    logger.warn("Damage calculation failed", {
+      character: data.character?.name,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
 const characterRefreshLimiter = rateLimit({
   windowMs: 60 * 60 * 1000,
   max: 10,
@@ -122,9 +156,7 @@ router.get(
       const { name } = req.params;
       const { gameMode = "softcore", season } = req.query;
 
-      const seasonNumber = season
-        ? parseInt(season as string, 10)
-        : config.currentSeason;
+      const seasonNumber = season ? parseInt(season as string, 10) : undefined;
       const MODES = ["hardcore", "softcore"];
 
       let character = await characterDB.getCharacterByName(
@@ -146,8 +178,8 @@ router.get(
         }
       }
 
-      //TODO: pass season param and remove this
-      if (!character) {
+      // Keep explicit-season links tolerant of the previous default-season behavior.
+      if (!character && seasonNumber !== undefined) {
         for (const gm of MODES) {
           character = await characterDB.getCharacterByName(
             gm,
@@ -164,12 +196,15 @@ router.get(
       }
 
       // Calculate realStats from items before returning
+      enrichArmoryPayload(character as unknown as Partial<CharacterData>);
       if (character.items && character.items.length > 0) {
         // @ts-expect-error - character structure is validated by DB
         const statParser = new CharacterStatParser(character);
         character.realStats = statParser.parseAndGetCharStats();
       }
 
+      attachDamageCalculation(character as unknown as Partial<CharacterData>);
+
       res.json(character);
     } catch (error: unknown) {
       logger.error("Error fetching character", {
@@ -293,12 +328,15 @@ router.get(
       }
 
       // Calculate realStats from items before returning
+      enrichArmoryPayload(snapshot as unknown as Partial<CharacterData>);
       if (snapshot.items && snapshot.items.length > 0) {
         // @ts-expect-error - snapshot structure is validated by DB
         const statParser = new CharacterStatParser(snapshot);
         snapshot.realStats = statParser.parseAndGetCharStats();
       }
 
+      attachDamageCalculation(snapshot as unknown as Partial<CharacterData>);
+
       res.json(snapshot);
     } catch (error: unknown) {
       logger.error("Error fetching character snapshot", {
@@ -724,6 +762,7 @@ router.post("/:name/refresh", characterRefreshLimiter, async (req: Request, res:
 
     // Set lastUpdated and calculate realSkills (same as scraper does)
     charData.lastUpdated = now;
+    enrichArmoryPayload(charData as unknown as Partial<CharacterData>);
     charData.realSkills = calculateTotalSkills(
       charData as unknown as CharacterResponse
     );
@@ -754,12 +793,15 @@ router.post("/:name/refresh", characterRefreshLimiter, async (req: Request, res:
     }
 
     // Calculate realStats from items (same as GET endpoint does)
+    enrichArmoryPayload(updatedChar as unknown as Partial<CharacterData>);
     if (updatedChar.items && updatedChar.items.length > 0) {
       // @ts-expect-error - character structure is validated by DB
       const statParser = new CharacterStatParser(updatedChar);
       updatedChar.realStats = statParser.parseAndGetCharStats();
     }
 
+    attachDamageCalculation(updatedChar as unknown as Partial<CharacterData>);
+
     logger.info(`Character ${name} successfully refreshed`);
 
     // Return same format as GET endpoint (character directly, not wrapped)

api/src/routes/routes.test.ts

@@ -7,6 +7,19 @@ import statisticsRoutes from "./statistics";
 import healthRoutes from "./health";
 import leaderboardRoutes from "./leaderboard";
 import { characterDB, economyDB } from "../database";
+import { calculateDamage } from "../utils/damage-calculator";
+
+jest.mock("../utils/damage-calculator", () => ({
+  calculateDamage: jest.fn(() => ({
+    weaponOptions: [],
+    skillOptions: [],
+    playerAuraOptions: [],
+    transformationOptions: [],
+    alwaysActiveAuras: [],
+    profiles: [],
+    notes: [],
+  })),
+}));
 
 jest.mock("../utils/cache", () => ({
   getCacheValue: jest.fn(() => Promise.resolve(undefined)), // Default: no cache hit
@@ -291,7 +304,7 @@ describe("API Routes", () => {
         expect(characterDB.getCharacterByName).toHaveBeenCalledWith(
           "softcore",
           "TestChar",
-          12
+          undefined
         );
       });
 
@@ -306,7 +319,7 @@ describe("API Routes", () => {
         expect(characterDB.getCharacterByName).toHaveBeenCalledWith(
           "hardcore",
           "TestChar",
-          12
+          undefined
         );
       });
 
@@ -350,6 +363,33 @@ describe("API Routes", () => {
           error: { message: "Failed to fetch character" },
         });
       });
+
+      it("should return character data when damage calculation fails", async () => {
+        const mockCharacter = {
+          character: {
+            name: "TestChar",
+            level: 90,
+            class: { name: "Druid" },
+            attributes: {},
+            skills: [],
+          },
+          items: [],
+        };
+
+        (characterDB.getCharacterByName as jest.Mock).mockResolvedValue(
+          mockCharacter
+        );
+        (calculateDamage as jest.Mock).mockImplementationOnce(() => {
+          throw new Error("Damage calculation error");
+        });
+
+        const response = await request(app)
+          .get("/api/v1/characters/TestChar")
+          .expect(200);
+
+        expect(response.body).toEqual(mockCharacter);
+        expect(calculateDamage).toHaveBeenCalled();
+      });
     });
 
     describe("GET /api/v1/characters/accounts/:accountName", () => {