@vatvaghool/create-ipl-dashboard 0.1.0

package/template/tests/ipl-transform.test.ts

@@ -0,0 +1,590 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import type {
+  DashboardData,
+  RawApiUser,
+  ScrapedDashboardPayload,
+  ScrapedLeaderboardItem,
+} from "../app/types.ts";
+import {
+  addLeaderboardMetrics,
+  buildDashboardFromSnapshot,
+  buildManualDashboard,
+  normalizePayload,
+  normalizeRawApiUsers,
+  serializeRawApiUsersModule,
+  syncRawUsersWithSnapshot,
+  toFiniteNumber,
+} from "../app/api/ipl/transform.ts";
+
+describe("IPL data transformation", () => {
+  it("parses finite numbers from numeric and comma-formatted values", () => {
+    assert.equal(toFiniteNumber(1200), 1200);
+    assert.equal(toFiniteNumber("7,125.5"), 7125.5);
+    assert.equal(toFiniteNumber("0"), 0);
+    assert.equal(toFiniteNumber("abc"), undefined);
+    assert.equal(toFiniteNumber(null), undefined);
+  });
+
+  it("normalizes scraped payloads by trimming names, coercing numbers, and sorting ranks", () => {
+    const payload = normalizePayload({
+      updatedAt: "2026-04-18T10:55:57.567Z",
+      completedMatches: "39",
+      leaders: [
+        {
+          rank: "2",
+          name: " Watapi ",
+          points: "6,281",
+          lastMatchPoints: "62",
+          transfersLeft: "106",
+          boostersUsed: " 0 ",
+        },
+        {
+          rank: "1",
+          name: "Deccan Dominators",
+          points: "7,125",
+          lastMatchPoints: "52.5",
+          transfersLeft: "101",
+          boostersUsed: "1",
+        },
+        {
+          rank: "bad",
+          name: "Ignored",
+          points: 99,
+        },
+      ],
+    });
+
+    assert.ok(payload);
+    assert.equal(payload.leaders.length, 2);
+    assert.equal(payload.leaders[0].name, "Deccan Dominators");
+    assert.equal(payload.leaders[0].points, 7125);
+    assert.equal(payload.leaders[0].lastMatchPoints, 52.5);
+    assert.equal(payload.leaders[0].transfersLeft, 101);
+    assert.equal(payload.leaders[1].name, "Watapi");
+    assert.equal(payload.leaders[1].boostersUsed, "0");
+    assert.equal(payload.updatedAt, "2026-04-18T10:55:57.567Z");
+    assert.equal(payload.completedMatches, 39);
+  });
+
+  it("normalizes a raw leaderboard array with net point context", () => {
+    const payload = normalizePayload([
+      {
+        rank: 1,
+        name: "Deccan Dominators",
+        points: 11627,
+        lastMatchPoints: 461,
+        netPoints: 11166,
+        netRank: 1,
+        transfersLeft: "87",
+        boostersUsed: "2",
+      },
+    ]);
+
+    assert.ok(payload);
+    assert.equal(payload.leaders[0].points, 11627);
+    assert.equal(payload.leaders[0].netPoints, 11166);
+    assert.equal(payload.leaders[0].netRank, 1);
+    assert.equal(payload.leaders[0].transfersLeft, 87);
+  });
+
+  it("normalizes nested fantasy payloads from Data.Value", () => {
+    const payload = normalizePayload({
+      Data: {
+        Value: [
+          { rank: 1, temname: "Deccan Dominators", points: 12037 },
+          { rank: 2, usrname: "SquadSeven9", points: 9815.5 },
+        ],
+        FeedTime: {
+          UTCTime: "2026-04-27T04:04:37.000Z",
+        },
+      },
+      completedMatches: 39,
+    });
+
+    assert.ok(payload);
+    assert.equal(payload.leaders.length, 2);
+    assert.equal(payload.leaders[0].name, "Deccan Dominators");
+    assert.equal(payload.leaders[1].name, "SquadSeven9");
+    assert.equal(payload.completedMatches, 39);
+  });
+
+  it("normalizes bookmarklet-style payload fields", () => {
+    const payload = normalizePayload({
+      time: "2026-04-28T09:15:00.000Z",
+      match: 41,
+      leaders: [
+        {
+          rank: 1,
+          name: "VATVAGHOOL XI",
+          points: 7777.5,
+          last: 120.5,
+          transfersLeft: 5,
+          transfersUsed: 2,
+          totalTransfers: 7,
+          boosters: 0,
+          c: "Shubman Gill",
+          v: "Jasprit Bumrah",
+          cPoints: 88,
+          vPoints: 54,
+          players: ["Shubman Gill", { name: "Jasprit Bumrah", points: 54 }],
+        },
+      ],
+    });
+
+    assert.ok(payload);
+    assert.equal(payload.updatedAt, "2026-04-28T09:15:00.000Z");
+    assert.equal(payload.completedMatches, 41);
+    assert.equal(payload.leaders[0].name, "VATVAGHOOL XI");
+    assert.equal(payload.leaders[0].lastMatchPoints, 120.5);
+    assert.equal(payload.leaders[0].transfersLeft, 5);
+    assert.equal(payload.leaders[0].transfersUsed, 2);
+    assert.equal(payload.leaders[0].totalTransfers, 7);
+    assert.equal(payload.leaders[0].boostersUsed, "0");
+    assert.equal(payload.leaders[0].captain?.name, "Shubman Gill");
+    assert.equal(payload.leaders[0].captain?.points, 88);
+    assert.equal(payload.leaders[0].viceCaptain?.name, "Jasprit Bumrah");
+    assert.equal(payload.leaders[0].viceCaptain?.points, 54);
+    assert.deepEqual(
+      payload.leaders[0].players?.map((player) => ({
+        name: player.name,
+        points: player.points,
+      })),
+      [
+        { name: "Shubman Gill", points: undefined },
+        { name: "Jasprit Bumrah", points: 54 },
+      ],
+    );
+  });
+
+  it("rejects invalid scraped payloads", () => {
+    assert.equal(normalizePayload(null), null);
+    assert.equal(normalizePayload({}), null);
+    assert.equal(normalizePayload({ leaders: "nope" }), null);
+    assert.equal(
+      normalizePayload({
+        leaders: [{ rank: "?", name: "", points: "x" }],
+      }),
+      null,
+    );
+  });
+
+  it("normalizes raw users loaded from storage by sorting matches and recalculating totals", () => {
+    const users = normalizeRawApiUsers([
+      {
+        rno: "2",
+        temname: " Team B ",
+        points: 999,
+        matches: [
+          { matchId: "2", points: "15" },
+          { matchId: "1", points: "25" },
+        ],
+      },
+      {
+        rno: 1,
+        temname: "Team A",
+        matches: [{ matchId: 1, points: 10 }],
+      },
+      {
+        rno: 3,
+        temname: "Broken",
+        matches: [],
+      },
+    ]);
+
+    assert.ok(users);
+    assert.equal(users.length, 2);
+    assert.equal(users[0].temname, "Team A");
+    assert.equal(users[1].temname, "Team B");
+    assert.deepEqual(users[1].matches, [
+      { matchId: 1, points: 25 },
+      { matchId: 2, points: 15 },
+    ]);
+    assert.equal(users[1].points, 40);
+  });
+
+  it("adds rank movement, point gaps, efficiency, and latest-match winner flags", () => {
+    const leaders: ScrapedLeaderboardItem[] = [
+      {
+        rank: 3,
+        name: "Gamma",
+        points: 80,
+        lastMatchPoints: 0,
+        transfersLeft: 130,
+      },
+      {
+        rank: 1,
+        name: "Alpha",
+        points: 100,
+        lastMatchPoints: 10,
+        transfersLeft: 150,
+      },
+      {
+        rank: 2,
+        name: "Beta",
+        points: 95,
+        lastMatchPoints: 50,
+        transfersLeft: 155,
+      },
+    ];
+
+    const rows = addLeaderboardMetrics(leaders);
+
+    assert.deepEqual(
+      rows.map((row) => row.name),
+      ["Alpha", "Beta", "Gamma"],
+    );
+    assert.equal(rows[0].previousPoints, 90);
+    assert.equal(rows[0].gapToNext, 5);
+    assert.equal(rows[0].gapPercent, 25);
+    assert.equal(rows[0].movement, "same");
+    assert.equal(rows[0].efficiency, 10);
+    assert.equal(rows[1].movement, "up");
+    assert.equal(rows[1].isLastMatchLeader, true);
+    assert.equal(rows[1].efficiency, 19);
+    assert.equal(rows[2].movement, "down");
+    assert.equal(rows[2].gapToNext, 0);
+    assert.equal(rows[2].isLastMatchLeader, false);
+  });
+
+  it("uses scraped net points and net rank when provided", () => {
+    const rows = addLeaderboardMetrics([
+      {
+        rank: 2,
+        name: "Beta",
+        points: 120,
+        lastMatchPoints: 10,
+        netPoints: 110,
+        netRank: 1,
+      },
+      {
+        rank: 1,
+        name: "Alpha",
+        points: 125,
+        lastMatchPoints: 50,
+        netPoints: 75,
+        netRank: 2,
+      },
+    ]);
+
+    assert.equal(rows[0].name, "Alpha");
+    assert.equal(rows[0].previousPoints, 75);
+    assert.equal(rows[0].previousRank, 2);
+    assert.equal(rows[0].movement, "up");
+    assert.equal(rows[1].previousPoints, 110);
+    assert.equal(rows[1].previousRank, 1);
+    assert.equal(rows[1].movement, "down");
+  });
+
+  it("preserves captain and vice-captain data in overall rows", () => {
+    const rows = addLeaderboardMetrics([
+      {
+        rank: 1,
+        name: "Alpha",
+        points: 125,
+        lastMatchPoints: 50,
+        transfersLeft: 3,
+        transfersUsed: 8,
+        totalTransfers: 11,
+        boostersUsed: "1",
+        captain: { name: "Captain A", points: 91 },
+        viceCaptain: { name: "Vice A", points: 42 },
+        players: [{ name: "Captain A", points: 91 }, { name: "Vice A", points: 42 }],
+      },
+    ]);
+
+    assert.equal(rows[0].captain?.name, "Captain A");
+    assert.equal(rows[0].captain?.points, 91);
+    assert.equal(rows[0].viceCaptain?.name, "Vice A");
+    assert.equal(rows[0].viceCaptain?.points, 42);
+    assert.equal(rows[0].transfersLeft, 3);
+    assert.equal(rows[0].transfersUsed, 8);
+    assert.equal(rows[0].totalTransfers, 11);
+    assert.equal(rows[0].boostersUsed, "1");
+  });
+
+  it("builds manual dashboard data from raw match rows", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 1,
+        temname: "Team A",
+        points: 30,
+        matches: [
+          { matchId: 1, points: 10 },
+          { matchId: 2, points: 20 },
+        ],
+      },
+      {
+        rno: 2,
+        temname: "Team B",
+        points: 40,
+        matches: [
+          { matchId: 1, points: 25 },
+          { matchId: 2, points: 15 },
+        ],
+      },
+    ];
+
+    const dashboard = buildManualDashboard(users);
+
+    assert.equal(dashboard.source, "database");
+    assert.deepEqual(
+      dashboard.overall.map((row) => row.name),
+      ["Team B", "Team A"],
+    );
+    assert.equal(dashboard.overall[0].lastMatchPoints, 15);
+    assert.equal(dashboard.daily.length, 2);
+    assert.equal(dashboard.daily[0].day, "Match 1");
+    assert.equal(dashboard.daily[0]["Team B"], 25);
+    assert.equal(dashboard.daily[1]["Team A"], 20);
+    assert.equal(dashboard.completedMatches, 2);
+  });
+
+  it("merges live snapshots with manual daily rows when latest match points exist", () => {
+    const manualDashboard: DashboardData = {
+      source: "database",
+      overall: [],
+      daily: [{ day: "Match 1", Alpha: 10, Beta: 20 }],
+    };
+    const snapshot: ScrapedDashboardPayload = {
+      updatedAt: "2026-04-18T10:55:57.567Z",
+      leaders: [
+        {
+          rank: 1,
+          name: "Alpha",
+          points: 100,
+          lastMatchPoints: 55,
+        },
+        {
+          rank: 2,
+          name: "Beta",
+          points: 90,
+          lastMatchPoints: 44,
+        },
+      ],
+    };
+
+    const dashboard = buildDashboardFromSnapshot(snapshot, manualDashboard);
+
+    assert.equal(dashboard.source, "database");
+    assert.equal(dashboard.updatedAt, snapshot.updatedAt);
+    assert.equal(dashboard.completedMatches, 2);
+    assert.equal(dashboard.daily.length, 2);
+    assert.equal(dashboard.daily[1].day, "Live Update");
+    assert.equal(dashboard.daily[1]["Alpha"], 55);
+    assert.equal(dashboard.overall[0].name, "Alpha");
+    assert.equal(dashboard.overall[0].isLastMatchLeader, true);
+    assert.equal(dashboard.snapshot, snapshot);
+  });
+
+  it("does not append a live daily row when snapshot has no latest match points", () => {
+    const manualDashboard: DashboardData = {
+      source: "database",
+      overall: [],
+      daily: [{ day: "Match 1", Alpha: 10 }],
+    };
+    const snapshot: ScrapedDashboardPayload = {
+      updatedAt: "2026-04-18T10:55:57.567Z",
+      leaders: [
+        {
+          rank: 1,
+          name: "Alpha",
+          points: 100,
+        },
+      ],
+    };
+
+    const dashboard = buildDashboardFromSnapshot(snapshot, manualDashboard);
+
+    assert.equal(dashboard.daily.length, 1);
+    assert.equal(dashboard.daily[0].day, "Match 1");
+    assert.equal(dashboard.completedMatches, 1);
+    assert.equal(dashboard.snapshot, snapshot);
+  });
+
+  it("syncs raw users by appending the next match from scraped total deltas", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 1,
+        temname: "Alpha",
+        points: 100,
+        matches: [{ matchId: 1, points: 100 }],
+      },
+      {
+        rno: 2,
+        temname: "Beta",
+        points: 90,
+        matches: [{ matchId: 1, points: 90 }],
+      },
+    ];
+    const snapshot: ScrapedDashboardPayload = {
+      leaders: [
+        { rank: 1, name: "Alpha", points: 130, lastMatchPoints: 30 },
+        { rank: 2, name: "Beta", points: 105, lastMatchPoints: 15 },
+      ],
+    };
+
+    const result = syncRawUsersWithSnapshot(users, snapshot);
+
+    assert.equal(result.status, "updated");
+    assert.equal(result.mode, "append");
+    assert.equal(result.matchId, 2);
+    assert.equal(result.users[0].points, 130);
+    assert.deepEqual(result.users[0].matches.at(-1), {
+      matchId: 2,
+      points: 30,
+    });
+    assert.equal(users[0].matches.length, 1);
+  });
+
+  it("backfills missing match ids when completedMatches is ahead", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 1,
+        temname: "Alpha",
+        points: 100,
+        matches: [{ matchId: 1, points: 100 }],
+      },
+    ];
+    const snapshot: ScrapedDashboardPayload = {
+      completedMatches: 4,
+      leaders: [{ rank: 1, name: "Alpha", points: 150, lastMatchPoints: 12 }],
+    };
+
+    const result = syncRawUsersWithSnapshot(users, snapshot);
+
+    assert.equal(result.status, "updated");
+    assert.equal(result.mode, "append");
+    assert.equal(result.matchId, 4);
+    assert.equal(result.completedMatches, 4);
+    assert.deepEqual(result.users[0].matches, [
+      { matchId: 1, points: 100 },
+      { matchId: 2, points: 38 },
+      { matchId: 3, points: 0 },
+      { matchId: 4, points: 12 },
+    ]);
+    assert.equal(result.users[0].points, 150);
+  });
+
+  it("keeps raw users unchanged when scraped totals are already synced", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 1,
+        temname: "Alpha",
+        points: 130,
+        matches: [
+          { matchId: 1, points: 100 },
+          { matchId: 2, points: 30 },
+        ],
+      },
+    ];
+    const snapshot: ScrapedDashboardPayload = {
+      leaders: [{ rank: 1, name: "Alpha", points: 130, lastMatchPoints: 30 }],
+    };
+
+    const result = syncRawUsersWithSnapshot(users, snapshot);
+
+    assert.equal(result.status, "unchanged");
+    assert.equal(result.matchId, 2);
+    assert.equal(result.users[0].matches.length, 2);
+  });
+
+  it("updates the latest raw match when a later scrape belongs to the same match", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 1,
+        temname: "Alpha",
+        points: 130,
+        matches: [
+          { matchId: 1, points: 100 },
+          { matchId: 2, points: 30 },
+        ],
+      },
+    ];
+    const snapshot: ScrapedDashboardPayload = {
+      leaders: [{ rank: 1, name: "Alpha", points: 145, lastMatchPoints: 45 }],
+    };
+
+    const result = syncRawUsersWithSnapshot(users, snapshot);
+
+    assert.equal(result.status, "updated");
+    assert.equal(result.mode, "update-latest");
+    assert.equal(result.matchId, 2);
+    assert.equal(result.users[0].points, 145);
+    assert.deepEqual(result.users[0].matches.at(-1), {
+      matchId: 2,
+      points: 45,
+    });
+  });
+
+  it("updates latest match when completedMatches equals current max", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 1,
+        temname: "Alpha",
+        points: 145,
+        matches: [
+          { matchId: 1, points: 100 },
+          { matchId: 2, points: 45 },
+        ],
+      },
+    ];
+    const snapshot: ScrapedDashboardPayload = {
+      completedMatches: 2,
+      leaders: [{ rank: 1, name: "Alpha", points: 150 }],
+    };
+
+    const result = syncRawUsersWithSnapshot(users, snapshot);
+
+    assert.equal(result.status, "updated");
+    assert.equal(result.mode, "update-latest");
+    assert.equal(result.matchId, 2);
+    assert.deepEqual(result.users[0].matches, [
+      { matchId: 1, points: 100 },
+      { matchId: 2, points: 50 },
+    ]);
+  });
+
+  it("matches scraped player aliases back to raw fantasy team names", () => {
+    const users: RawApiUser[] = [
+      {
+        rno: 4,
+        temname: "VATVAGHOOL XI",
+        points: 100,
+        matches: [{ matchId: 1, points: 100 }],
+      },
+    ];
+    const snapshot: ScrapedDashboardPayload = {
+      leaders: [
+        { rank: 1, name: "Vijay Swami", points: 125, lastMatchPoints: 25 },
+      ],
+    };
+
+    const result = syncRawUsersWithSnapshot(users, snapshot);
+
+    assert.equal(result.status, "updated");
+    assert.deepEqual(result.unmatchedNames, []);
+    assert.equal(result.users[0].temname, "VATVAGHOOL XI");
+    assert.equal(result.users[0].points, 125);
+  });
+
+  it("serializes synced raw users back into a data.ts module", () => {
+    const source = serializeRawApiUsersModule([
+      {
+        rno: 1,
+        temname: "Alpha",
+        points: 130,
+        matches: [
+          { matchId: 1, points: 100 },
+          { matchId: 2, points: 30 },
+        ],
+      },
+    ]);
+
+    assert.match(source, /export const rawApiUsers: RawApiUser\[\]/);
+    assert.match(source, /"temname": "Alpha"/);
+    assert.match(source, /"matchId": 2/);
+    assert.match(source, /calculateTotalPoints/);
+  });
+});

