@vatvaghool/create-ipl-dashboard 0.1.14 → 0.1.15

package/README.md

@@ -27,9 +27,13 @@ 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`) |
+| Collection/sheet name | MongoDB collection or Google sheet for this league's data |
 | League name | Display name for your league |
 | Teams | Team names (and optional owners) in your league
 

package/package.json

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

package/src/index.mjs

@@ -3,7 +3,7 @@
 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, getMongoUri, getStorageBackend, getGoogleSheetsConfig, getLeagueUrl, getCollectionName, getLeagueName, getTeams, close } from "./prompts.mjs";
 import { scaffoldProject } from "./scaffold.mjs";
 import { scrapeTeamsFromUrl } from "./scraper.mjs";
 
@@ -61,7 +61,16 @@ async function main() {
 
   await mkdir(projectPath, { recursive: true });
 
-  const mongoUri = await getMongoUri(DEFAULT_MONGODB_URI);
+  const storageBackend = await getStorageBackend();
+  let mongoUri = "";
+  let googleSheets = {};
+
+  if (storageBackend === "google_sheets") {
+    googleSheets = await getGoogleSheetsConfig();
+  } else {
+    mongoUri = await getMongoUri(DEFAULT_MONGODB_URI);
+  }
+
   const leagueUrl = await getLeagueUrl();
   const collectionName = await getCollectionName();
   const leagueName = await getLeagueName();
@@ -82,7 +91,7 @@ async function main() {
 
   close();
 
-  await scaffoldProject(projectPath, { mongoUri, leagueUrl, collectionName, leagueName, teams, skipInstall: flags.skipInstall });
+  await scaffoldProject(projectPath, { mongoUri, storageBackend, googleSheets, leagueUrl, collectionName, leagueName, teams, skipInstall: flags.skipInstall });
 
   console.log("");
   console.log("  Next steps:");

package/src/prompts.mjs

@@ -50,12 +50,36 @@ export async function getLeagueUrl() {
   return (await prompt("IPL fantasy league URL (or press Enter to skip, can be set later): ")).trim();
 }
 
+export async function getStorageBackend() {
+  if (!isTTY) {
+    await consumeAllLines();
+    return (pipedLines[promptIndex++] || "mongodb").trim();
+  }
+  const answer = (await prompt("Storage backend (mongodb / google_sheets, default: mongodb): ")).trim().toLowerCase();
+  return answer === "google_sheets" ? "google_sheets" : "mongodb";
+}
+
+export async function getGoogleSheetsConfig() {
+  if (!isTTY) {
+    await consumeAllLines();
+    const sheetId = (pipedLines[promptIndex++] || "").trim();
+    const email = (pipedLines[promptIndex++] || "").trim();
+    const key = (pipedLines[promptIndex++] || "").trim();
+    return { sheetId, serviceAccountEmail: email, privateKey: key };
+  }
+  console.log("\n  Google Sheets configuration:\n");
+  const sheetId = (await prompt("  Google Sheet ID: ")).trim();
+  const serviceAccountEmail = (await prompt("  Service account email: ")).trim();
+  const privateKey = (await prompt("  Private key (paste the full key, including -----BEGIN/END-----): ")).trim();
+  return { sheetId, serviceAccountEmail, privateKey };
+}
+
 export async function getCollectionName() {
   if (!isTTY) {
     await consumeAllLines();
     return (pipedLines[promptIndex++] || "league_data").trim();
   }
-  return (await prompt("MongoDB collection name for league data (e.g. ipl_2025_office_league): ")).trim() || "league_data";
+  return (await prompt("Collection/sheet name for this league's data (e.g. ipl_2025_office_league): ")).trim() || "league_data";
 }
 
 export async function getLeagueName() {

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 },
+  { mongoUri, storageBackend, googleSheets, leagueUrl, collectionName, leagueName, teams, skipInstall = false },
 ) {
   console.log(`\nCreating project at ${projectPath}...`);
 
@@ -35,6 +35,8 @@ export async function scaffoldProject(
 
   await writeEnvFile(projectPath, {
     mongoUri,
+    storageBackend,
+    googleSheets,
     leagueUrl,
     collectionName,
     leagueName,
@@ -42,7 +44,7 @@ export async function scaffoldProject(
   await writeTeamData(projectPath, teams);
   await writeLeagueData(projectPath, { leagueName, leagueUrl, teams });
   await writeMatchPointsPlaceholder(projectPath);
-  await updatePackageJson(projectPath);
+  await updatePackageJson(projectPath, storageBackend);
 
   for (const f of [
     "app/api/ipl/live-snapshot.json",
@@ -57,15 +59,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}"`, {
           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 +81,16 @@ export async function scaffoldProject(
 
 async function writeEnvFile(
   projectPath,
-  { mongoUri, leagueUrl, collectionName, leagueName },
+  { mongoUri, storageBackend, googleSheets, leagueUrl, collectionName, leagueName },
 ) {
   const envPath = join(projectPath, ".env");
   const lines = [
+    `STORAGE_BACKEND=${storageBackend || "mongodb"}`,
     `MONGODB_URI=${mongoUri || ""}`,
     `COLLECTION_NAME=${collectionName || "league_data"}`,
+    `GOOGLE_SHEET_ID=${(googleSheets && googleSheets.sheetId) || ""}`,
+    `GOOGLE_SERVICE_ACCOUNT_EMAIL=${(googleSheets && googleSheets.serviceAccountEmail) || ""}`,
+    `GOOGLE_PRIVATE_KEY=${(googleSheets && googleSheets.privateKey) || ""}`,
     `IPL_LEAGUE_URL=${leagueUrl || ""}`,
     `IPL_LEAGUE_NAME=${leagueName || ""}`,
     `IPL_POST_SECRET=`,
@@ -180,7 +186,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 +195,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.");