672 lines
20 KiB
TypeScript
672 lines
20 KiB
TypeScript
/**
|
|
* seed-db.ts — Push all extracted JSON data into MongoDB using the native driver.
|
|
*
|
|
* Prisma with MongoDB requires a replica set for writes (even createMany/deleteMany).
|
|
* This script uses the MongoDB native driver directly to avoid that constraint.
|
|
* The collections and field names match the Prisma schema so the frontend can
|
|
* still read via Prisma without issues.
|
|
*
|
|
* Usage:
|
|
* npx tsx scripts/seed-db.ts
|
|
*
|
|
* Prerequisites:
|
|
* - DATABASE_URL must be set in .env
|
|
* - All extraction scripts (bg, sb, cc, glossary) must have been run
|
|
*/
|
|
|
|
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 LIB_DIR = path.join(BASE_DIR, "lib", "jsons");
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function readJson<T>(filePath: string): T {
|
|
return JSON.parse(fs.readFileSync(filePath, "utf-8"));
|
|
}
|
|
|
|
function readAllJsonInDir(dir: string): unknown[] {
|
|
if (!fs.existsSync(dir)) return [];
|
|
return fs
|
|
.readdirSync(dir)
|
|
.filter((f) => f.endsWith(".json"))
|
|
.sort()
|
|
.map((f) => readJson(path.join(dir, f)));
|
|
}
|
|
|
|
/**
|
|
* Insert documents one at a time with a small delay every N docs.
|
|
*
|
|
* Uses insertOne to avoid BSON wire-protocol corruption that occurs
|
|
* with insertMany on certain MongoDB server/proxy configurations.
|
|
* A brief pause every 100 docs prevents connection overload.
|
|
*/
|
|
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]);
|
|
// Pause briefly every 100 docs to give the connection breathing room
|
|
if ((i + 1) % 100 === 0) {
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Types
|
|
// ---------------------------------------------------------------------------
|
|
|
|
type BgVerse = {
|
|
book_title: string;
|
|
chapter: number;
|
|
verse: number;
|
|
verse_end?: number;
|
|
reference: string;
|
|
devanagari: string;
|
|
transliteration: string;
|
|
synonyms: { word: string; meanings: string[] }[];
|
|
translation: string;
|
|
purport: string[];
|
|
};
|
|
|
|
type SbVerse = {
|
|
book_title: string;
|
|
canto: number;
|
|
chapter: number;
|
|
verse: number;
|
|
verse_end?: number;
|
|
reference: string;
|
|
devanagari: string;
|
|
transliteration: string;
|
|
synonyms: { word: string; meanings: string[] }[];
|
|
translation: string;
|
|
purport: string[];
|
|
};
|
|
|
|
type CcVerse = {
|
|
book_title: string;
|
|
lila: string;
|
|
chapter: number;
|
|
verse: number;
|
|
verse_end?: number;
|
|
reference: string;
|
|
devanagari: string;
|
|
bengali: string;
|
|
transliteration: string;
|
|
synonyms: { word: string; meanings: string[] }[];
|
|
translation: string;
|
|
purport: string[];
|
|
};
|
|
|
|
type ProseChapterJson = {
|
|
book: string;
|
|
volume: number;
|
|
chapter?: number;
|
|
title: string;
|
|
type: string;
|
|
slug?: string;
|
|
order?: number;
|
|
paragraphs: string[];
|
|
};
|
|
|
|
type Sb1962Verse = {
|
|
book_title: string;
|
|
chapter: number;
|
|
verse: number;
|
|
verse_end?: number;
|
|
reference: string;
|
|
transliteration: string;
|
|
synonyms: { word: string; meanings: string[] }[];
|
|
translation: string;
|
|
purport: string[];
|
|
};
|
|
|
|
type GlossaryData = {
|
|
title: string;
|
|
description: string;
|
|
totalEntries: number;
|
|
letters: string[];
|
|
entries: {
|
|
term: string;
|
|
definition: string;
|
|
definition_html: string;
|
|
}[];
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// BG
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function seedBg(db: ReturnType<MongoClient["db"]>) {
|
|
const introPath = path.join(LIB_DIR, "books", "bg", "intro.json");
|
|
if (!fs.existsSync(introPath)) {
|
|
console.log(" ⏭ BG intro.json not found, skipping");
|
|
return;
|
|
}
|
|
|
|
const intro = readJson(introPath);
|
|
|
|
// Book meta
|
|
const metaCol = db.collection("book_meta");
|
|
await metaCol.deleteMany({ book: "bg" });
|
|
await metaCol.insertOne({ book: "bg", data: intro });
|
|
console.log(" 📖 BG book meta inserted");
|
|
|
|
// Verses
|
|
const versesCol = db.collection("verses");
|
|
await versesCol.deleteMany({ book: "bg" });
|
|
|
|
const chaptersDir = path.join(LIB_DIR, "books", "bg", "chapters");
|
|
if (!fs.existsSync(chaptersDir)) {
|
|
console.log(" ⏭ BG chapters dir not found, skipping verses");
|
|
return;
|
|
}
|
|
|
|
const chapterDirs = fs
|
|
.readdirSync(chaptersDir)
|
|
.filter((d) => fs.statSync(path.join(chaptersDir, d)).isDirectory())
|
|
.sort();
|
|
|
|
const docs: Record<string, unknown>[] = [];
|
|
|
|
for (const chDir of chapterDirs) {
|
|
const versesDir = path.join(chaptersDir, chDir, "verses");
|
|
const verses = readAllJsonInDir(versesDir) as BgVerse[];
|
|
|
|
for (const v of verses) {
|
|
docs.push({
|
|
book: "bg",
|
|
division: null,
|
|
chapter: v.chapter,
|
|
verse: v.verse,
|
|
verseEnd: v.verse_end ?? null,
|
|
reference: v.reference,
|
|
bookTitle: v.book_title,
|
|
devanagari: v.devanagari,
|
|
bengali: null,
|
|
transliteration: v.transliteration,
|
|
synonyms: v.synonyms,
|
|
translation: v.translation,
|
|
purport: v.purport,
|
|
});
|
|
}
|
|
}
|
|
|
|
await insertBatched(versesCol, docs);
|
|
console.log(` ✅ BG: ${docs.length} verses`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// SB
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function seedSb(db: ReturnType<MongoClient["db"]>) {
|
|
const introPath = path.join(LIB_DIR, "books", "sb", "intro.json");
|
|
if (!fs.existsSync(introPath)) {
|
|
console.log(" ⏭ SB intro.json not found, skipping");
|
|
return;
|
|
}
|
|
|
|
const intro = readJson(introPath);
|
|
|
|
const metaCol = db.collection("book_meta");
|
|
await metaCol.deleteMany({ book: "sb" });
|
|
await metaCol.insertOne({ book: "sb", data: intro });
|
|
console.log(" 📖 SB book meta inserted");
|
|
|
|
const versesCol = db.collection("verses");
|
|
await versesCol.deleteMany({ book: "sb" });
|
|
|
|
const cantosDir = path.join(LIB_DIR, "books", "sb", "cantos");
|
|
if (!fs.existsSync(cantosDir)) {
|
|
console.log(" ⏭ SB cantos dir not found, skipping verses");
|
|
return;
|
|
}
|
|
|
|
const cantoDirs = fs
|
|
.readdirSync(cantosDir)
|
|
.filter((d) => fs.statSync(path.join(cantosDir, d)).isDirectory())
|
|
.sort();
|
|
|
|
let totalCount = 0;
|
|
|
|
for (const cantoDir of cantoDirs) {
|
|
const chaptersDir = path.join(cantosDir, cantoDir, "chapters");
|
|
if (!fs.existsSync(chaptersDir)) continue;
|
|
|
|
const chapterDirs = fs
|
|
.readdirSync(chaptersDir)
|
|
.filter((d) => fs.statSync(path.join(chaptersDir, d)).isDirectory())
|
|
.sort();
|
|
|
|
const cantoDocs: Record<string, unknown>[] = [];
|
|
|
|
for (const chDir of chapterDirs) {
|
|
const versesDir = path.join(chaptersDir, chDir, "verses");
|
|
const verses = readAllJsonInDir(versesDir) as SbVerse[];
|
|
|
|
for (const v of verses) {
|
|
cantoDocs.push({
|
|
book: "sb",
|
|
division: String(v.canto),
|
|
chapter: v.chapter,
|
|
verse: v.verse,
|
|
verseEnd: v.verse_end ?? null,
|
|
reference: v.reference,
|
|
bookTitle: v.book_title,
|
|
devanagari: v.devanagari,
|
|
bengali: null,
|
|
transliteration: v.transliteration,
|
|
synonyms: v.synonyms,
|
|
translation: v.translation,
|
|
purport: v.purport,
|
|
});
|
|
}
|
|
}
|
|
|
|
await insertBatched(versesCol, cantoDocs);
|
|
totalCount += cantoDocs.length;
|
|
console.log(` Canto ${cantoDir}: ${cantoDocs.length} verses`);
|
|
}
|
|
|
|
console.log(` ✅ SB: ${totalCount} verses`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CC
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function seedCc(db: ReturnType<MongoClient["db"]>) {
|
|
const introPath = path.join(LIB_DIR, "books", "cc", "intro.json");
|
|
if (!fs.existsSync(introPath)) {
|
|
console.log(" ⏭ CC intro.json not found, skipping");
|
|
return;
|
|
}
|
|
|
|
const intro = readJson(introPath);
|
|
|
|
const metaCol = db.collection("book_meta");
|
|
await metaCol.deleteMany({ book: "cc" });
|
|
await metaCol.insertOne({ book: "cc", data: intro });
|
|
console.log(" 📖 CC book meta inserted");
|
|
|
|
const versesCol = db.collection("verses");
|
|
await versesCol.deleteMany({ book: "cc" });
|
|
|
|
const lilasDir = path.join(LIB_DIR, "books", "cc", "lilas");
|
|
if (!fs.existsSync(lilasDir)) {
|
|
console.log(" ⏭ CC lilas dir not found, skipping verses");
|
|
return;
|
|
}
|
|
|
|
const lilaDirs = fs
|
|
.readdirSync(lilasDir)
|
|
.filter((d) => fs.statSync(path.join(lilasDir, d)).isDirectory())
|
|
.sort();
|
|
|
|
let totalCount = 0;
|
|
|
|
for (const lilaDir of lilaDirs) {
|
|
const chaptersDir = path.join(lilasDir, lilaDir, "chapters");
|
|
if (!fs.existsSync(chaptersDir)) continue;
|
|
|
|
const chapterDirs = fs
|
|
.readdirSync(chaptersDir)
|
|
.filter((d) => fs.statSync(path.join(chaptersDir, d)).isDirectory())
|
|
.sort();
|
|
|
|
const lilaDocs: Record<string, unknown>[] = [];
|
|
|
|
for (const chDir of chapterDirs) {
|
|
const versesDir = path.join(chaptersDir, chDir, "verses");
|
|
const verses = readAllJsonInDir(versesDir) as CcVerse[];
|
|
|
|
for (const v of verses) {
|
|
lilaDocs.push({
|
|
book: "cc",
|
|
division: v.lila,
|
|
chapter: v.chapter,
|
|
verse: v.verse,
|
|
verseEnd: v.verse_end ?? null,
|
|
reference: v.reference,
|
|
bookTitle: v.book_title,
|
|
devanagari: v.devanagari,
|
|
bengali: v.bengali,
|
|
transliteration: v.transliteration,
|
|
synonyms: v.synonyms,
|
|
translation: v.translation,
|
|
purport: v.purport,
|
|
});
|
|
}
|
|
}
|
|
|
|
await insertBatched(versesCol, lilaDocs);
|
|
totalCount += lilaDocs.length;
|
|
console.log(` Līlā ${lilaDir}: ${lilaDocs.length} verses`);
|
|
}
|
|
|
|
console.log(` ✅ CC: ${totalCount} verses`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// SB 1962
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function seedSb1962(db: ReturnType<MongoClient["db"]>) {
|
|
const introPath = path.join(LIB_DIR, "books", "sb-1962", "intro.json");
|
|
if (!fs.existsSync(introPath)) {
|
|
console.log(" ⏭ SB 1962 intro.json not found, skipping");
|
|
return;
|
|
}
|
|
|
|
const intro = readJson(introPath);
|
|
|
|
const metaCol = db.collection("book_meta");
|
|
await metaCol.deleteMany({ book: "sb1962" });
|
|
await metaCol.insertOne({ book: "sb1962", data: intro });
|
|
console.log(" 📖 SB 1962 book meta inserted");
|
|
|
|
const versesCol = db.collection("verses");
|
|
await versesCol.deleteMany({ book: "sb1962" });
|
|
|
|
const chaptersDir = path.join(LIB_DIR, "books", "sb-1962", "chapters");
|
|
if (!fs.existsSync(chaptersDir)) {
|
|
console.log(" ⏭ SB 1962 chapters dir not found, skipping verses");
|
|
return;
|
|
}
|
|
|
|
const chapterDirs = fs
|
|
.readdirSync(chaptersDir)
|
|
.filter((d) => fs.statSync(path.join(chaptersDir, d)).isDirectory())
|
|
.sort();
|
|
|
|
const docs: Record<string, unknown>[] = [];
|
|
|
|
for (const chDir of chapterDirs) {
|
|
const versesDir = path.join(chaptersDir, chDir, "verses");
|
|
const verses = readAllJsonInDir(versesDir) as Sb1962Verse[];
|
|
|
|
for (const v of verses) {
|
|
docs.push({
|
|
book: "sb1962",
|
|
division: null,
|
|
chapter: v.chapter,
|
|
verse: v.verse,
|
|
verseEnd: v.verse_end ?? null,
|
|
reference: v.reference,
|
|
bookTitle: v.book_title,
|
|
devanagari: "",
|
|
bengali: null,
|
|
transliteration: v.transliteration,
|
|
synonyms: v.synonyms,
|
|
translation: v.translation,
|
|
purport: v.purport,
|
|
});
|
|
}
|
|
}
|
|
|
|
await insertBatched(versesCol, docs);
|
|
console.log(` ✅ SB 1962: ${docs.length} verses`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Kṛṣṇa Book
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function seedKb(db: ReturnType<MongoClient["db"]>) {
|
|
const introPath = path.join(LIB_DIR, "books", "kb", "intro.json");
|
|
if (!fs.existsSync(introPath)) {
|
|
console.log(" ⏭ KB intro.json not found, skipping");
|
|
return;
|
|
}
|
|
|
|
const intro = readJson(introPath);
|
|
|
|
// Book meta
|
|
const metaCol = db.collection("book_meta");
|
|
await metaCol.deleteMany({ book: "kb" });
|
|
await metaCol.insertOne({ book: "kb", data: intro });
|
|
console.log(" 📖 KB book meta inserted");
|
|
|
|
// Prose chapters collection
|
|
const proseCol = db.collection("prose_chapters");
|
|
await proseCol.deleteMany({ book: "kb" });
|
|
|
|
const docs: Record<string, unknown>[] = [];
|
|
|
|
// Volume 1 intro segments
|
|
const vol1IntroDir = path.join(LIB_DIR, "books", "kb", "vol-1", "intro");
|
|
if (fs.existsSync(vol1IntroDir)) {
|
|
const introFiles = fs
|
|
.readdirSync(vol1IntroDir)
|
|
.filter((f) => f.endsWith(".json"))
|
|
.sort();
|
|
|
|
const introDocsV1: Record<string, unknown>[] = [];
|
|
for (const file of introFiles) {
|
|
const seg = readJson<ProseChapterJson>(path.join(vol1IntroDir, file));
|
|
introDocsV1.push({
|
|
book: "kb",
|
|
volume: seg.volume ?? 1,
|
|
chapter: seg.chapter ?? null,
|
|
title: seg.title,
|
|
type: seg.type || "intro-segment",
|
|
slug: seg.slug || file.replace(".json", ""),
|
|
order: seg.order ?? 0,
|
|
paragraphs: seg.paragraphs,
|
|
});
|
|
}
|
|
await insertBatched(proseCol, introDocsV1);
|
|
console.log(` Vol 1 intro segments: ${introFiles.length}`);
|
|
}
|
|
|
|
// Volume 1 chapters
|
|
const vol1ChapDir = path.join(LIB_DIR, "books", "kb", "vol-1", "chapters");
|
|
if (fs.existsSync(vol1ChapDir)) {
|
|
const chapterFiles = fs
|
|
.readdirSync(vol1ChapDir)
|
|
.filter((f) => f.endsWith(".json"))
|
|
.sort();
|
|
|
|
const chapDocsV1: Record<string, unknown>[] = [];
|
|
for (const file of chapterFiles) {
|
|
const ch = readJson<ProseChapterJson>(path.join(vol1ChapDir, file));
|
|
chapDocsV1.push({
|
|
book: "kb",
|
|
volume: ch.volume ?? 1,
|
|
chapter: ch.chapter ?? null,
|
|
title: ch.title,
|
|
type: ch.type || "chapter",
|
|
slug: String(ch.chapter ?? file.replace(".json", "")).padStart(2, "0"),
|
|
order: 100 + (ch.chapter ?? 0),
|
|
paragraphs: ch.paragraphs,
|
|
});
|
|
}
|
|
await insertBatched(proseCol, chapDocsV1);
|
|
console.log(` Vol 1 chapters: ${chapterFiles.length}`);
|
|
}
|
|
|
|
// Volume 2 intro segments
|
|
const vol2IntroDir = path.join(LIB_DIR, "books", "kb", "vol-2", "intro");
|
|
if (fs.existsSync(vol2IntroDir)) {
|
|
const introFiles = fs
|
|
.readdirSync(vol2IntroDir)
|
|
.filter((f) => f.endsWith(".json"))
|
|
.sort();
|
|
|
|
const introDocsV2: Record<string, unknown>[] = [];
|
|
for (const file of introFiles) {
|
|
const seg = readJson<ProseChapterJson>(path.join(vol2IntroDir, file));
|
|
introDocsV2.push({
|
|
book: "kb",
|
|
volume: seg.volume ?? 2,
|
|
chapter: seg.chapter ?? null,
|
|
title: seg.title,
|
|
type: seg.type || "intro-segment",
|
|
slug: seg.slug || file.replace(".json", ""),
|
|
order: seg.order ?? 0,
|
|
paragraphs: seg.paragraphs,
|
|
});
|
|
}
|
|
await insertBatched(proseCol, introDocsV2);
|
|
console.log(` Vol 2 intro segments: ${introFiles.length}`);
|
|
}
|
|
|
|
// Volume 2 chapters
|
|
const vol2ChapDir = path.join(LIB_DIR, "books", "kb", "vol-2", "chapters");
|
|
if (fs.existsSync(vol2ChapDir)) {
|
|
const chapterFiles = fs
|
|
.readdirSync(vol2ChapDir)
|
|
.filter((f) => f.endsWith(".json"))
|
|
.sort();
|
|
|
|
const chapDocsV2: Record<string, unknown>[] = [];
|
|
for (const file of chapterFiles) {
|
|
const ch = readJson<ProseChapterJson>(path.join(vol2ChapDir, file));
|
|
chapDocsV2.push({
|
|
book: "kb",
|
|
volume: ch.volume ?? 2,
|
|
chapter: ch.chapter ?? null,
|
|
title: ch.title,
|
|
type: ch.type || "chapter",
|
|
slug: String(ch.chapter ?? file.replace(".json", "")).padStart(2, "0"),
|
|
order: 100 + (ch.chapter ?? 0),
|
|
paragraphs: ch.paragraphs,
|
|
});
|
|
}
|
|
await insertBatched(proseCol, chapDocsV2);
|
|
console.log(` Vol 2 chapters: ${chapterFiles.length}`);
|
|
}
|
|
|
|
const totalDocs = await proseCol.countDocuments({ book: "kb" });
|
|
console.log(` ✅ KB: ${totalDocs} prose entries`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Glossary
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function seedGlossary(db: ReturnType<MongoClient["db"]>) {
|
|
const glossaryPath = path.join(LIB_DIR, "glossary", "index.json");
|
|
if (!fs.existsSync(glossaryPath)) {
|
|
console.log(" ⏭ Glossary index.json not found, skipping");
|
|
return;
|
|
}
|
|
|
|
const data = readJson<GlossaryData>(glossaryPath);
|
|
|
|
const col = db.collection("glossary");
|
|
await col.deleteMany({});
|
|
|
|
const glossaryDocs = data.entries.map((entry) => ({
|
|
term: entry.term,
|
|
definition: entry.definition,
|
|
definitionHtml: entry.definition_html,
|
|
}));
|
|
|
|
await insertBatched(col, glossaryDocs);
|
|
console.log(` ✅ Glossary: ${glossaryDocs.length} entries`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Create indexes (matching Prisma schema)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function createIndexes(db: ReturnType<MongoClient["db"]>) {
|
|
console.log(" 📇 Creating indexes...");
|
|
|
|
const versesCol = db.collection("verses");
|
|
await versesCol.createIndex({ book: 1 });
|
|
await versesCol.createIndex({ book: 1, division: 1 });
|
|
await versesCol.createIndex({ book: 1, division: 1, chapter: 1 });
|
|
await versesCol.createIndex(
|
|
{ book: 1, division: 1, chapter: 1, verse: 1 },
|
|
{ unique: true },
|
|
);
|
|
|
|
const metaCol = db.collection("book_meta");
|
|
await metaCol.createIndex({ book: 1 }, { unique: true });
|
|
|
|
const glossaryCol = db.collection("glossary");
|
|
await glossaryCol.createIndex({ term: 1 }, { unique: true });
|
|
|
|
const proseCol = db.collection("prose_chapters");
|
|
await proseCol.createIndex({ book: 1 });
|
|
await proseCol.createIndex({ book: 1, volume: 1 });
|
|
await proseCol.createIndex({ book: 1, volume: 1, slug: 1 }, { unique: true });
|
|
await proseCol.createIndex({ book: 1, volume: 1, type: 1 });
|
|
|
|
console.log(" ✅ Indexes created");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Main
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function main() {
|
|
console.log("🌱 Seeding database...\n");
|
|
|
|
const client = new MongoClient(DATABASE_URL!);
|
|
await client.connect();
|
|
console.log("📡 Connected to MongoDB\n");
|
|
|
|
const db = client.db(); // uses the database name from the URL
|
|
|
|
const start = Date.now();
|
|
|
|
console.log("[1/6] Bhagavad-gītā");
|
|
await seedBg(db);
|
|
console.log();
|
|
|
|
console.log("[2/6] Śrīmad-Bhāgavatam");
|
|
await seedSb(db);
|
|
console.log();
|
|
|
|
console.log("[3/6] Śrī Caitanya-caritāmṛta");
|
|
await seedCc(db);
|
|
console.log();
|
|
|
|
console.log("[4/6] Śrīmad-Bhāgavatam (1962 Edition)");
|
|
await seedSb1962(db);
|
|
console.log();
|
|
|
|
console.log("[5/7] Kṛṣṇa Book");
|
|
await seedKb(db);
|
|
console.log();
|
|
|
|
console.log("[6/7] Glossary");
|
|
await seedGlossary(db);
|
|
console.log();
|
|
|
|
console.log("[7/7] Indexes");
|
|
await createIndexes(db);
|
|
console.log();
|
|
|
|
const elapsed = ((Date.now() - start) / 1000).toFixed(1);
|
|
console.log(`🎉 Done in ${elapsed}s`);
|
|
|
|
await client.close();
|
|
}
|
|
|
|
main().catch((e) => {
|
|
console.error("❌ Seed failed:", e);
|
|
process.exit(1);
|
|
});
|