spsays-training/scripts/seed-tlc.ts

/**
 * seed-tlc.ts — Push Teachings of Lord Caitanya JSON data into MongoDB.
 *
 * Uses the native MongoDB driver (same pattern as seed-nod.ts) to avoid
 * Prisma replica-set write requirements.
 *
 * TLC is a prose book (like NoD) with no volume structure.
 * We use volume=0 as the sentinel for "no volumes".
 *
 * Collections written:
 *   - book_meta       → one doc { book: "tlc", data: <intro.json> }
 *   - prose_chapters  → 9 intro segments + 32 chapters
 *
 * Usage:
 *   npx tsx scripts/seed-tlc.ts
 */

import dotenv from "dotenv";
import fs from "fs";
import path from "path";
import { MongoClient } from "mongodb";

// Load env
dotenv.config({ path: ".env.local" });
dotenv.config({ path: ".env" });

const DATABASE_URL = process.env.DATABASE_URL;
if (!DATABASE_URL) {
  console.error("❌ DATABASE_URL is not set in .env");
  process.exit(1);
}

const BASE_DIR = path.resolve(__dirname, "..");
const TLC_DIR = path.join(BASE_DIR, "lib", "jsons", "books", "tlc");

/** Volume sentinel for books without volumes. */
const NO_VOLUME = 0;

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function readJson<T>(filePath: string): T {
  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
}

/**
 * Insert documents one at a time with a small delay every N docs.
 * Uses insertOne to avoid BSON wire-protocol corruption.
 */
async function insertBatched(
  col: ReturnType<ReturnType<MongoClient["db"]>["collection"]>,
  docs: Record<string, unknown>[],
) {
  for (let i = 0; i < docs.length; i++) {
    await col.insertOne(docs[i]);
    if ((i + 1) % 100 === 0) {
      await new Promise((r) => setTimeout(r, 100));
    }
  }
}

// ---------------------------------------------------------------------------
// Types for the JSON files
// ---------------------------------------------------------------------------

type TlcIntroJson = {
  book: string;
  title: string;
  subtitle: string;
  author: string;
  year: number;
  description: string;
  totalChapters: number;
  parts: { number: number; title: string; chapters: number[] }[];
  chapters: { number: number; title: string }[];
};

type TlcIntroSegmentJson = {
  slug: string;
  title: string;
  type: string;
  book: string;
  order: number;
  paragraphs: string[];
};

type TlcChapterJson = {
  book: string;
  chapter: number | null;
  title: string;
  type: string;
  slug?: string;
  paragraphs: string[];
};

// ---------------------------------------------------------------------------
// Seed function
// ---------------------------------------------------------------------------

async function seedTlc(db: ReturnType<MongoClient["db"]>) {
  const introPath = path.join(TLC_DIR, "intro.json");
  if (!fs.existsSync(introPath)) {
    console.error("❌ TLC intro.json not found at", introPath);
    process.exit(1);
  }

  const intro = readJson<TlcIntroJson>(introPath);

  // ---- Book meta ----
  const metaCol = db.collection("book_meta");
  await metaCol.deleteMany({ book: "tlc" });
  await metaCol.insertOne({ book: "tlc", data: intro });
  console.log("  📖 TLC book meta inserted");

  // ---- Prose chapters collection ----
  const proseCol = db.collection("prose_chapters");
  await proseCol.deleteMany({ book: "tlc" });

  const docs: Record<string, unknown>[] = [];

  // Intro segments
  const introDir = path.join(TLC_DIR, "intro");
  if (fs.existsSync(introDir)) {
    const introFiles = fs
      .readdirSync(introDir)
      .filter((f) => f.endsWith(".json"))
      .sort();

    let fallbackOrder = 0;
    for (const file of introFiles) {
      const seg = readJson<TlcIntroSegmentJson>(path.join(introDir, file));
      fallbackOrder++;
      docs.push({
        book: "tlc",
        volume: NO_VOLUME,
        chapter: null,
        title: seg.title,
        type: seg.type || "intro-segment",
        slug: `intro-${seg.slug || file.replace(".json", "")}`,
        order: seg.order ?? fallbackOrder,
        paragraphs: seg.paragraphs,
      });
    }
    console.log(`  📄 Intro segments: ${introFiles.length}`);
  }

  // Chapters (01.json – 32.json)
  const chaptersDir = path.join(TLC_DIR, "chapters");
  if (fs.existsSync(chaptersDir)) {
    const chapterFiles = fs
      .readdirSync(chaptersDir)
      .filter((f) => f.endsWith(".json"))
      .sort();

    for (const file of chapterFiles) {
      const ch = readJson<TlcChapterJson>(path.join(chaptersDir, file));
      const chNum = ch.chapter ?? parseInt(file.replace(".json", ""), 10);
      docs.push({
        book: "tlc",
        volume: NO_VOLUME,
        chapter: chNum,
        title: ch.title,
        type: ch.type || "chapter",
        slug: String(chNum),
        order: 100 + chNum,
        paragraphs: ch.paragraphs,
      });
    }
    console.log(`  📖 Chapters: ${chapterFiles.length}`);
  }

  // Insert all docs
  console.log(`\n  Inserting ${docs.length} documents...`);
  await insertBatched(proseCol, docs);

  const totalDocs = await proseCol.countDocuments({ book: "tlc" });
  console.log(`  ✅ TLC: ${totalDocs} prose entries in MongoDB`);
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

async function main() {
  console.log("🌱 Seeding Teachings of Lord Caitanya...\n");

  const client = new MongoClient(DATABASE_URL!);
  await client.connect();
  console.log("📡 Connected to MongoDB\n");

  const db = client.db();

  const start = Date.now();

  await seedTlc(db);

  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
  console.log(`\n🎉 Done in ${elapsed}s`);

  await client.close();
}

main().catch((err) => {
  console.error("❌ Seed failed:", err);
  process.exit(1);
});