@vatvaghool/create-ipl-dashboard 0.1.18 → 0.1.23

package/template/app/hooks/dashboardPolling.ts

@@ -1,53 +0,0 @@
-import type { DashboardData } from "../types";
-
-export const DASHBOARD_POLL_INTERVAL_MS = 120000;
-
-type DashboardFetcher = typeof fetch;
-
-type DashboardPollerOptions = {
-  fetcher: DashboardFetcher;
-  onData: (data: DashboardData) => void;
-  onError?: (error: unknown) => void;
-  intervalMs?: number;
-};
-
-export const createDashboardPoller = ({
-  fetcher,
-  onData,
-  onError = console.error,
-  intervalMs = DASHBOARD_POLL_INTERVAL_MS,
-}: DashboardPollerOptions) => {
-  let active = true;
-  let previousSerialized = "";
-
-  const fetchData = async () => {
-    try {
-      const res = await fetcher(`/api/ipl?t=${Date.now()}`, {
-        cache: "no-store",
-      });
-
-      if (!res.ok) {
-        throw new Error(`Dashboard API failed with ${res.status}`);
-      }
-
-      const data = (await res.json()) as DashboardData;
-      const serialized = JSON.stringify(data);
-
-      if (active && serialized !== previousSerialized) {
-        previousSerialized = serialized;
-        onData(data);
-      }
-    } catch (error) {
-      onError(error);
-    }
-  };
-
-  const interval = setInterval(fetchData, intervalMs);
-
-  void fetchData();
-
-  return () => {
-    active = false;
-    clearInterval(interval);
-  };
-};

package/template/app/hooks/snapshotCache.ts

@@ -1,47 +0,0 @@
-"use client";
-
-import type { ScrapedDashboardPayload } from "../types";
-
-const CACHE_KEY = "ipl:snapshot-cache:v1";
-
-type CachePayload = {
-  cachedAt: string;
-  snapshot: ScrapedDashboardPayload;
-};
-
-export const readSnapshotCache = (): CachePayload | null => {
-  if (typeof window === "undefined") return null;
-
-  try {
-    const raw = window.localStorage.getItem(CACHE_KEY);
-    if (!raw) return null;
-
-    const parsed = JSON.parse(raw) as Partial<CachePayload> | null;
-    if (!parsed || typeof parsed !== "object") return null;
-    if (!parsed.snapshot || typeof parsed.snapshot !== "object") return null;
-
-    const cachedAt =
-      typeof parsed.cachedAt === "string" ? parsed.cachedAt : undefined;
-
-    return {
-      cachedAt: cachedAt ?? new Date().toISOString(),
-      snapshot: parsed.snapshot as ScrapedDashboardPayload,
-    };
-  } catch {
-    return null;
-  }
-};
-
-export const writeSnapshotCache = (snapshot: ScrapedDashboardPayload) => {
-  if (typeof window === "undefined") return;
-
-  try {
-    const payload: CachePayload = {
-      cachedAt: new Date().toISOString(),
-      snapshot,
-    };
-    window.localStorage.setItem(CACHE_KEY, JSON.stringify(payload));
-  } catch {
-    // ignore cache write failures (private mode, quota, etc.)
-  }
-};

package/template/app/lib/storage/google-sheets-storage.ts

