bible.html

Author: jvinodraj

api/.env.example

@@ -7,7 +7,7 @@ ALLOWED_ORIGINS=https://ziongospelministry.org,https://www.ziongospelministry.or
 SMTP_HOST=smtp.gmail.com
 SMTP_PORT=587
 SMTP_SECURE=false
-SMTP_USER=your-smtp-user
+SMTP_USER=vio
 SMTP_PASS=your-smtp-password-or-app-password
 
 # Mail routing.

api/schema/bible_reader_schema.sql

@@ -0,0 +1,53 @@
+-- Bible Reader persistence schema
+-- Suitable for PostgreSQL / MySQL style relational databases
+
+CREATE TABLE IF NOT EXISTS users (
+  id BIGSERIAL PRIMARY KEY,
+  external_id VARCHAR(64) UNIQUE NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS bible_bookmarks (
+  id BIGSERIAL PRIMARY KEY,
+  user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  book_slug VARCHAR(64) NOT NULL,
+  chapter_num INTEGER NOT NULL,
+  verse_num INTEGER NULL,
+  note TEXT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE (user_id, book_slug, chapter_num, verse_num)
+);
+
+CREATE TABLE IF NOT EXISTS bible_reading_progress (
+  id BIGSERIAL PRIMARY KEY,
+  user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  book_slug VARCHAR(64) NOT NULL,
+  chapter_num INTEGER NOT NULL,
+  verse_num INTEGER NULL,
+  scroll_pct DECIMAL(5,2) NULL,
+  last_read_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE (user_id, book_slug, chapter_num)
+);
+
+CREATE TABLE IF NOT EXISTS bible_reading_plans (
+  id BIGSERIAL PRIMARY KEY,
+  code VARCHAR(40) UNIQUE NOT NULL,
+  title VARCHAR(120) NOT NULL,
+  total_days INTEGER NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS bible_reading_plan_progress (
+  id BIGSERIAL PRIMARY KEY,
+  user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  plan_id BIGINT NOT NULL REFERENCES bible_reading_plans(id) ON DELETE CASCADE,
+  completed_days INTEGER NOT NULL DEFAULT 0,
+  completed_chapters JSONB NULL,
+  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE (user_id, plan_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_bookmarks_user ON bible_bookmarks(user_id);
+CREATE INDEX IF NOT EXISTS idx_progress_user_last_read ON bible_reading_progress(user_id, last_read_at DESC);
+CREATE INDEX IF NOT EXISTS idx_plan_progress_user ON bible_reading_plan_progress(user_id);

api/server.js

@@ -1,6 +1,8 @@
 const express = require("express");
 const cors = require("cors");
 const nodemailer = require("nodemailer");
+const fs = require("fs/promises");
+const path = require("path");
 require("dotenv").config();
 
 const app = express();
@@ -20,6 +22,11 @@ const allowedOrigins = String(process.env.ALLOWED_ORIGINS || "")
 
 const origins = allowedOrigins.length ? allowedOrigins : defaultAllowedOrigins;
 const allowAllOrigins = origins.includes("*");
+const repoRoot = path.resolve(__dirname, "..");
+const bibleBooksMetaPath = path.join(repoRoot, "assets", "data", "bible-books.json");
+const userStateDir = path.join(__dirname, "data");
+const userStatePath = path.join(userStateDir, "bible-user-state.json");
+const bibleChapterCache = new Map();
 
 function normalizeOrigin(value) {
   try {
@@ -74,6 +81,92 @@ app.use(cors({
 
 app.use(express.json({ limit: "100kb" }));
 
+async function readJsonFile(filePath, fallback) {
+  try {
+    const content = await fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (_err) {
+    return fallback;
+  }
+}
+
+async function writeJsonFile(filePath, payload) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(payload, null, 2), "utf8");
+}
+
+function normalizeBookPayload(payload, bookName) {
+  if (payload && payload.book && Array.isArray(payload.chapters)) {
+    const chapterMap = {};
+    payload.chapters.forEach((ch) => {
+      const chapterNum = String(ch.chapter || "");
+      if (!chapterNum) return;
+      chapterMap[chapterNum] = chapterMap[chapterNum] || {};
+      (ch.verses || []).forEach((verse) => {
+        chapterMap[chapterNum][String(verse.verse)] = String(verse.text || "");
+      });
+    });
+    return chapterMap;
+  }
+
+  if (payload && payload[bookName] && typeof payload[bookName] === "object") {
+    return payload[bookName];
+  }
+
+  return payload && typeof payload === "object" ? payload : {};
+}
+
+function numericSort(a, b) {
+  return Number(a) - Number(b);
+}
+
+function sanitizeUserId(input) {
+  const userId = String(input || "").trim();
+  if (!/^[a-zA-Z0-9_-]{2,64}$/.test(userId)) return "anonymous";
+  return userId;
+}
+
+function defaultUserBibleState() {
+  return {
+    bookmarks: [],
+    progress: {},
+    plans: {},
+    recents: []
+  };
+}
+
+async function getBooksMeta() {
+  return readJsonFile(bibleBooksMetaPath, []);
+}
+
+async function getBookMetaBySlug(bookSlug) {
+  const books = await getBooksMeta();
+  return books.find((book) => book.slug === bookSlug) || null;
+}
+
+async function getBookChapters(bookSlug) {
+  if (bibleChapterCache.has(bookSlug)) return bibleChapterCache.get(bookSlug);
+
+  const book = await getBookMetaBySlug(bookSlug);
+  if (!book) return null;
+
+  const sourcePath = path.join(repoRoot, "bible-data", book.file);
+  const payload = await readJsonFile(sourcePath, null);
+  if (!payload) return null;
+
+  const chapterMap = normalizeBookPayload(payload, book.name);
+  bibleChapterCache.set(bookSlug, chapterMap);
+  return chapterMap;
+}
+
+async function getAllUserState() {
+  return readJsonFile(userStatePath, {});
+}
+
+async function saveAllUserState(payload) {
+  await writeJsonFile(userStatePath, payload);
+}
+
 function buildTransporter() {
   const host = process.env.SMTP_HOST;
   const portNumber = Number(process.env.SMTP_PORT || 587);
@@ -120,6 +213,169 @@ app.get("/api/health", (_req, res) => {
   res.status(200).json({ ok: true });
 });
 
+app.get("/api/bible/books", async (_req, res) => {
+  const books = await getBooksMeta();
+  res.status(200).json({ ok: true, items: books });
+});
+
+app.get("/api/bible/search", async (req, res) => {
+  const q = String(req.query.q || "").trim().toLowerCase();
+  const scope = String(req.query.scope || "all").toLowerCase();
+  const page = Math.max(1, Number(req.query.page || 1));
+  const limit = Math.min(100, Math.max(1, Number(req.query.limit || 20)));
+
+  if (!q) {
+    res.status(400).json({ ok: false, error: "Search query q is required." });
+    return;
+  }
+
+  const books = (await getBooksMeta()).filter((book) => {
+    if (scope === "ot") return book.testament === "ot";
+    if (scope === "nt") return book.testament === "nt";
+    return true;
+  });
+
+  const matches = [];
+  for (const book of books) {
+    const chapters = await getBookChapters(book.slug);
+    if (!chapters) continue;
+
+    for (const [chapterNum, verses] of Object.entries(chapters)) {
+      for (const [verseNum, text] of Object.entries(verses || {})) {
+        const verseText = String(text || "");
+        if (!verseText.toLowerCase().includes(q)) continue;
+        matches.push({
+          book: book.name,
+          bookSlug: book.slug,
+          chapter: Number(chapterNum),
+          verse: Number(verseNum),
+          text: verseText
+        });
+      }
+    }
+  }
+
+  const total = matches.length;
+  const start = (page - 1) * limit;
+  const items = matches.slice(start, start + limit);
+  res.status(200).json({ ok: true, query: q, scope, page, limit, total, items });
+});
+
+app.get("/api/bible/audio/:bookSlug/:chapter", async (req, res) => {
+  const book = await getBookMetaBySlug(req.params.bookSlug);
+  const chapter = Number(req.params.chapter || 0);
+  if (!book || !chapter || chapter < 1 || chapter > book.chapters) {
+    res.status(404).json({ ok: false, error: "Audio chapter not found." });
+    return;
+  }
+
+  res.status(200).json({
+    ok: true,
+    book: book.name,
+    chapter,
+    sourceType: "tts",
+    streamUrl: null,
+    supportsBackgroundPlayback: true,
+    supportsVerseTiming: false,
+    cues: []
+  });
+});
+
+app.get("/api/bible/:bookSlug", async (req, res) => {
+  const book = await getBookMetaBySlug(req.params.bookSlug);
+  if (!book) {
+    res.status(404).json({ ok: false, error: "Book not found." });
+    return;
+  }
+
+  const chapters = await getBookChapters(book.slug);
+  const chapterNumbers = Object.keys(chapters || {}).sort(numericSort).map(Number);
+  res.status(200).json({ ok: true, item: { ...book, chapterNumbers } });
+});
+
+app.get("/api/bible/:bookSlug/:chapter", async (req, res) => {
+  const book = await getBookMetaBySlug(req.params.bookSlug);
+  const chapter = Number(req.params.chapter || 0);
+  if (!book || !chapter) {
+    res.status(404).json({ ok: false, error: "Chapter not found." });
+    return;
+  }
+
+  const chapters = await getBookChapters(book.slug);
+  const chapterMap = chapters ? chapters[String(chapter)] : null;
+  if (!chapterMap) {
+    res.status(404).json({ ok: false, error: "Chapter not found." });
+    return;
+  }
+
+  const verses = Object.keys(chapterMap)
+    .sort(numericSort)
+    .map((verse) => ({ verse: Number(verse), text: String(chapterMap[verse] || "") }));
+
+  res.status(200).json({
+    ok: true,
+    item: {
+      book: book.name,
+      bookSlug: book.slug,
+      chapter,
+      verses
+    }
+  });
+});
+
+app.get("/api/bible/:bookSlug/:chapter/:verse", async (req, res) => {
+  const book = await getBookMetaBySlug(req.params.bookSlug);
+  const chapter = Number(req.params.chapter || 0);
+  const verse = Number(req.params.verse || 0);
+
+  if (!book || !chapter || !verse) {
+    res.status(404).json({ ok: false, error: "Verse not found." });
+    return;
+  }
+
+  const chapters = await getBookChapters(book.slug);
+  const text = chapters && chapters[String(chapter)] ? chapters[String(chapter)][String(verse)] : null;
+  if (!text) {
+    res.status(404).json({ ok: false, error: "Verse not found." });
+    return;
+  }
+
+  res.status(200).json({
+    ok: true,
+    item: {
+      book: book.name,
+      bookSlug: book.slug,
+      chapter,
+      verse,
+      text: String(text)
+    }
+  });
+});
+
+app.get("/api/user/:userId/bible/state", async (req, res) => {
+  const userId = sanitizeUserId(req.params.userId);
+  const allState = await getAllUserState();
+  res.status(200).json({ ok: true, userId, item: allState[userId] || defaultUserBibleState() });
+});
+
+app.patch("/api/user/:userId/bible/state", async (req, res) => {
+  const userId = sanitizeUserId(req.params.userId);
+  const patch = req.body || {};
+
+  const allState = await getAllUserState();
+  const prev = allState[userId] || defaultUserBibleState();
+  const next = {
+    bookmarks: Array.isArray(patch.bookmarks) ? patch.bookmarks : prev.bookmarks,
+    progress: patch.progress && typeof patch.progress === "object" ? patch.progress : prev.progress,
+    plans: patch.plans && typeof patch.plans === "object" ? patch.plans : prev.plans,
+    recents: Array.isArray(patch.recents) ? patch.recents.slice(0, 50) : prev.recents
+  };
+
+  allState[userId] = next;
+  await saveAllUserState(allState);
+  res.status(200).json({ ok: true, userId, item: next });
+});
+
 app.post("/api/contact", async (req, res) => {
   const { payload, error } = validatePayload(req.body || {});
   if (error) {