@vatvaghool/create-ipl-dashboard 0.1.0

package/template/app/api/ipl/transfers/route.ts

@@ -0,0 +1,261 @@
+import { NextResponse } from "next/server";
+import { readFile, writeFile } from "node:fs/promises";
+import getMongoDb from "../../../lib/useDb";
+import { config } from "../../../lib/config.ts";
+import type {
+  ScrapedTransferItem,
+  ScrapedTransferSnapshot,
+} from "../../../types";
+import {
+  mergeTransferCollections,
+  mergeTransferItem,
+  normalizeTransferItem,
+  normalizeTransferSnapshot,
+  normalizeTransferPayload,
+  summarizeTransferSnapshot,
+} from "./transform";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+export const runtime = "nodejs";
+
+const DASHBOARD_COLLECTION = config.mongodb.collectionName;
+const TRANSFER_DOCUMENT_TYPE = config.docTypes.transferStats;
+const isProduction = process.env.NODE_ENV === "production";
+const allowLocalSnapshotFallback = !isProduction;
+const SNAPSHOT_FILE_PATH = config.paths.transferSnapshotFile;
+
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Cache-Control": "no-store, no-cache, must-revalidate",
+  Pragma: "no-cache",
+  Expires: "0",
+};
+
+const LOG_TAG = "[ipl-transfers-api]";
+const shouldLog =
+  process.env.IPL_API_LOG === "1" || process.env.NODE_ENV !== "production";
+
+const log = (message: string, details?: unknown) => {
+  if (!shouldLog) return;
+
+  if (details === undefined) {
+    console.log(LOG_TAG, message);
+    return;
+  }
+
+  console.log(LOG_TAG, message, details);
+};
+
+const getDb = async () => {
+  try {
+    return await getMongoDb();
+  } catch (error) {
+    console.error("MongoDB connection failed:", error);
+    return null;
+  }
+};
+
+const readMongoTransfers = async () => {
+  const db = await getDb();
+
+  if (!db) {
+    return null;
+  }
+
+  try {
+    const documents = await db
+      .collection(DASHBOARD_COLLECTION)
+      .find({ type: TRANSFER_DOCUMENT_TYPE })
+      .toArray();
+
+    const teams = documents
+      .map(normalizeTransferItem)
+      .filter(Boolean) as ScrapedTransferItem[];
+
+    return teams.length > 0 ? teams : null;
+  } catch (error) {
+    console.error("Failed to read IPL transfer stats from MongoDB:", error);
+    return null;
+  }
+};
+
+const readSnapshotFile = async () => {
+  if (!allowLocalSnapshotFallback) {
+    return null;
+  }
+
+  try {
+    const content = await readFile(SNAPSHOT_FILE_PATH, "utf8");
+    const snapshot = normalizeTransferSnapshot(JSON.parse(content));
+
+    return snapshot?.teams ?? null;
+  } catch {
+    return null;
+  }
+};
+
+const writeMongoTransfer = async (record: ScrapedTransferItem) => {
+  const db = await getDb();
+
+  if (!db) {
+    return {
+      configured: false,
+      stored: false,
+    };
+  }
+
+  try {
+    await db.collection(DASHBOARD_COLLECTION).updateOne(
+      {
+        type: TRANSFER_DOCUMENT_TYPE,
+        team: record.team,
+      },
+      {
+        $set: {
+          type: TRANSFER_DOCUMENT_TYPE,
+          team: record.team,
+          matchesPlayed: record.matchesPlayed,
+          boostersUsed: record.boostersUsed,
+          transfersLeft: record.transfersLeft,
+          updatedAt: record.updatedAt,
+        },
+      },
+      { upsert: true },
+    );
+
+    return {
+      configured: true,
+      stored: true,
+    };
+  } catch (error) {
+    console.error("Failed to write IPL transfer stats to MongoDB:", error);
+
+    return {
+      configured: true,
+      stored: false,
+    };
+  }
+};
+
+const writeSnapshotFile = async (snapshot: ScrapedTransferSnapshot) => {
+  if (!allowLocalSnapshotFallback) {
+    return false;
+  }
+
+  try {
+    await writeFile(
+      SNAPSHOT_FILE_PATH,
+      `${JSON.stringify(snapshot, null, 2)}\n`,
+      "utf8",
+    );
+
+    return true;
+  } catch (error) {
+    console.error("Failed to write IPL transfer snapshot file:", error);
+    return false;
+  }
+};
+
+const snapshotSummary = (teams: ScrapedTransferItem[] | null) =>
+  teams && teams.length > 0 ? summarizeTransferSnapshot(teams) : null;
+
+export async function OPTIONS() {
+  return new Response(null, { status: 204, headers: corsHeaders });
+}
+
+export async function GET() {
+  const [mongoTransfers, fileTransfers] = await Promise.all([
+    readMongoTransfers(),
+    readSnapshotFile(),
+  ]);
+
+  const teams = mergeTransferCollections(mongoTransfers ?? [], fileTransfers ?? []);
+
+  log("GET /api/ipl/transfers", {
+    hasMongoTransfers: Boolean(mongoTransfers),
+    hasFileTransfers: Boolean(fileTransfers),
+    allowLocalSnapshotFallback,
+    snapshot: snapshotSummary(teams),
+  });
+
+  if (teams.length === 0) {
+    return NextResponse.json(
+      { error: "No IPL transfer stats found yet. POST a transfer payload first." },
+      { status: 503, headers: corsHeaders },
+    );
+  }
+
+  return NextResponse.json(summarizeTransferSnapshot(teams), {
+    headers: corsHeaders,
+  });
+}
+
+export async function POST(request: Request) {
+  const mongoConfigured = Boolean(process.env.MONGODB_URI);
+  const items = normalizeTransferPayload(await request.json().catch(() => null));
+
+  if (!items) {
+    log("POST /api/ipl/transfers -> 400 (invalid payload)");
+    return NextResponse.json(
+      {
+        error:
+          "Invalid payload. Expected { team, matchesPlayed, boostersUsed, transfersLeft, updatedAt } or { teams: [...] }.",
+      },
+      { status: 400, headers: corsHeaders },
+    );
+  }
+
+  if (isProduction && !mongoConfigured) {
+    log("POST /api/ipl/transfers -> 503 (MongoDB required in production)");
+    return NextResponse.json(
+      {
+        error:
+          "MongoDB storage is required in production. Configure MONGODB_URI for cloud ingestion.",
+      },
+      { status: 503, headers: corsHeaders },
+    );
+  }
+
+  log("POST /api/ipl/transfers received payload", { count: items.length });
+
+  const [mongoTransfers, fileTransfers] = await Promise.all([
+    readMongoTransfers(),
+    readSnapshotFile(),
+  ]);
+
+  const baselineTransfers = mergeTransferCollections(
+    mongoTransfers ?? [],
+    fileTransfers ?? [],
+  );
+  let nextTransfers = baselineTransfers;
+  for (const item of items) {
+    nextTransfers = mergeTransferItem(nextTransfers, item);
+  }
+  const snapshot = summarizeTransferSnapshot(nextTransfers);
+
+  const mongoResults = await Promise.all(items.map(writeMongoTransfer));
+  const fileStorage = await writeSnapshotFile(snapshot);
+
+  log("POST /api/ipl/transfers write results", {
+    mongoResults,
+    fileStorage,
+    snapshot: snapshotSummary(nextTransfers),
+  });
+
+  return NextResponse.json(
+    {
+      ok: true,
+      count: nextTransfers.length,
+      storage: {
+        mongodbTransferStats: mongoResults.some((r) => r.stored),
+        localSnapshotFile: fileStorage,
+        mongodbConfigured: mongoResults.some((r) => r.configured),
+      },
+      snapshot,
+    },
+    { headers: corsHeaders },
+  );
+}