@@ -1,147 +0,0 @@
-import type { IStorage, StorageResult } from "./types";
-
-const SHEET_ID = () => process.env.GOOGLE_SHEET_ID || "";
-const SHEET_NAMES: Record<string, string> = {
-  dashboard: "dashboard",
-  "raw-users": "raw_users",
-  "transfer-stats": "transfers",
-  league: "league",
-};
-
-function sheetNameFor(type: string): string {
-  return SHEET_NAMES[type] || type.replace(/[^a-z0-9_]/g, "_");
-}
-
-let sheetsClient: any = null;
-
-async function getSheetsClient() {
-  if (sheetsClient) return sheetsClient;
-  try {
-    const { google } = await import("googleapis");
-    const auth = new google.auth.GoogleAuth({
-      credentials: {
-        client_email: process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL,
-        private_key: process.env.GOOGLE_PRIVATE_KEY?.replace(/\\n/g, "\n"),
-      },
-      scopes: ["https://www.googleapis.com/auth/spreadsheets"],
-    });
-    sheetsClient = google.sheets({ version: "v4", auth });
-    return sheetsClient;
-  } catch (error) {
-    console.error("Failed to create Google Sheets client:", error);
-    return null;
-  }
-}
-
-export class GoogleSheetsStorage implements IStorage {
-  isConfigured(): boolean {
-    return Boolean(process.env.GOOGLE_SHEET_ID && process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL && process.env.GOOGLE_PRIVATE_KEY);
-  }
-
-  async isConnected(): Promise<boolean> {
-    const client = await getSheetsClient();
-    return client !== null;
-  }
-
-  private async ensureSheet(sheetName: string): Promise<void> {
-    const client = await getSheetsClient();
-    if (!client) return;
-    try {
-      const res = await client.spreadsheets.get({ spreadsheetId: SHEET_ID() });
-      const sheets: any[] = res.data.sheets || [];
-      if (sheets.some((s: any) => s.properties?.title === sheetName)) return;
-      await client.spreadsheets.batchUpdate({
-        spreadsheetId: SHEET_ID(),
-        requestBody: {
-          requests: [{ addSheet: { properties: { title: sheetName } } }],
-        },
-      });
-    } catch {
-      // Sheet already exists or can't be created
-    }
-  }
-
-  async readDocument(type: string): Promise<Record<string, unknown> | null> {
-    const client = await getSheetsClient();
-    if (!client) return null;
-    const sheetName = sheetNameFor(type);
-    try {
-      const res = await client.spreadsheets.values.get({
-        spreadsheetId: SHEET_ID(),
-        range: `${sheetName}!A:C`,
-      });
-      const rows: string[][] = res.data.values || [];
-      const dataRow = rows.find((r) => r[0] === type);
-      if (dataRow?.[1]) {
-        return { type, ...JSON.parse(dataRow[1]), updatedAt: dataRow[2] || new Date().toISOString() };
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  async upsertDocument(
-    type: string,
-    data: Record<string, unknown>,
-    _filter?: Record<string, unknown>,
-  ): Promise<StorageResult> {
-    const client = await getSheetsClient();
-    if (!client) return { configured: true, stored: false, status: "no_connection" };
-    const sheetName = sheetNameFor(type);
-    await this.ensureSheet(sheetName);
-    try {
-      const res = await client.spreadsheets.values.get({
-        spreadsheetId: SHEET_ID(),
-        range: `${sheetName}!A:C`,
-      });
-      const rows: string[][] = res.data.values || [];
-      const rowIndex = rows.findIndex((r) => r[0] === type);
-      const jsonData = JSON.stringify(data);
-      const updatedAt = new Date().toISOString();
-      if (rowIndex >= 0) {
-        await client.spreadsheets.values.update({
-          spreadsheetId: SHEET_ID(),
-          range: `${sheetName}!A${rowIndex + 1}:C${rowIndex + 1}`,
-          valueInputOption: "RAW",
-          requestBody: { values: [[type, jsonData, updatedAt]] },
-        });
-      } else {
-        await client.spreadsheets.values.append({
-          spreadsheetId: SHEET_ID(),
-          range: `${sheetName}!A:C`,
-          valueInputOption: "RAW",
-          requestBody: { values: [[type, jsonData, updatedAt]] },
-        });
-      }
-      return { configured: true, stored: true, status: "updated" };
-    } catch (error) {
-      console.error(`Failed to write document type "${type}" to Google Sheets:`, error);
-      return { configured: true, stored: false, status: "failed" };
-    }
-  }
-
-  async readDocuments(type: string): Promise<Record<string, unknown>[]> {
-    const client = await getSheetsClient();
-    if (!client) return [];
-    const sheetName = sheetNameFor(type);
-    try {
-      const res = await client.spreadsheets.values.get({
-        spreadsheetId: SHEET_ID(),
-        range: `${sheetName}!A:C`,
-      });
-      const rows: string[][] = res.data.values || [];
-      return rows
-        .filter((r) => r[0] && r[0] !== type)
-        .map((r) => {
-          try {
-            return { team: r[0], ...JSON.parse(r[1] || "{}"), updatedAt: r[2] || new Date().toISOString() };
-          } catch {
-            return { team: r[0], updatedAt: r[2] || new Date().toISOString() };
-          }
-        });
-    } catch {
-      return [];
-    }
-  }
-}

package/template/app/lib/utils/diff.ts

@@ -1,24 +0,0 @@
-// utils/diff.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function getDiff(prev: any, next: any, path = ""): Record<string, any> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const diff: Record<string, any> = {};
-
-  for (const key in next) {
-    const newPath = path ? `${path}.${key}` : key;
-
-    if (
-      typeof next[key] === "object" &&
-      next[key] !== null &&
-      typeof prev?.[key] === "object"
-    ) {
-      Object.assign(diff, getDiff(prev[key], next[key], newPath));
-    } else {
-      if (prev?.[key] !== next[key]) {
-        diff[newPath] = next[key];
-      }
-    }
-  }
-
-  return diff;
-}

package/template/app/lib/utils/time.ts

@@ -1,40 +0,0 @@
-// utils/time.ts
-
-export function formatMatchTime(date: string, timeZone = "Asia/Kolkata") {
-  return new Date(date).toLocaleString("en-IN", {
-    timeZone,
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: true,
-    day: "2-digit",
-    month: "short",
-  });
-}
-
-export function getMatchStatus(date: string) {
-  const now = new Date().getTime();
-  const matchTime = new Date(date).getTime();
-
-  const diff = matchTime - now;
-
-  if (diff < -4 * 60 * 60 * 1000) return "ENDED"; // 4h after start
-  if (diff <= 0) return "LIVE";
-  if (diff <= 30 * 60 * 1000) return "STARTING SOON";
-
-  return "UPCOMING";
-}
-
-export function getTimeLeft(date: string) {
-  const now = new Date().getTime();
-  const matchTime = new Date(date).getTime();
-
-  const diff = matchTime - now;
-
-  if (diff <= 0) return "Started";
-
-  const mins = Math.floor(diff / 60000);
-  const hrs = Math.floor(mins / 60);
-
-  if (hrs > 0) return `${hrs}h ${mins % 60}m`;
-  return `${mins}m`;
-}

package/template/tests/coverage-gaps.test.ts

@@ -1,290 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it, mock } from "node:test";
-
-import type { DashboardData, RawApiUser } from "../app/types.ts";
-import {
-  addLeaderboardMetrics,
-  buildManualDashboard,
-  normalizePayload,
-  normalizeRawApiUsers,
-  syncRawUsersWithSnapshot,
-} from "../app/api/ipl/transform.ts";
-import { createDashboardPoller } from "../app/hooks/dashboardPolling.ts";
-
-const flushPromises = () => new Promise<void>((resolve) => queueMicrotask(resolve));
-
-describe("coverage gap guards", () => {
-  afterEach(() => {
-    mock.timers.reset();
-  });
-
-  it("normalizes date instances and filters malformed squad/player records", () => {
-    const updatedAt = new Date("2026-04-28T09:15:00.000Z");
-    const payload = normalizePayload({
-      updatedAt,
-      leaders: [
-        {
-          rank: 1,
-          name: "Alpha",
-          points: 110,
-          captain: { playerName: "Captain A", id: 7, playerPoints: 44 },
-          viceCaptain: { fullName: "Vice A", playerId: "11", pts: 22 },
-          players: [
-            { name: "Valid Player", number: "08", points: 20 },
-            { playerName: "Bench Player", id: 19, playerPoints: 5 },
-            { number: "99", points: 3 },
-            "",
-            null,
-          ],
-        },
-      ],
-    });
-
-    assert.ok(payload);
-    assert.equal(payload.updatedAt, updatedAt.toISOString());
-    assert.equal(payload.leaders[0].captain?.name, "Captain A");
-    assert.equal(payload.leaders[0].captain?.number, "7");
-    assert.equal(payload.leaders[0].captain?.points, 44);
-    assert.equal(payload.leaders[0].viceCaptain?.name, "Vice A");
-    assert.equal(payload.leaders[0].viceCaptain?.number, "11");
-    assert.deepEqual(payload.leaders[0].players, [
-      { name: "Valid Player", number: "08", points: 20 },
-      { name: "Bench Player", number: "19", points: 5 },
-    ]);
-  });
-
-  it("keeps completed match count undefined when a valid payload reports zero", () => {
-    const payload = normalizePayload({
-      completedMatches: 0,
-      Meta: {
-        Timestamp: {
-          ISTTime: "2026-04-28T09:15:00.000Z",
-        },
-      },
-      leaders: [{ rank: 1, name: "Alpha", points: 110 }],
-    });
-
-    assert.ok(payload);
-    assert.equal(payload.completedMatches, undefined);
-    assert.equal(payload.updatedAt, "2026-04-28T09:15:00.000Z");
-  });
-
-  it("parses completed matches from feed text and handles single-row leaderboard metrics", () => {
-    const payload = normalizePayload({
-      Data: {
-        Value: [{ rank: 1, usrname: "Solo", points: 77 }],
-        FeedTime: {
-          UTCTime: "Match 12",
-        },
-      },
-    });
-
-    assert.ok(payload);
-    assert.equal(payload.completedMatches, 12);
-
-    const rows = addLeaderboardMetrics([
-      { rank: 1, name: "Solo", points: 77, transfersLeft: 210 },
-    ]);
-
-    assert.deepEqual(rows, [
-      {
-        name: "Solo",
-        points: 77,
-        rank: 1,
-        previousRank: 1,
-        previousPoints: 77,
-        lastMatchPoints: undefined,
-        gapToNext: 0,
-        gapPercent: 0,
-        movement: "same",
-        transfersLeft: 210,
-        transfersUsed: undefined,
-        totalTransfers: undefined,
-        boostersUsed: undefined,
-        efficiency: undefined,
-        isLastMatchLeader: false,
-        captain: undefined,
-        viceCaptain: undefined,
-        players: undefined,
-      },
-    ]);
-  });
-
-  it("rejects invalid raw user payload shapes and invalid match rows", () => {
-    assert.equal(normalizeRawApiUsers({ nope: true }), null);
-
-    const normalized = normalizeRawApiUsers([
-      null,
-      {
-        rno: 1,
-        temname: "Alpha",
-        matches: [
-          null,
-          { matchId: "bad", points: 10 },
-          { matchId: 1, points: "bad" },
-          { matchId: 2, points: 25 },
-        ],
-      },
-      {
-        rno: 2,
-        temname: "No Matches Array",
-      },
-    ]);
-
-    assert.deepEqual(normalized, [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 25,
-        matches: [{ matchId: 2, points: 25 }],
-      },
-    ]);
-  });
-
-  it("builds an empty manual dashboard and appends future matches without live points", () => {
-    assert.deepEqual(buildManualDashboard([]), {
-      overall: [],
-      daily: [],
-      completedMatches: undefined,
-      source: "database",
-    });
-
-    const users: RawApiUser[] = [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 30,
-        matches: [{ matchId: 1, points: 30 }],
-      },
-    ];
-
-    const result = syncRawUsersWithSnapshot(users, {
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 3,
-      leaders: [{ rank: 1, name: "Alpha", points: 45 }],
-    });
-
-    assert.equal(result.status, "updated");
-    assert.equal(result.mode, "append");
-    assert.deepEqual(result.users[0].matches, [
-      { matchId: 1, points: 30 },
-      { matchId: 2, points: 15 },
-    ]);
-  });
-
-  it("returns skipped when snapshot leaders do not match raw users", () => {
-    const users: RawApiUser[] = [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 100,
-        matches: [{ matchId: 1, points: 100 }],
-      },
-    ];
-
-    const result = syncRawUsersWithSnapshot(users, {
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 2,
-      leaders: [{ rank: 1, name: "Ghost Team", points: 150 }],
-    });
-
-    assert.deepEqual(result, {
-      status: "skipped",
-      users,
-      unmatchedNames: ["Ghost Team"],
-    });
-  });
-
-  it("creates a latest match row when forcing update-latest without an existing match entry", () => {
-    const users: RawApiUser[] = [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 10,
-        matches: [{ matchId: 1, points: 10 }],
-      },
-      {
-        rno: 2,
-        temname: "Beta",
-        points: 15,
-        matches: [{ matchId: 1, points: 15 }],
-      },
-    ];
-
-    const result = syncRawUsersWithSnapshot(users, {
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 2,
-      leaders: [
-        { rank: 1, name: "Beta", points: 15, lastMatchPoints: 0 },
-        { rank: 2, name: "Alpha", points: 18, lastMatchPoints: 8 },
-      ],
-    });
-
-    assert.equal(result.status, "updated");
-    assert.equal(result.mode, "append");
-    assert.equal(result.matchId, 2);
-    assert.deepEqual(result.users[0].matches, [
-      { matchId: 1, points: 10 },
-      { matchId: 2, points: 8 },
-    ]);
-  });
-
-  it("reports polling fetch failures and does not emit stale data after stop", async () => {
-    mock.timers.enable({ apis: ["Date", "setInterval"], now: 0 });
-
-    const errors: unknown[] = [];
-    const received: DashboardData[] = [];
-    let resolveFetch: ((value: Response) => void) | undefined;
-
-    const fetcher = (async (url: string) => {
-      if (url.includes("first")) {
-        return {
-          ok: false,
-          status: 503,
-          json: async () => ({}),
-        } as Response;
-      }
-
-      return await new Promise<Response>((resolve) => {
-        resolveFetch = resolve;
-      });
-    }) as typeof fetch;
-
-    let firstCall = true;
-    const wrappedFetcher = (async (url: string, options?: RequestInit) => {
-      const actualUrl = firstCall ? "/api/ipl?first=true" : url;
-      firstCall = false;
-      return fetcher(actualUrl, options);
-    }) as typeof fetch;
-
-    const stop = createDashboardPoller({
-      fetcher: wrappedFetcher,
-      onData: (data) => received.push(data),
-      onError: (error) => errors.push(error),
-      intervalMs: 50,
-    });
-
-    await flushPromises();
-    await flushPromises();
-    assert.equal(errors.length, 1);
-    assert.match(String(errors[0]), /503/);
-
-    mock.timers.tick(50);
-    stop();
-
-    resolveFetch?.({
-      ok: true,
-      status: 200,
-      json: async () =>
-        ({
-          source: "database",
-          updatedAt: "2026-04-28T09:20:00.000Z",
-          overall: [{ rank: 1, name: "Alpha", points: 120 }],
-          daily: [{ day: "Match 1", Alpha: 120 }],
-        }) as DashboardData,
-    } as Response);
-
-    await flushPromises();
-    assert.equal(received.length, 0);
-  });
-});