Use novel refactor (lnreader#1838)

* init

* feat: add zustand dependency and persistence key contract

* refactor: extract bootstrap data loading into reusable service

* refactor: move chapter mutations into store-ready action helpers

* feat: add zustand novel store with cache and core actions

* refactor: bridge novel persistence contracts for migration safety

* refactor: migrate NovelScreen domain flows to zustand selectors

* refactor: migrate NovelScreenList to selector-based store access

* refactor: move reader chapter flows onto store boundaries

* refactor: decouple useNovelSettings from broad context domain state

* refactor: align migrateNovel with stable persistence contracts

* refactor: cut novel-reader consumers to store-only context boundary

* refactor: retire legacy useNovel and route cache cleanup export

* test: update suites for store-only context boundary cutover

* test: modernize store-era mocks and add contract coverage

* test: finalize Task-15 sweep—remove dead useNovelData and lint clear mocksContract

Final validation confirms mock-contract test suite clean and target file deletion verified with zero stale references in src/ scope.

* remove imports from NovelScreen

* reworked ai output

* improvements

* implemented synchronus novel and chapter fetch

* refactor tests

* fix db tests

* Update remaining tests.

* Harden chapter actions and bootstrap flows

* Only count filtered chapters

* improved chapter insert speed by optimizing triggers

* Improved the batching function

* Added drizzle support to dbManager.batch

* removed better-sqlite3 for testing

* fix tests

* Update updateNovelChapters fucntion

* reverse read filter

* fix snackbar

* fixed page bottomsheet

* resolved paged novels showing wrong chapter number on opening

* use openPage instead of setPageIndex in chapterDrawer

* fix lint & tests

* fix type issues

* fix various smaller issues

* updated novel restore

* Delete tsconfig.tsbuildinfo

Author: CD-Z

__mocks__/database.js

@@ -1,4 +1,5 @@
 jest.mock('@database/queries/NovelQueries', () => ({
+  getNovelById: jest.fn(),
   getNovelByPath: jest.fn(),
   deleteCachedNovels: jest.fn(),
   getCachedNovels: jest.fn(),
@@ -30,7 +31,9 @@ jest.mock('@database/queries/ChapterQueries', () => ({
   insertChapters: jest.fn(),
   getCustomPages: jest.fn(),
   getChapterCount: jest.fn(),
+  getChapterCountSync: jest.fn(),
   getPageChaptersBatched: jest.fn(),
+  getNovelChaptersSync: jest.fn(),
   getFirstUnreadChapter: jest.fn(),
   updateChapterProgress: jest.fn(),
 }));

package.json

@@ -118,7 +118,8 @@
     "react-native-worklets": "^0.8.1",
     "react-native-zip-archive": "^7.0.2",
     "sanitize-html": "^2.17.2",
-    "urlencode": "^2.0.0"
+    "urlencode": "^2.0.0",
+    "zustand": "^5.0.12"
   },
   "devDependencies": {
     "@babel/core": "^7.29.0",
@@ -145,7 +146,7 @@
     "@typescript-eslint/parser": "^8.58.0",
     "babel-plugin-module-resolver": "^5.0.3",
     "babel-plugin-react-compiler": "^1.0.0",
-    "better-sqlite3": "^12.8.0",
+    "better-sqlite3": "^12.9.0",
     "drizzle-kit": "1.0.0-beta.20",
     "eslint": "^8.57.1",
     "eslint-plugin-eslint-comments": "^3.2.0",

pnpm-lock.yaml

@@ -1,22 +1,9 @@
-import Database from 'better-sqlite3';
+import { open, type DB } from '@op-engineering/op-sqlite';
 import { drizzle } from 'drizzle-orm/op-sqlite';
 import { migrate } from 'drizzle-orm/op-sqlite/migrator';
 import migrations from '../../../drizzle/migrations';
 import { schema } from '@database/schema';
 
-jest.mock('@op-engineering/op-sqlite', () => ({
-  __esModule: true,
-  open: jest.fn(() => ({
-    execute: jest.fn().mockResolvedValue({ rows: [] }),
-    executeAsync: jest.fn().mockResolvedValue({ rows: [] }),
-    executeSync: jest.fn().mockReturnValue({ rows: [] }),
-    executeRawAsync: jest.fn().mockResolvedValue([]),
-    executeBatch: jest.fn().mockResolvedValue(undefined),
-    flushPendingReactiveQueries: jest.fn(),
-    reactiveExecute: jest.fn(() => () => undefined),
-  })),
-}));
-
 import { runDatabaseBootstrap } from '@database/db';
 
 const MIGRATION_STATEMENTS = [
@@ -80,84 +67,26 @@ const MIGRATION_STATEMENTS = [
   `CREATE UNIQUE INDEX IF NOT EXISTS repository_url_unique ON Repository (url)`,
 ];
 
-const createExecutor = (sqlite: Database.Database) => ({
+const createExecutor = (sqlite: DB) => ({
   executeSync: (sql: string, params?: unknown[]) => {
-    if (params && params.length) {
-      const stmt = sqlite.prepare(sql);
-      stmt.run(params as any[]);
-      return;
-    }
-    sqlite.exec(sql);
+    sqlite.executeSync(sql, params as any[]);
   },
 });
 
-const createOpSqliteAdapter = (sqlite: Database.Database) => {
-  return {
-    execute: async (sql: string, params?: unknown[]) => {
-      const stmt = sqlite.prepare(sql);
-      const rows =
-        params && params.length ? stmt.all(params as any[]) : stmt.all();
-      return {
-        rows: {
-          _array: rows.map(row =>
-            Object.values(row as Record<string, unknown>),
-          ),
-        },
-      };
-    },
-    executeSync: (sql: string, params?: unknown[]) => {
-      const stmt = sqlite.prepare(sql);
-      const result =
-        params && params.length ? stmt.run(params as any[]) : stmt.run();
-      return { rows: [], rowsAffected: result.changes ?? 0 };
-    },
-    executeAsync: async (sql: string, params?: unknown[]) => {
-      const stmt = sqlite.prepare(sql);
-      const result =
-        params && params.length ? stmt.run(params as any[]) : stmt.run();
-      return { rows: [], rowsAffected: result.changes ?? 0 };
-    },
-    executeRawAsync: async (sql: string, params?: unknown[]) => {
-      const stmt = sqlite.prepare(sql).raw();
-      const rows =
-        params && params.length ? stmt.all(params as any[]) : stmt.all();
-      return rows as unknown[][];
-    },
-    executeBatch: async (
-      commands: Array<[string, unknown[] | unknown[][]]>,
-    ) => {
-      const transaction = sqlite.transaction((cmds: typeof commands) => {
-        for (const cmd of cmds) {
-          const stmt = sqlite.prepare(cmd[0]);
-          if (Array.isArray(cmd[1])) {
-            for (const arg of cmd[1]) {
-              stmt.run(arg as any[]);
-            }
-          } else {
-            stmt.run(cmd[1] as any[]);
-          }
-        }
-      });
-      transaction(commands);
-    },
-    flushPendingReactiveQueries: () => undefined,
-    reactiveExecute: () => () => undefined,
-  };
-};
-
 describe('new database initialization', () => {
   it('creates schema, triggers, and default data', async () => {
-    const sqlite = new Database(':memory:');
+    const sqlite = open({ name: ':memory:' });
+    (sqlite as any).executeAsync ??= sqlite.execute;
+    (sqlite as any).executeRawAsync ??= sqlite.executeRaw;
     try {
-      const adapter = createOpSqliteAdapter(sqlite);
-      const drizzleDb = drizzle(adapter, { schema });
+      const drizzleDb = drizzle(sqlite, { schema });
 
       await migrate(drizzleDb, migrations);
       runDatabaseBootstrap(createExecutor(sqlite));
 
-      const tables = sqlite
-        .prepare("SELECT name FROM sqlite_master WHERE type='table'")
-        .all() as Array<{ name: string }>;
+      const tables = sqlite.executeSync(
+        "SELECT name FROM sqlite_master WHERE type='table'",
+      ).rows as Array<{ name: string }>;
       const tableNames = tables.map(table => table.name);
       expect(tableNames).toEqual(
         expect.arrayContaining([
@@ -169,9 +98,9 @@ describe('new database initialization', () => {
         ]),
       );
 
-      const triggers = sqlite
-        .prepare("SELECT name FROM sqlite_master WHERE type='trigger'")
-        .all() as Array<{ name: string }>;
+      const triggers = sqlite.executeSync(
+        "SELECT name FROM sqlite_master WHERE type='trigger'",
+      ).rows as Array<{ name: string }>;
       const triggerNames = triggers.map(trigger => trigger.name);
       expect(triggerNames).toEqual(
         expect.arrayContaining([
@@ -182,9 +111,9 @@ describe('new database initialization', () => {
         ]),
       );
 
-      const categories = sqlite
-        .prepare('SELECT id, name FROM Category ORDER BY id')
-        .all() as Array<{ id: number; name: string }>;
+      const categories = sqlite.executeSync(
+        'SELECT id, name FROM Category ORDER BY id',
+      ).rows as Array<{ id: number; name: string }>;
       expect(categories.map(category => category.id)).toEqual([1, 2]);
     } finally {
       sqlite.close();
@@ -194,20 +123,23 @@ describe('new database initialization', () => {
 
 describe('runDatabaseBootstrap', () => {
   it('applies pragmas, triggers, and default categories', () => {
-    const sqlite = new Database(':memory:');
+    const sqlite = open({ name: ':memory:' });
+    (sqlite as any).executeAsync ??= sqlite.execute;
+    (sqlite as any).executeRawAsync ??= sqlite.executeRaw;
     try {
       for (const statement of MIGRATION_STATEMENTS) {
-        sqlite.exec(statement.trim());
+        sqlite.executeSync(statement.trim());
       }
 
+      sqlite.executeSync('PRAGMA journal_mode = WAL');
       runDatabaseBootstrap(createExecutor(sqlite));
 
-      const journalMode = sqlite.pragma('journal_mode', { simple: true });
+      const journalMode = sqlite.executeRawSync('PRAGMA journal_mode')[0]?.[0];
       expect(['wal', 'memory']).toContain(String(journalMode).toLowerCase());
 
-      const triggers = sqlite
-        .prepare("SELECT name FROM sqlite_master WHERE type='trigger'")
-        .all() as Array<{ name: string }>;
+      const triggers = sqlite.executeSync(
+        "SELECT name FROM sqlite_master WHERE type='trigger'",
+      ).rows as Array<{ name: string }>;
       const triggerNames = triggers.map(trigger => trigger.name);
       expect(triggerNames).toEqual(
         expect.arrayContaining([
@@ -218,9 +150,9 @@ describe('runDatabaseBootstrap', () => {
         ]),
       );
 
-      const categories = sqlite
-        .prepare('SELECT id, name FROM Category ORDER BY id')
-        .all() as Array<{ id: number; name: string }>;
+      const categories = sqlite.executeSync(
+        'SELECT id, name FROM Category ORDER BY id',
+      ).rows as Array<{ id: number; name: string }>;
       expect(categories.map(category => category.id)).toEqual([1, 2]);
       expect(categories.map(category => category.name)).toEqual([
         'categories.default',
@@ -234,19 +166,20 @@ describe('runDatabaseBootstrap', () => {
 
 describe('production migrations', () => {
   it('can run after test schema exists', async () => {
-    const sqlite = new Database(':memory:');
+    const sqlite = open({ name: ':memory:' });
+    (sqlite as any).executeAsync ??= sqlite.execute;
+    (sqlite as any).executeRawAsync ??= sqlite.executeRaw;
     try {
       for (const statement of MIGRATION_STATEMENTS) {
-        sqlite.exec(statement.trim());
+        sqlite.executeSync(statement.trim());
       }
 
-      const adapter = createOpSqliteAdapter(sqlite);
-      const drizzleDb = drizzle(adapter, { schema });
+      const drizzleDb = drizzle(sqlite, { schema });
       await migrate(drizzleDb, migrations);
 
-      const tables = sqlite
-        .prepare("SELECT name FROM sqlite_master WHERE type='table'")
-        .all() as Array<{ name: string }>;
+      const tables = sqlite.executeSync(
+        "SELECT name FROM sqlite_master WHERE type='table'",
+      ).rows as Array<{ name: string }>;
       const tableNames = tables.map(table => table.name);
       expect(tableNames).toEqual(
         expect.arrayContaining([

src/database/__tests__/db.test.ts

@@ -69,6 +69,10 @@ const populateDatabase = (executor: SqlExecutor) => {
 
 const createDbTriggers = (executor: SqlExecutor) => {
   console.log('Creating database triggers');
+  executor.executeSync('DROP TRIGGER IF EXISTS update_novel_stats');
+  executor.executeSync('DROP TRIGGER IF EXISTS update_novel_stats_on_update');
+  executor.executeSync('DROP TRIGGER IF EXISTS update_novel_stats_on_delete');
+  executor.executeSync('DROP TRIGGER IF EXISTS add_category');
   executor.executeSync(createCategoryTriggerQuery);
   executor.executeSync(createNovelTriggerQueryDelete);
   executor.executeSync(createNovelTriggerQueryInsert);

src/database/db.ts

@@ -1,5 +1,10 @@
 // db-manager.types.ts
-import type { SQLiteTransaction, TablesRelationalConfig } from 'drizzle-orm';
+import type {
+  SQLiteTransaction,
+  TablesRelationalConfig,
+  Placeholder,
+} from 'drizzle-orm';
+import { SQLitePreparedQuery } from 'drizzle-orm/sqlite-core';
 
 // Define the TransactionParameter type based on your DrizzleDb
 export type TransactionParameter = SQLiteTransaction<
@@ -14,6 +19,18 @@ export type TransactionParameter = SQLiteTransaction<
  * This contract ensures consistent documentation and type safety across the application.
  */
 export interface IDbManager {
+  /**
+   * Efficiently executes a Drizzle query for multiple data rows using
+   * op-sqlite executeBatch under the hood.
+   */
+  batch<T extends Record<string, unknown>>(
+    data: T[],
+    fn: (
+      tx: TransactionParameter,
+      ph: (arg: Extract<keyof T, string>) => Placeholder,
+    ) => SQLitePreparedQuery<any>,
+  ): Promise<void>;
+
   /**
    * Creates a subquery that defines a temporary named result set as a CTE.
    *