package/template/tests/transfers-route.test.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import {
+  mergeTransferCollections,
+  normalizeTransferItem,
+  normalizeTransferSnapshot,
+  summarizeTransferSnapshot,
+} from "../app/api/ipl/transfers/transform.ts";
+
+describe("IPL transfers route helpers", () => {
+  it("normalizes the bookmarklet payload into a stable transfer item", () => {
+    const payload = normalizeTransferItem({
+      team: "  Team A  ",
+      matchesPlayed: "12",
+      boostersUsed: "3",
+      transfersLeft: " 94 ",
+      updatedAt: "2026-05-11T10:30:00.000Z",
+    });
+
+    assert.deepEqual(payload, {
+      team: "Team A",
+      matchesPlayed: 12,
+      boostersUsed: 3,
+      transfersLeft: "94",
+      updatedAt: "2026-05-11T10:30:00.000Z",
+    });
+  });
+
+  it("merges file and database snapshots by team using the newest update", () => {
+    const merged = mergeTransferCollections(
+      [
+        {
+          team: "Alpha",
+          matchesPlayed: 10,
+          boostersUsed: 1,
+          transfersLeft: "90",
+          updatedAt: "2026-05-11T09:00:00.000Z",
+        },
+      ],
+      [
+        {
+          team: "Alpha",
+          matchesPlayed: 11,
+          boostersUsed: 2,
+          transfersLeft: "89",
+          updatedAt: "2026-05-11T10:00:00.000Z",
+        },
+        {
+          team: "Beta",
+          matchesPlayed: 8,
+          boostersUsed: 0,
+          transfersLeft: "95",
+          updatedAt: "2026-05-11T08:00:00.000Z",
+        },
+      ],
+    );
+
+    assert.deepEqual(merged, [
+      {
+        team: "Alpha",
+        matchesPlayed: 11,
+        boostersUsed: 2,
+        transfersLeft: "89",
+        updatedAt: "2026-05-11T10:00:00.000Z",
+      },
+      {
+        team: "Beta",
+        matchesPlayed: 8,
+        boostersUsed: 0,
+        transfersLeft: "95",
+        updatedAt: "2026-05-11T08:00:00.000Z",
+      },
+    ]);
+  });
+
+  it("normalizes a persisted transfer snapshot payload", () => {
+    const snapshot = normalizeTransferSnapshot({
+      updatedAt: "2026-05-11T10:00:00.000Z",
+      teams: [
+        {
+          team: "Gamma",
+          matchesPlayed: 14,
+          boostersUsed: 2,
+          transfersLeft: "88",
+          updatedAt: "2026-05-11T10:00:00.000Z",
+        },
+      ],
+    });
+
+    assert.deepEqual(snapshot, {
+      updatedAt: "2026-05-11T10:00:00.000Z",
+      teams: [
+        {
+          team: "Gamma",
+          matchesPlayed: 14,
+          boostersUsed: 2,
+          transfersLeft: "88",
+          updatedAt: "2026-05-11T10:00:00.000Z",
+        },
+      ],
+    });
+
+    assert.deepEqual(
+      summarizeTransferSnapshot(snapshot?.teams ?? []),
+      snapshot,
+    );
+  });
+});