package/template/app/api/ipl/transfers/transform.ts

@@ -0,0 +1,156 @@
+import type {
+  ScrapedTransferItem,
+  ScrapedTransferSnapshot,
+} from "../../../types";
+
+const toNumber = (value: unknown) => {
+  const numeric = Number(String(value ?? "").replace(/,/g, "").trim());
+  return Number.isFinite(numeric) ? numeric : undefined;
+};
+
+const toTrimmedString = (value: unknown) => {
+  const text = String(value ?? "").trim();
+  return text.length > 0 ? text : undefined;
+};
+
+export const normalizeTransferPayload = (
+  value: unknown,
+): ScrapedTransferItem[] | null => {
+  if (!value || typeof value !== "object") return null;
+
+  const candidate = value as Record<string, unknown>;
+
+  if (Array.isArray(value)) {
+    const items = value.map(normalizeTransferItem).filter(Boolean) as ScrapedTransferItem[];
+    return items.length > 0 ? items : null;
+  }
+
+  if (Array.isArray(candidate.teams)) {
+    const items = candidate.teams
+      .map(normalizeTransferItem)
+      .filter(Boolean) as ScrapedTransferItem[];
+    return items.length > 0 ? items : null;
+  }
+
+  const single = normalizeTransferItem(candidate);
+  return single ? [single] : null;
+};
+
+export const normalizeTransferItem = (
+  value: unknown,
+): ScrapedTransferItem | null => {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+
+  const candidate = value as Record<string, unknown>;
+  const team = toTrimmedString(candidate.team);
+  const matchesPlayed = toNumber(candidate.matchesPlayed);
+  const boostersUsed = toNumber(candidate.boostersUsed) ?? toNumber(candidate.boosters);
+  const transfersLeftRaw = candidate.transfersLeft;
+  const transfersLeft =
+    typeof transfersLeftRaw === "number" && Number.isFinite(transfersLeftRaw)
+      ? String(transfersLeftRaw)
+      : toTrimmedString(transfersLeftRaw);
+  const updatedAt = toTrimmedString(candidate.updatedAt) ?? new Date().toISOString();
+
+  if (
+    !team ||
+    matchesPlayed === undefined ||
+    boostersUsed === undefined ||
+    !transfersLeft
+  ) {
+    return null;
+  }
+
+  return {
+    team,
+    matchesPlayed,
+    boostersUsed,
+    transfersLeft,
+    updatedAt,
+  };
+};
+
+export const normalizeTransferSnapshot = (
+  value: unknown,
+): ScrapedTransferSnapshot | null => {
+  if (!value) {
+    return null;
+  }
+
+  if (Array.isArray(value)) {
+    const teams = value.map(normalizeTransferItem).filter(Boolean) as ScrapedTransferItem[];
+
+    return teams.length > 0 ? { teams } : null;
+  }
+
+  if (typeof value !== "object") {
+    return null;
+  }
+
+  const candidate = value as Record<string, unknown>;
+
+  if (Array.isArray(candidate.teams)) {
+    const teams = candidate.teams
+      .map(normalizeTransferItem)
+      .filter(Boolean) as ScrapedTransferItem[];
+
+    return teams.length > 0
+      ? {
+          updatedAt: toTrimmedString(candidate.updatedAt),
+          teams,
+        }
+      : null;
+  }
+
+  const singleItem = normalizeTransferItem(candidate);
+
+  return singleItem ? { updatedAt: singleItem.updatedAt, teams: [singleItem] } : null;
+};
+
+export const mergeTransferItem = (
+  existing: ScrapedTransferItem[],
+  incoming: ScrapedTransferItem,
+) => {
+  const items = existing.filter(
+    (item) => item.team.toLowerCase() !== incoming.team.toLowerCase(),
+  );
+
+  items.push(incoming);
+
+  return items.sort((a, b) => a.team.localeCompare(b.team));
+};
+
+export const mergeTransferCollections = (
+  primary: ScrapedTransferItem[],
+  secondary: ScrapedTransferItem[],
+) => {
+  const byTeam = new Map<string, ScrapedTransferItem>();
+
+  for (const item of [...primary, ...secondary]) {
+    const key = item.team.toLowerCase();
+    const current = byTeam.get(key);
+
+    if (!current || current.updatedAt <= item.updatedAt) {
+      byTeam.set(key, item);
+    }
+  }
+
+  return [...byTeam.values()].sort((a, b) => a.team.localeCompare(b.team));
+};
+
+export const summarizeTransferSnapshot = (
+  teams: ScrapedTransferItem[],
+): ScrapedTransferSnapshot => {
+  const updatedAt =
+    [...teams]
+      .map((item) => item.updatedAt)
+      .sort()
+      .at(-1) ?? new Date().toISOString();
+
+  return {
+    updatedAt,
+    teams: [...teams].sort((a, b) => a.team.localeCompare(b.team)),
+  };
+};

