@vatvaghool/create-ipl-dashboard 0.1.14 → 0.1.17

package/README.md

@@ -27,13 +27,16 @@ npx @vatvaghool/create-ipl-dashboard [project-name] [options]
 | Prompt | Description |
 |--------|-------------|
 | Project name | Directory to scaffold into |
-| MongoDB URI | Your MongoDB connection string (press Enter for a default) |
+| Storage backend | `mongodb` (default) or `google_sheets` |
+| MongoDB URI | Your MongoDB connection string (only if MongoDB chosen, press Enter for default) |
+| Google Sheet ID | Google Sheet ID (only if google_sheets chosen) |
+| Service account email | Google service account email (only if google_sheets chosen) |
+| Private key | Google service account private key (only if google_sheets chosen) |
 | League URL | The fantasy.iplt20.com league page URL |
-| Collection name | MongoDB collection to store this league's data (e.g. `ipl_2025_office_league`) |
-| League name | Display name for your league |
-| Teams | Team names (and optional owners) in your league
+| Collection/sheet name | MongoDB collection or Google sheet for this league's data |
+| League name | Used as collection/table name in storage |
 
-If `--scrape` is provided, the CLI attempts to extract team names from the league page HTML. If that fails, it falls back to manual entry.
+Set team names later via `app/data/teams.ts` or use `--scrape` to auto-detect from the league URL during scaffolding.
 
 ## Screenshots
 
@@ -81,16 +84,31 @@ cd my-league
 
 # Start the dev server
 npm run dev:simple
-
-# Capture auth state for scrapers (one-time setup)
-npm run capture:ipl-auth
-
-# Scrape live leaderboard data
-npm run sync:ipl
 ```
 
 Open http://localhost:3000 to see your dashboard.
 
+### Available commands
+
+| Command | Description |
+|---------|-------------|
+| `npm run dev` | Dev server with welcome splash |
+| `npm run dev:simple` | Dev server (simple, no splash) |
+| `npm run build` | Production build |
+| `npm start` | Production server |
+| `npm run capture:ipl-auth` | Capture Playwright login state (one-time) |
+| `npm run sync:ipl` | Scrape live leaderboard snapshot |
+| `npm run sync:ipl:watch` | Scrape leaderboard in watch mode (polls every 2 min) |
+| `npm run sync:ipl:transfers-daily` | Scrape transfer/booster data |
+| `npm run sync:cloud` | Run both leaderboard + transfer sync (for cloud jobs) |
+| `npm run seed:league` | Seed league metadata into storage |
+| `npm run seed:mongodb` | Seed initial raw user data from `data.ts` |
+| `npm run seed:mongodb:reset` | Reset and re-seed MongoDB data |
+| `npm run verify:production` | Verify production setup |
+| `npm run monitor:ops` | Check ops health status |
+| `npm run test` | Run test suite |
+| `npm run lint` | Run linter |
+
 ## How it works
 
 The CLI:
@@ -117,11 +135,13 @@ The template includes all dashboard components, API endpoints, scrapers, and tes
 npx @vatvaghool/create-ipl-dashboard another-league
 ```
 
-Provide a different collection name (e.g. `ipl_2025_friends_league`) and the new league will be stored in its own collection — data stays fully isolated.
+Provide a different league name and the new league will be stored in its own collection/sheet — data stays fully isolated.
 
 ### Viewing seeded data
 
-Connect to the MongoDB instance with any MongoDB client. Each league appears as a separate collection containing a document with `type: "league"` and all the metadata (name, URL, teams, timestamps).
+**MongoDB:** Connect with any MongoDB client. Each league appears as a separate collection with `type: "league"`.
+
+**Google Sheets:** Open your spreadsheet in a browser. Each league has its own sheet (tab) with league metadata in row 2.
 
 ### Production deployment
 