package/template/app/api/ipl/transform.ts

@@ -0,0 +1,20 @@
+export {
+  addLeaderboardMetrics,
+  buildDashboardFromSnapshot,
+  buildManualDashboard,
+  normalizePayload,
+  normalizeRawApiUsers,
+  serializeRawApiUsersModule,
+  syncRawUsersWithSnapshot,
+  toFiniteNumber,
+} from "../../../packages/ipl-dashboard-utils/src/transform.ts";
+
+import { TEAM_ALIAS_MAP, resolveTeamId } from "../../data/teams.ts";
+import { config } from "../../lib/config.ts";
+
+export { resolveTeamId, TEAM_ALIAS_MAP };
+
+export const getTransformOptions = () => ({
+  teamAliases: TEAM_ALIAS_MAP,
+  totalTransfers: config.league.totalTransfers,
+});

package/template/app/api/ipl/upcoming-matches/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { fetchUpcomingMatches } from "../../../lib/upcomingMatches";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+export const runtime = "nodejs";
+
+export async function GET() {
+  const payload = await fetchUpcomingMatches();
+
+  return NextResponse.json(payload, {
+    headers: {
+      "Cache-Control": "no-store, no-cache, must-revalidate",
+      Pragma: "no-cache",
+      Expires: "0",
+    },
+  });
+}