@@ -131,4 +151,23 @@ npm run build
 npx vercel --prod
 ```
 
-Set `IPL_POST_SECRET` in your Vercel dashboard. The `MONGODB_URI` and `COLLECTION_NAME` are already populated in the scaffolded `.env`.
+Set `IPL_POST_SECRET` in your Vercel dashboard. Storage credentials are already populated in the scaffolded `.env`.
+
+### Data sync workflow
+
+```bash
+# 1. Capture browser login (one-time)
+npm run capture:ipl-auth
+
+# 2. Scrape leaderboard (manual or watch mode)
+npm run sync:ipl
+npm run sync:ipl:watch     # auto-poll every 2 min
+
+# 3. Scrape transfer/booster data
+npm run sync:ipl:transfers-daily
+
+# 4. Run all scrapers (for cloud jobs)
+npm run sync:cloud
+```
+
+See the [Available commands](#quick-start-after-scaffold) table above for all options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vatvaghool/create-ipl-dashboard",
-  "version": "0.1.14",
+  "version": "0.1.17",
   "description": "Scaffold an IPL fantasy cricket dashboard project",
   "type": "module",
   "bin": {

package/src/index.mjs

@@ -3,12 +3,10 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import { getProjectName, getMongoUri, getLeagueUrl, getCollectionName, getLeagueName, getTeams, close } from "./prompts.mjs";
+import { getProjectName, getConnectionUrl, getLeagueUrl, getLeagueName, close } from "./prompts.mjs";
 import { scaffoldProject } from "./scaffold.mjs";
 import { scrapeTeamsFromUrl } from "./scraper.mjs";
 
-const DEFAULT_MONGODB_URI = "mongodb+srv://admin:admin@cricket.ptjjrub.mongodb.net/?appName=cricket";
-
 function printHelp(exitCode) {
   console.log(`
   create-ipl-dashboard [project-name] [options]
@@ -61,9 +59,8 @@ async function main() {
 
   await mkdir(projectPath, { recursive: true });
 
-  const mongoUri = await getMongoUri(DEFAULT_MONGODB_URI);
+  const conn = await getConnectionUrl();
   const leagueUrl = await getLeagueUrl();
-  const collectionName = await getCollectionName();
   const leagueName = await getLeagueName();
   let teams;
 
@@ -72,17 +69,12 @@ async function main() {
     teams = await scrapeTeamsFromUrl(leagueUrl);
     if (teams && teams.length > 0) {
       console.log(`  Found ${teams.length} team(s): ${teams.map((t) => t.name).join(", ")}`);
-    } else {
-      console.log("  Could not auto-detect teams. Enter them manually:");
-      teams = await getTeams();
     }
-  } else {
-    teams = await getTeams();
   }
 
   close();
 
-  await scaffoldProject(projectPath, { mongoUri, leagueUrl, collectionName, leagueName, teams, skipInstall: flags.skipInstall });
+  await scaffoldProject(projectPath, { conn, leagueUrl, leagueName, teams, skipInstall: flags.skipInstall });
 
   console.log("");
   console.log("  Next steps:");

package/src/prompts.mjs

@@ -1,5 +1,6 @@
 import { createInterface } from "node:readline";
 import { stdin as input, stdout as output, stdin } from "node:process";
+import * as readline from "node:readline";
 
 const isTTY = stdin.isTTY;
 
@@ -24,6 +25,86 @@ function prompt(query) {
   });
 }
 