package/template/app/api/ops/status/route.ts

@@ -0,0 +1,225 @@
+import { NextResponse } from "next/server";
+import getMongoDb from "../../../lib/useDb";
+import { config } from "../../../lib/config.ts";
+import { normalizePayload } from "../../ipl/transform";
+import { summarizeTransferSnapshot } from "../../ipl/transfers/transform";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+export const runtime = "nodejs";
+
+const DASHBOARD_COLLECTION = config.mongodb.collectionName;
+const DASHBOARD_DOCUMENT_TYPE = config.docTypes.dashboard;
+const RAW_USERS_DOCUMENT_TYPE = config.docTypes.rawUsers;
+const TRANSFER_DOCUMENT_TYPE = config.docTypes.transferStats;
+const isProduction = process.env.NODE_ENV === "production";
+const DEFAULT_DASHBOARD_STALE_MINUTES = isProduction ? 20 : 180;
+const DEFAULT_TRANSFERS_STALE_MINUTES = isProduction ? 720 : 1440;
+
+type AlertSeverity = "info" | "warning" | "critical";
+
+const readThresholdMinutes = (name: string, fallback: number) => {
+  const raw = Number(process.env[name] ?? "");
+  return Number.isFinite(raw) && raw > 0 ? raw : fallback;
+};
+
+const dashboardStaleMinutes = readThresholdMinutes(
+  "IPL_DASHBOARD_STALE_MINUTES",
+  DEFAULT_DASHBOARD_STALE_MINUTES,
+);
+const transfersStaleMinutes = readThresholdMinutes(
+  "IPL_TRANSFERS_STALE_MINUTES",
+  DEFAULT_TRANSFERS_STALE_MINUTES,
+);
+
+const toAgeMs = (value: string | undefined) => {
+  if (!value) return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? Date.now() - timestamp : null;
+};
+
+const getFreshness = (
+  updatedAt: string | undefined,
+  thresholdMinutes: number,
+) => {
+  const ageMs = toAgeMs(updatedAt);
+  const thresholdMs = thresholdMinutes * 60 * 1000;
+
+  if (!updatedAt || ageMs === null) {
+    return {
+      updatedAt: updatedAt ?? null,
+      ageMs,
+      thresholdMinutes,
+      isStale: true,
+      status: "missing" as const,
+    };
+  }
+
+  return {
+    updatedAt,
+    ageMs,
+    thresholdMinutes,
+    isStale: ageMs > thresholdMs,
+    status: ageMs > thresholdMs ? ("stale" as const) : ("fresh" as const),
+  };
+};
+
+const getDb = async () => {
+  try {
+    return await getMongoDb();
+  } catch (error) {
+    console.error("MongoDB connection failed:", error);
+    return null;
+  }
+};
+
+export async function GET() {
+  const mongoConfigured = Boolean(process.env.MONGODB_URI);
+  const db = await getDb();
+
+  if (!db) {
+    return NextResponse.json(
+      {
+        ok: !isProduction,
+        mode: isProduction ? "cloud" : "local",
+        mongoConfigured,
+        mongoConnected: false,
+        reason: mongoConfigured
+          ? "MongoDB connection failed."
+          : "MONGODB_URI is not configured.",
+      },
+      { status: mongoConfigured ? 503 : 200 },
+    );
+  }
+
+  const [dashboardDocument, rawUsersDocument, transferDocuments] = await Promise.all([
+    db.collection(DASHBOARD_COLLECTION).findOne({ type: DASHBOARD_DOCUMENT_TYPE }),
+    db.collection(DASHBOARD_COLLECTION).findOne({ type: RAW_USERS_DOCUMENT_TYPE }),
+    db
+      .collection(DASHBOARD_COLLECTION)
+      .find({ type: TRANSFER_DOCUMENT_TYPE })
+      .toArray(),
+  ]);
+  const snapshot = normalizePayload(dashboardDocument);
+  const transfers = summarizeTransferSnapshot(
+    transferDocuments
+      .map((document) => ({
+        team:
+          typeof document.team === "string" ? document.team : "",
+        matchesPlayed:
+          typeof document.matchesPlayed === "number"
+            ? document.matchesPlayed
+            : Number.NaN,
+        boostersUsed:
+          typeof document.boostersUsed === "number"
+            ? document.boostersUsed
+            : Number.NaN,
+        transfersLeft:
+          typeof document.transfersLeft === "string"
+            ? document.transfersLeft
+            : String(document.transfersLeft ?? "").trim(),
+        updatedAt:
+          typeof document.updatedAt === "string"
+            ? document.updatedAt
+            : new Date(0).toISOString(),
+      }))
+      .filter(
+        (item) =>
+          item.team &&
+          Number.isFinite(item.matchesPlayed) &&
+          Number.isFinite(item.boostersUsed) &&
+          item.transfersLeft,
+      ),
+  );
+  const transfersUpdatedAt =
+    transfers.teams.length > 0 ? transfers.updatedAt : undefined;
+  const dashboardFreshness = getFreshness(
+    snapshot?.updatedAt,
+    dashboardStaleMinutes,
+  );
+  const transfersFreshness = getFreshness(
+    transfersUpdatedAt,
+    transfersStaleMinutes,
+  );
+  const alerts: Array<{
+    code: string;
+    severity: AlertSeverity;
+    message: string;
+  }> = [];
+
+  if (!snapshot) {
+    alerts.push({
+      code: "dashboard_missing",
+      severity: isProduction ? "critical" : "warning",
+      message: "Dashboard snapshot is missing from MongoDB.",
+    });
+  } else if (dashboardFreshness.isStale) {
+    alerts.push({
+      code: "dashboard_stale",
+      severity: isProduction ? "critical" : "warning",
+      message: `Dashboard snapshot is stale. Latest update is older than ${dashboardStaleMinutes} minutes.`,
+    });
+  }
+
+  if (transfers.teams.length === 0) {
+    alerts.push({
+      code: "transfers_missing",
+      severity: "warning",
+      message: "Transfer snapshot data is missing.",
+    });
+  } else if (transfersFreshness.isStale) {
+    alerts.push({
+      code: "transfers_stale",
+      severity: "warning",
+      message: `Transfer snapshot is stale. Latest update is older than ${transfersStaleMinutes} minutes.`,
+    });
+  }
+
+  const hasCriticalAlert = alerts.some((alert) => alert.severity === "critical");
+  const hasWarningAlert = alerts.some((alert) => alert.severity === "warning");
+  const status = hasCriticalAlert
+    ? "critical"
+    : hasWarningAlert
+      ? "degraded"
+      : "ok";
+  const responseStatus = status === "critical" ? 503 : 200;
+
+  return NextResponse.json(
+    {
+      ok: status !== "critical",
+      status,
+      mode: isProduction ? "cloud" : "local",
+      checkedAt: new Date().toISOString(),
+      mongoConfigured,
+      mongoConnected: true,
+      localSnapshotFallbackEnabled: !isProduction,
+      thresholds: {
+        dashboardStaleMinutes,
+        transfersStaleMinutes,
+      },
+      dashboard: snapshot
+        ? {
+            updatedAt: snapshot.updatedAt,
+            dailyTransferUpdatedAt: snapshot.dailyTransferUpdatedAt,
+            completedMatches: snapshot.completedMatches,
+            leadersCount: snapshot.leaders.length,
+            freshness: dashboardFreshness,
+          }
+        : null,
+      rawUsers: {
+        count: Array.isArray(rawUsersDocument?.users) ? rawUsersDocument.users.length : 0,
+        updatedAt:
+          typeof rawUsersDocument?.updatedAt === "string"
+            ? rawUsersDocument.updatedAt
+            : null,
+      },
+      transfers: {
+        updatedAt: transfersUpdatedAt ?? null,
+        count: transfers.teams.length,
+        freshness: transfersFreshness,
+      },
+      alerts,
+    },
+    { status: responseStatus },
+  );
+}