+const BACKEND_VALUES = { mongodb: "mongodb", google_sheets: "google_sheets" };
+
+async function select(message, choices, valueMap) {
+  if (!isTTY) {
+    await consumeAllLines();
+    const answer = (pipedLines[promptIndex++] || "").trim().toLowerCase().replace(/[\s_-]+/g, "");
+    const match = choices.find((c) => c.toLowerCase().replace(/[\s_-]+/g, "").startsWith(answer));
+    const idx = match ? choices.indexOf(match) : 0;
+    return valueMap ? valueMap[Object.keys(valueMap)[idx]] : choices[idx];
+  }
+
+  return new Promise((resolve) => {
+    let selected = 0;
+    const rl = createInterface({ input, output });
+
+    function render(n) {
+      for (let i = 0; i < n; i++) {
+        readline.moveCursor(output, 0, -1);
+        readline.clearLine(output, 0);
+      }
+    }
+
+    process.stdout.write(`${message}\n`);
+    choices.forEach((c, i) => {
+      process.stdout.write(i === selected ? `\x1B[7m  ${c}  \x1B[0m\n` : `  ${c}\n`);
+    });
+
+    const numLines = choices.length;
+
+    readline.emitKeypressEvents(input);
+    if (input.isTTY) input.setRawMode(true);
+
+    function cleanup() {
+      input.setRawMode(false);
+      input.pause();
+      input.removeListener("keypress", handler);
+      rl.close();
+    }
+
+    function handler(str, key) {
+      if (!key) return;
+      if (key.name === "up" && selected > 0) {
+        selected--;
+        for (let i = 0; i < numLines; i++) readline.moveCursor(output, 0, -1);
+        choices.forEach((c, i) => {
+          readline.clearLine(output, 0);
+          readline.cursorTo(output, 0);
+          output.write(i === selected ? `\x1B[7m  ${c}  \x1B[0m` : `  ${c}  `);
+          if (i < numLines - 1) output.write("\n");
+        });
+        output.write("\n");
+      } else if (key.name === "down" && selected < numLines - 1) {
+        selected++;
+        for (let i = 0; i < numLines; i++) readline.moveCursor(output, 0, -1);
+        choices.forEach((c, i) => {
+          readline.clearLine(output, 0);
+          readline.cursorTo(output, 0);
+          output.write(i === selected ? `\x1B[7m  ${c}  \x1B[0m` : `  ${c}  `);
+          if (i < numLines - 1) output.write("\n");
+        });
+        output.write("\n");
+      } else if (key.name === "return") {
+        cleanup();
+        for (let i = 0; i < numLines + 1; i++) {
+          readline.moveCursor(output, 0, -1);
+          readline.clearLine(output, 0);
+        }
+        output.write(`${message} \x1B[32m${choices[selected]}\x1B[0m\n`);
+        const keys = Object.keys(valueMap || {});
+        resolve(valueMap ? valueMap[keys[selected]] : choices[selected]);
+      } else if (key.name === "c" && key.ctrl) {
+        cleanup();
+        process.exit(1);
+      }
+    }
+
+    input.on("keypress", handler);
+  });
+}
+
 export async function getProjectName(args) {
   if (args[0]) return args[0];
   if (!isTTY) {
@@ -33,63 +114,47 @@ export async function getProjectName(args) {
   return (await prompt("Project name: ")).trim() || "ipl-dashboard";
 }
 
-export async function getMongoUri(defaultUri) {
-  if (!isTTY) {
-    await consumeAllLines();
-    return (pipedLines[promptIndex++] || defaultUri || "").trim();
-  }
-  const answer = (await prompt(`MongoDB URI (press Enter for default): `)).trim();
-  return answer || defaultUri || "";
+export async function getStorageBackend() {
+  return select("Storage backend:", ["MongoDB", "Google Sheets"], BACKEND_VALUES);
 }
 
-export async function getLeagueUrl() {
-  if (!isTTY) {
-    await consumeAllLines();
-    return (pipedLines[promptIndex++] || "").trim();
+export async function getConnectionUrl() {
+  const backend = await getStorageBackend();
+  if (backend === "google_sheets") {
+    if (!isTTY) {
+      await consumeAllLines();
+      return { backend, sheetId: (pipedLines[promptIndex++] || "").trim(), serviceAccountEmail: (pipedLines[promptIndex++] || "").trim(), privateKey: (pipedLines[promptIndex++] || "").trim() };
+    }
+    console.log("\n  Google Sheets credentials:\n");
+    const sheetId = (await prompt("  Google Sheet ID: ")).trim();
+    const serviceAccountEmail = (await prompt("  Service account email: ")).trim();
+    const privateKey = (await prompt("  Private key (including -----BEGIN/END-----): ")).trim();
+    return { backend, sheetId, serviceAccountEmail, privateKey };
   }
-  return (await prompt("IPL fantasy league URL (or press Enter to skip, can be set later): ")).trim();
-}
 
-export async function getCollectionName() {
+  const DEFAULT_MONGODB_URI = "mongodb+srv://admin:admin@cricket.ptjjrub.mongodb.net/?appName=cricket";
   if (!isTTY) {
     await consumeAllLines();
-    return (pipedLines[promptIndex++] || "league_data").trim();
+    return { backend, uri: (pipedLines[promptIndex++] || DEFAULT_MONGODB_URI || "").trim() };
   }
-  return (await prompt("MongoDB collection name for league data (e.g. ipl_2025_office_league): ")).trim() || "league_data";
+  const answer = (await prompt("MongoDB URI (press Enter for default): ")).trim();
+  return { backend, uri: answer || DEFAULT_MONGODB_URI || "" };
 }
 
-export async function getLeagueName() {
+export async function getLeagueUrl() {
   if (!isTTY) {
     await consumeAllLines();
-    return (pipedLines[promptIndex++] || "My IPL League").trim();
+    return (pipedLines[promptIndex++] || "").trim();
   }
-  return (await prompt("League name (e.g. Office Fantasy League): ")).trim() || "My IPL League";
+  return (await prompt("IPL fantasy league URL: ")).trim();
 }
 
-export async function getTeams() {
+export async function getLeagueName() {
   if (!isTTY) {
     await consumeAllLines();
-    const count = Math.max(1, parseInt(pipedLines[promptIndex++], 10) || 9);
-    const teams = [];
-    for (let i = 0; i < count; i++) {
-      const line = pipedLines[promptIndex++] || "";
-      const parts = line.split(",").map((s) => s.trim());
-      teams.push({ id: i + 1, name: parts[0] || `Team ${i + 1}`, owner: parts[1] || parts[0] || `Team ${i + 1}` });
-    }
-    return teams;
-  }
-
-  const countAnswer = await prompt("How many teams in your league? (default: 9): ");
-  const count = Math.max(1, parseInt(countAnswer, 10) || 9);
-
-  console.log(`\nEnter ${count} team(s) — at minimum a name, optionally an owner:\n`);
-  const teams = [];
-  for (let i = 0; i < count; i++) {
-    const line = await prompt(`  Team ${i + 1} (Name or "Name,Owner"): `);
-    const parts = line.split(",").map((s) => s.trim());
-    teams.push({ id: i + 1, name: parts[0] || `Team ${i + 1}`, owner: parts[1] || parts[0] || `Team ${i + 1}` });
+    return (pipedLines[promptIndex++] || "my_league").trim();
   }
-  return teams;
+  return (await prompt("League name (used as collection/table name, e.g. my_office_league): ")).trim() || "my_league";
 }
 
 export function close() {}

package/src/scaffold.mjs

@@ -10,7 +10,7 @@ const TEMPLATE_DIR = join(PACKAGE_ROOT, "template");
 
 export async function scaffoldProject(
   projectPath,
-  { mongoUri, leagueUrl, collectionName, leagueName, teams, skipInstall = false },
+  { conn, leagueUrl, leagueName, teams, skipInstall = false },
 ) {
   console.log(`\nCreating project at ${projectPath}...`);
 
@@ -34,15 +34,14 @@ export async function scaffoldProject(
   }
 
   await writeEnvFile(projectPath, {
-    mongoUri,
+    conn,
     leagueUrl,
-    collectionName,
     leagueName,
   });
-  await writeTeamData(projectPath, teams);
-  await writeLeagueData(projectPath, { leagueName, leagueUrl, teams });
+  await writeTeamData(projectPath, teams || []);
+  await writeLeagueData(projectPath, { leagueName, leagueUrl, teams: teams || [] });
   await writeMatchPointsPlaceholder(projectPath);
-  await updatePackageJson(projectPath);
+  await updatePackageJson(projectPath, conn.backend);
 
   for (const f of [
     "app/api/ipl/live-snapshot.json",
@@ -57,15 +56,15 @@ export async function scaffoldProject(
     console.log("  Running npm install...");
     execSync("npm install", { cwd: projectPath, stdio: "inherit" });
 
-    if (mongoUri && leagueName) {
-      console.log("  Seeding league metadata into MongoDB...");
+    if (leagueName) {
+      console.log("  Seeding league metadata...");
       try {
-        execSync(`npm run seed:league -- "${leagueName}" "${collectionName}"`, {
+        execSync(`npm run seed:league -- "${leagueName}" "${leagueName}"`, {
           cwd: projectPath,
           stdio: "inherit",
         });
       } catch {
-        console.log("  League seed skipped (MongoDB may not be reachable yet)");
+        console.log("  League seed skipped (storage may not be reachable yet)");
       }
     }
   } else {
@@ -79,12 +78,15 @@ export async function scaffoldProject(
 
 async function writeEnvFile(
   projectPath,
-  { mongoUri, leagueUrl, collectionName, leagueName },
+  { conn, leagueUrl, leagueName },
 ) {
   const envPath = join(projectPath, ".env");
   const lines = [
-    `MONGODB_URI=${mongoUri || ""}`,
-    `COLLECTION_NAME=${collectionName || "league_data"}`,
+    `STORAGE_BACKEND=${conn.backend || "mongodb"}`,
+    `COLLECTION_NAME=${leagueName || "my_league"}`,
+    conn.backend === "google_sheets" ? `GOOGLE_SHEET_ID=${conn.sheetId || ""}` : `MONGODB_URI=${conn.uri || ""}`,
+    conn.backend === "google_sheets" ? `GOOGLE_SERVICE_ACCOUNT_EMAIL=${conn.serviceAccountEmail || ""}` : "",
+    conn.backend === "google_sheets" ? `GOOGLE_PRIVATE_KEY=${conn.privateKey || ""}` : "",
     `IPL_LEAGUE_URL=${leagueUrl || ""}`,
     `IPL_LEAGUE_NAME=${leagueName || ""}`,
     `IPL_POST_SECRET=`,
@@ -94,7 +96,7 @@ async function writeEnvFile(
     `IPL_API_LOG_PAYLOAD=0`,
     `IPL_WRITE_SEED_DATA_FILE=1`,
     ``,
-  ];
+  ].filter(Boolean);
   await writeFile(envPath, lines.join("\n"));
 }
 
@@ -180,7 +182,7 @@ async function writeMatchPointsPlaceholder(projectPath) {
   await writeFile(join(dir, "match-points.ts"), content);
 }
 
-async function updatePackageJson(projectPath) {
+async function updatePackageJson(projectPath, storageBackend) {
   const pkgPath = join(projectPath, "package.json");
   try {
     const raw = await readFile(pkgPath, "utf8");
@@ -189,6 +191,10 @@ async function updatePackageJson(projectPath) {
     pkg.private = false;
     delete pkg.scripts?.["generate:template"];
     pkg.scripts["seed:league"] = "node scripts/seed-league.mjs";
+    if (storageBackend === "google_sheets" && !pkg.dependencies.googleapis) {
+      pkg.dependencies = pkg.dependencies || {};
+      pkg.dependencies.googleapis = "^140.0.0";
+    }
     await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   } catch {}
 }

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

@@ -12,7 +12,7 @@ import {
   getTransformOptions,
 } from "./transform";
 import { rawApiUsers } from "./data";
-import getMongoDb from "../../lib/useDb";
+import { getStorage } from "../../lib/storage";
 import { config } from "../../lib/config.ts";
 
 export const dynamic = "force-dynamic";
@@ -54,39 +54,24 @@ const log = (message: string, details?: unknown) => {
 
 const opts = getTransformOptions();
 
-const getDb = async () => {
-  try {
-    return await getMongoDb();
-  } catch (error) {
-    console.error("MongoDB connection failed:", error);
-    return null;
-  }
-};
+const storage = getStorage();
 
 const readMongoSnapshot = async () => {
-  const db = await getDb();
-  if (!db) return null;
   try {
-    const document = await db
-      .collection(DASHBOARD_COLLECTION)
-      .findOne({ type: DASHBOARD_DOCUMENT_TYPE });
+    const document = await storage.readDocument(DASHBOARD_DOCUMENT_TYPE);
     return normalizePayload(document);
   } catch (error) {
-    console.error("Failed to read IPL snapshot from MongoDB:", error);
+    console.error("Failed to read IPL snapshot from storage:", error);
     return null;
   }
 };
 
 const readMongoRawUsers = async () => {
-  const db = await getDb();
-  if (!db) return null;
   try {
-    const document = await db
-      .collection(DASHBOARD_COLLECTION)
-      .findOne({ type: RAW_USERS_DOCUMENT_TYPE });
-    return normalizeRawApiUsers(document?.users);
+    const document = await storage.readDocument(RAW_USERS_DOCUMENT_TYPE);
+    return normalizeRawApiUsers((document?.users as any[]) ?? null);
   } catch (error) {
-    console.error("Failed to read IPL raw users from MongoDB:", error);
+    console.error("Failed to read IPL raw users from storage:", error);
     return null;
   }
 };
@@ -192,60 +177,44 @@ const snapshotSummary = (payload: ScrapedDashboardPayload | null) => {
 };
 
 const writeMongoSnapshot = async (payload: ScrapedDashboardPayload) => {
-  const db = await getDb();
-  if (!db) return { configured: false, stored: false };
+  if (!storage.isConfigured()) return { configured: false, stored: false };
   try {
     const current = await readMongoSnapshot();
     if (snapshotsAreEqual(current, payload)) {
       return { configured: true, stored: true, status: "unchanged" as const };
     }
-    await db.collection(DASHBOARD_COLLECTION).updateOne(
-      { type: DASHBOARD_DOCUMENT_TYPE },
-      {
-        $set: {
-          type: DASHBOARD_DOCUMENT_TYPE,
-          updatedAt: payload.updatedAt,
-          dailyTransferUpdatedAt: payload.dailyTransferUpdatedAt,
-          completedMatches: payload.completedMatches,
-          leaders: payload.leaders.map((l) => ({
-            ...l,
-            teamId: resolveTeamId(l.name),
-          })),
-        },
-      },
-      { upsert: true },
-    );
-    return { configured: true, stored: true, status: "updated" as const };
+    const result = await storage.upsertDocument(DASHBOARD_DOCUMENT_TYPE, {
+      updatedAt: payload.updatedAt,
+      dailyTransferUpdatedAt: payload.dailyTransferUpdatedAt,
+      completedMatches: payload.completedMatches,
+      leaders: payload.leaders.map((l) => ({
+        ...l,
+        teamId: resolveTeamId(l.name),
+      })),
+    });
+    return { configured: result.configured, stored: result.stored, status: result.status || "updated" };
   } catch (error) {
-    console.error("Failed to write IPL snapshot to MongoDB:", error);
+    console.error("Failed to write IPL snapshot to storage:", error);
     return { configured: true, stored: false, status: "failed" as const };
   }
 };
 
 const writeMongoRawUsers = async (users: RawApiUser[]) => {
-  const db = await getDb();
-  if (!db) return { configured: false, stored: false };
+  if (!storage.isConfigured()) return { configured: false, stored: false };
   try {
-    await db.collection(DASHBOARD_COLLECTION).updateOne(
-      { type: RAW_USERS_DOCUMENT_TYPE },
-      {
-        $set: {
-          type: RAW_USERS_DOCUMENT_TYPE,
-          updatedAt: new Date().toISOString(),
-          users: users.map((user) => ({
-            rno: user.rno,
-            temname: user.temname,
-            points: user.points,
-            teamId: resolveTeamId(user.temname),
-            matches: [...user.matches].sort((a, b) => a.matchId - b.matchId),
-          })),
-        },
-      },
-      { upsert: true },
-    );
-    return { configured: true, stored: true };
+    const result = await storage.upsertDocument(RAW_USERS_DOCUMENT_TYPE, {
+      updatedAt: new Date().toISOString(),
+      users: users.map((user) => ({
+        rno: user.rno,
+        temname: user.temname,
+        points: user.points,
+        teamId: resolveTeamId(user.temname),
+        matches: [...user.matches].sort((a, b) => a.matchId - b.matchId),
+      })),
+    });
+    return { configured: result.configured, stored: result.stored };
   } catch (error) {
-    console.error("Failed to write IPL raw users to MongoDB:", error);
+    console.error("Failed to write IPL raw users to storage:", error);
     return { configured: true, stored: false };
   }
 };

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

@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { readFile, writeFile } from "node:fs/promises";
-import getMongoDb from "../../../lib/useDb";
+import { getStorage } from "../../../lib/storage";
 import { config } from "../../../lib/config.ts";
 import type {
   ScrapedTransferItem,
@@ -49,35 +49,17 @@ const log = (message: string, details?: unknown) => {
   console.log(LOG_TAG, message, details);
 };
 
-const getDb = async () => {
-  try {
-    return await getMongoDb();
-  } catch (error) {
-    console.error("MongoDB connection failed:", error);
-    return null;
-  }
-};
+const storage = getStorage();
 
 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 documents = await storage.readDocuments(TRANSFER_DOCUMENT_TYPE);
     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);
+    console.error("Failed to read IPL transfer stats from storage:", error);
     return null;
   }
 };
@@ -98,45 +80,23 @@ const readSnapshotFile = async () => {
 };
 
 const writeMongoTransfer = async (record: ScrapedTransferItem) => {
-  const db = await getDb();
-
-  if (!db) {
-    return {
-      configured: false,
-      stored: false,
-    };
-  }
-
+  if (!storage.isConfigured()) return { configured: false, stored: false };
   try {
-    await db.collection(DASHBOARD_COLLECTION).updateOne(
+    const result = await storage.upsertDocument(
+      TRANSFER_DOCUMENT_TYPE,
       {
-        type: TRANSFER_DOCUMENT_TYPE,
         team: record.team,
+        matchesPlayed: record.matchesPlayed,
+        boostersUsed: record.boostersUsed,
+        transfersLeft: record.transfersLeft,
+        updatedAt: record.updatedAt,
       },
-      {
-        $set: {
-          type: TRANSFER_DOCUMENT_TYPE,
-          team: record.team,
-          matchesPlayed: record.matchesPlayed,
-          boostersUsed: record.boostersUsed,
-          transfersLeft: record.transfersLeft,
-          updatedAt: record.updatedAt,
-        },
-      },
-      { upsert: true },
+      { team: record.team },
     );
-
-    return {
-      configured: true,
-      stored: true,
-    };
+    return { configured: result.configured, stored: result.stored };
   } catch (error) {
-    console.error("Failed to write IPL transfer stats to MongoDB:", error);
-
-    return {
-      configured: true,
-      stored: false,
-    };
+    console.error("Failed to write IPL transfer stats to storage:", error);
+    return { configured: true, stored: false };
   }
 };
 

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

@@ -1,8 +1,8 @@
 import { NextResponse } from "next/server";
-import getMongoDb from "../../../lib/useDb";
+import { getStorage } from "../../../lib/storage";
 import { config } from "../../../lib/config.ts";
 import { normalizePayload } from "../../ipl/transform";
-import { summarizeTransferSnapshot } from "../../ipl/transfers/transform";
+import { normalizeTransferItem, summarizeTransferSnapshot } from "../../ipl/transfers/transform";
 
 export const dynamic = "force-dynamic";
 export const revalidate = 0;
@@ -64,73 +64,38 @@ const getFreshness = (
   };
 };
 
-const getDb = async () => {
-  try {
-    return await getMongoDb();
-  } catch (error) {
-    console.error("MongoDB connection failed:", error);
-    return null;
-  }
-};
+const storage = getStorage();
 
 export async function GET() {
-  const mongoConfigured = Boolean(process.env.MONGODB_URI);
-  const db = await getDb();
+  const storageConfigured = storage.isConfigured();
+  const storageConnected = await storage.isConnected();
 
-  if (!db) {
+  if (!storageConnected) {
     return NextResponse.json(
       {
         ok: !isProduction,
         mode: isProduction ? "cloud" : "local",
-        mongoConfigured,
+        mongoConfigured: storageConfigured,
         mongoConnected: false,
-        reason: mongoConfigured
-          ? "MongoDB connection failed."
-          : "MONGODB_URI is not configured.",
+        storageBackend: process.env.STORAGE_BACKEND || "mongodb",
+        reason: storageConfigured
+          ? "Storage connection failed."
+          : "Storage is not configured.",
       },
-      { status: mongoConfigured ? 503 : 200 },
+      { status: storageConfigured ? 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(),
+    storage.readDocument(DASHBOARD_DOCUMENT_TYPE),
+    storage.readDocument(RAW_USERS_DOCUMENT_TYPE),
+    storage.readDocuments(TRANSFER_DOCUMENT_TYPE),
   ]);
   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 transferItems = transferDocuments
+    .map((doc) => normalizeTransferItem(doc as any))
+    .filter(Boolean) as any[];
+  const transfers = summarizeTransferSnapshot(transferItems);
   const transfersUpdatedAt =
     transfers.teams.length > 0 ? transfers.updatedAt : undefined;
   const dashboardFreshness = getFreshness(
@@ -190,8 +155,9 @@ export async function GET() {
       status,
       mode: isProduction ? "cloud" : "local",
       checkedAt: new Date().toISOString(),
-      mongoConfigured,
-      mongoConnected: true,
+      mongoConfigured: storageConfigured,
+      mongoConnected: storageConnected,
+      storageBackend: process.env.STORAGE_BACKEND || "mongodb",
       localSnapshotFallbackEnabled: !isProduction,
       thresholds: {
         dashboardStaleMinutes,
@@ -207,7 +173,7 @@ export async function GET() {
           }
         : null,
       rawUsers: {
-        count: Array.isArray(rawUsersDocument?.users) ? rawUsersDocument.users.length : 0,
+        count: Array.isArray((rawUsersDocument as any)?.users) ? (rawUsersDocument as any).users.length : 0,
         updatedAt:
           typeof rawUsersDocument?.updatedAt === "string"
             ? rawUsersDocument.updatedAt

package/template/app/lib/config.ts

@@ -1,6 +1,10 @@
 import path from "node:path";
 
 export const config = {
+  storage: {
+    backend: process.env.STORAGE_BACKEND || "mongodb",
+  },
+
   mongodb: {
     databaseName: process.env.IPL_DB_NAME || "ipl",
     collectionName: process.env.IPL_COLLECTION_NAME || "ipl",

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

@@ -0,0 +1,147 @@
+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/storage/index.ts

@@ -0,0 +1,20 @@
+import type { IStorage } from "./types";
+import { MongoStorage } from "./mongo-storage";
+import { GoogleSheetsStorage } from "./google-sheets-storage";
+
+let _instance: IStorage | null = null;
+
+function detectBackend(): "mongodb" | "google_sheets" {
+  if (process.env.STORAGE_BACKEND === "google_sheets") return "google_sheets";
+  if (process.env.GOOGLE_SHEET_ID && process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL && process.env.GOOGLE_PRIVATE_KEY) return "google_sheets";
+  return "mongodb";
+}
+
+export function getStorage(): IStorage {
+  if (_instance) return _instance;
+  const backend = detectBackend();
+  _instance = backend === "google_sheets" ? new GoogleSheetsStorage() : new MongoStorage();
+  return _instance;
+}
+
+export type { IStorage } from "./types";

package/template/app/lib/storage/mongo-storage.ts

@@ -0,0 +1,53 @@
+import getMongoDb from "../useDb";
+import { config } from "../config";
+import type { IStorage, StorageResult } from "./types";
+
+const COLLECTION = config.mongodb.collectionName;
+
+export class MongoStorage implements IStorage {
+  isConfigured(): boolean {
+    return Boolean(process.env.MONGODB_URI);
+  }
+
+  async isConnected(): Promise<boolean> {
+    const db = await getMongoDb();
+    return db !== null;
+  }
+
+  async readDocument(type: string): Promise<Record<string, unknown> | null> {
+    const db = await getMongoDb();
+    if (!db) return null;
+    try {
+      return (await db.collection(COLLECTION).findOne({ type })) as Record<string, unknown> | null;
+    } catch {
+      return null;
+    }
+  }
+
+  async upsertDocument(
+    type: string,
+    data: Record<string, unknown>,
+    filter?: Record<string, unknown>,
+  ): Promise<StorageResult> {
+    const db = await getMongoDb();
+    if (!db) return { configured: true, stored: false, status: "no_connection" };
+    try {
+      const query = filter ? { type, ...filter } : { type };
+      await db.collection(COLLECTION).updateOne(query, { $set: { type, ...data } }, { upsert: true });
+      return { configured: true, stored: true, status: "updated" };
+    } catch (error) {
+      console.error(`Failed to upsert document type "${type}" in MongoDB:`, error);
+      return { configured: true, stored: false, status: "failed" };
+    }
+  }
+
+  async readDocuments(type: string): Promise<Record<string, unknown>[]> {
+    const db = await getMongoDb();
+    if (!db) return [];
+    try {
+      return (await db.collection(COLLECTION).find({ type }).toArray()) as Record<string, unknown>[];
+    } catch {
+      return [];
+    }
+  }
+}

package/template/app/lib/storage/types.ts

@@ -0,0 +1,13 @@
+export interface StorageResult {
+  configured: boolean;
+  stored: boolean;
+  status?: string;
+}
+
+export interface IStorage {
+  readDocument(type: string): Promise<Record<string, unknown> | null>;
+  upsertDocument(type: string, data: Record<string, unknown>, filter?: Record<string, unknown>): Promise<StorageResult>;
+  readDocuments(type: string): Promise<Record<string, unknown>[]>;
+  isConfigured(): boolean;
+  isConnected(): Promise<boolean>;
+}

package/template/scripts/seed-league.mjs

@@ -29,6 +29,61 @@ async function main() {
 
   const collectionName = process.argv[3] || process.env.COLLECTION_NAME?.trim() || sanitizeCollectionName(leagueName);
 
+  const isGoogleSheets = process.env.STORAGE_BACKEND === "google_sheets";
+
+  if (isGoogleSheets) {
+    const sheetId = process.env.GOOGLE_SHEET_ID;
+    const email = process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL;
+    const key = process.env.GOOGLE_PRIVATE_KEY;
+
+    if (!sheetId || !email || !key) {
+      console.log("Google Sheets not configured. Skipping league seed.");
+      return;
+    }
+
+    const leagueUrl = process.env.IPL_LEAGUE_URL?.trim();
+
+    let teams = [];
+    const leagueDataPath = join(ROOT, "app/data/league.ts");
+    if (existsSync(leagueDataPath)) {
+      try {
+        const content = readFileSync(leagueDataPath, "utf8");
+        const match = content.match(/teams:\s*\[([\s\S]*?)\],/);
+        if (match) {
+          const entries = [...match[1].matchAll(/\{\s*id:\s*(\d+),\s*name:\s*"([^"]+)",\s*owner:\s*"([^"]+)"\s*\}/g)];
+          teams = entries.map(([, id, name, owner]) => ({
+            id: Number(id),
+            name,
+            owner,
+          }));
+        }
+      } catch {}
+    }
+
+    const { google } = await import("googleapis");
+    const auth = new google.auth.GoogleAuth({
+      credentials: { client_email: email, private_key: key.replace(/\\n/g, "\n") },
+      scopes: ["https://www.googleapis.com/auth/spreadsheets"],
+    });
+    const sheets = google.sheets({ version: "v4", auth });
+    const sheetName = collectionName.replace(/[^a-z0-9_]/g, "_");
+
+    try {
+      await sheets.spreadsheets.values.append({
+        spreadsheetId: sheetId,
+        range: `${sheetName}!A:C`,
+        valueInputOption: "RAW",
+        requestBody: {
+          values: [["league", JSON.stringify({ name: leagueName, leagueUrl, teams }), new Date().toISOString()]],
+        },
+      });
+      console.log(`League "${leagueName}" seeded in sheet "${sheetName}" with ${teams.length} team(s).`);
+    } catch (error) {
+      console.error("Failed to seed league in Google Sheets:", error.message);
+    }
+    return;
+  }
+
   const uri = process.env.MONGODB_URI;
   if (!uri) {
     console.log("MONGODB_URI not set. Skipping league seed.");