Use novel refactor

__mocks__/react-native-nitro-modules.js

@@ -6,5 +6,26 @@ jest.mock('react-native-nitro-modules', () => ({
       // Return a mock object that won't be used since MMKV has its own mock
       return {};
     }),
+  ];
+
+module.exports = {
+  MMKV,
+  useMMKVString: createTupleHook(key => strings.get(key)),
+  useMMKVNumber: createTupleHook(key => numbers.get(key)),
+  useMMKVBoolean: createTupleHook(key => booleans.get(key)),
+  useMMKVObject: createTupleHook(key => {
+    const json = strings.get(key);
+    if (!json) {
+      return undefined;
+    }
+
+    try {
+      return JSON.parse(json);
+    } catch {
+      return undefined;
+    }
+  }),
+  NitroModules: {
+    createHybridObject: 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",

src/database/manager/manager.ts

@@ -71,9 +71,9 @@ class DbManager implements IDbManager {
     >;
   }
 
-  public async allSync<T extends ExecutableSelect>(
+  public allSync<T extends ExecutableSelect>(
     query: T,
-  ): Promise<Awaited<ReturnType<T['all']>>> {
+  ): Awaited<ReturnType<T['all']>> {
     const { sql: sqlString, params } = query.toSQL();
     return db.executeSync(sqlString, params as any[]).rows as Awaited<
       ReturnType<T['all']>
@@ -135,6 +135,40 @@ type FireOn = Array<{ table: TableNames; ids?: number[] }>;
 export function useLiveQuery<T extends ExecutableSelect>(
   query: T,
   fireOn: FireOn,
+  callback?: (data: Awaited<ReturnType<T['all']>>) => void,
+) {
+  type ReturnValue = Awaited<ReturnType<T['all']>>;
+
+  const { sql: sqlString, params } = query.toSQL();
+  const paramsKey = JSON.stringify(params);
+  const fireOnKey = JSON.stringify(fireOn);
+
+  const [data, setData] = useState<ReturnValue>(() => {
+    const r = db.executeSync(sqlString, params as any[]).rows as ReturnValue;
+    if (callback) callback(r);
+    return r;
+  });
+
+  useEffect(() => {
+    const unsub = db.reactiveExecute({
+      query: sqlString,
+      arguments: params as any[],
+      fireOn,
+      callback: (result: { rows: ReturnValue }) => {
+        setData(result.rows);
+        if (callback) callback(result.rows);
+      },
+    });
+    return unsub;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sqlString, paramsKey, fireOnKey]);
+
+  return data;
+}
+export function useLiveQueryAsync<T extends ExecutableSelect>(
+  query: T,
+  fireOn: FireOn,
+  callback?: (data: Awaited<ReturnType<T['all']>>) => void,
 ) {
   type ReturnValue = Awaited<ReturnType<T['all']>>;
 
@@ -143,7 +177,11 @@ export function useLiveQuery<T extends ExecutableSelect>(
   const fireOnKey = JSON.stringify(fireOn);
 
   const [data, setData] = useState<ReturnValue>(
-    () => db.executeSync(sqlString, params as any[]).rows as ReturnValue,
+    () =>
+      db.execute(sqlString, params as any[]).then(result => {
+        callback?.(result.rows as ReturnValue);
+        return result.rows;
+      }) as ReturnValue,
   );
 
   useEffect(() => {
@@ -153,6 +191,7 @@ export function useLiveQuery<T extends ExecutableSelect>(
       fireOn,
       callback: (result: { rows: ReturnValue }) => {
         setData(result.rows);
+        if (callback) callback(result.rows);
       },
     });
     return unsub;

src/database/queries/ChapterQueries.ts

@@ -300,23 +300,61 @@ export const clearUpdates = async (): Promise<void> => {
 // #endregion
 // #region Selectors
 
-export const getCustomPages = async (novelId: number) => {
-  return await dbManager
-    .selectDistinct({ page: chapterSchema.page })
-    .from(chapterSchema)
-    .where(eq(chapterSchema.novelId, novelId))
-    .orderBy(asc(castInt(chapterSchema.page)))
-    .all();
+export const getCustomPages = (novelId: number) => {
+  return dbManager.allSync(
+    dbManager
+      .selectDistinct({ page: chapterSchema.page })
+      .from(chapterSchema)
+      .where(eq(chapterSchema.novelId, novelId))
+      .orderBy(asc(castInt(chapterSchema.page))),
+  );
 };
 
 export const getNovelChapters = async (
   novelId: number,
+  sort?: ChapterOrderKey,
+  filter?: ChapterFilterKey[],
+  page?: string,
+  limit: number = 1000,
 ): Promise<ChapterInfo[]> =>
   dbManager
     .select()
     .from(chapterSchema)
-    .where(eq(chapterSchema.novelId, novelId));
+    .where(
+      and(
+        eq(chapterSchema.novelId, novelId),
+        !page ? sql.raw('true') : eq(chapterSchema.page, page),
+        chapterFilterToSQL(filter),
+      ),
+    )
+    .orderBy(chapterOrderToSQL(sort))
+    .limit(limit)
+    .all();
 
+export const getNovelChaptersSync = (
+  novelId: number,
+  sort?: ChapterOrderKey,
+  filter?: ChapterFilterKey[],
+  page?: string,
+  limit: number = 1000,
+): ChapterInfo[] =>
+  dbManager.allSync(
+    dbManager
+      .select()
+      .from(chapterSchema)
+      .where(
+        and(
+          eq(chapterSchema.novelId, novelId),
+          !page ? sql.raw('true') : eq(chapterSchema.page, page),
+          chapterFilterToSQL(filter),
+        ),
+      )
+      .orderBy(chapterOrderToSQL(sort))
+      .limit(limit), // Adding a limit to prevent potential performance issues with large datasets
+  );
+/**
+ * @deprecated, use getNovelChapters with whereConditions instead
+ */
 export const getUnreadNovelChapters = async (
   novelId: number,
 ): Promise<ChapterInfo[]> =>
@@ -326,7 +364,9 @@ export const getUnreadNovelChapters = async (
     .where(
       and(eq(chapterSchema.novelId, novelId), eq(chapterSchema.unread, true)),
     );
-
+/**
+ * @deprecated, use getNovelChapters with whereConditions instead
+ */
 export const getAllUndownloadedChapters = async (
   novelId: number,
 ): Promise<ChapterInfo[]> =>
@@ -339,7 +379,9 @@ export const getAllUndownloadedChapters = async (
         eq(chapterSchema.isDownloaded, false),
       ),
     );
-
+/**
+ * @deprecated, use getNovelChapters with whereConditions instead
+ */
 export const getAllUndownloadedAndUnreadChapters = async (
   novelId: number,
 ): Promise<ChapterInfo[]> =>
@@ -408,8 +450,8 @@ export const getPageChaptersBatched = async (
   page?: string,
   batch: number = 0,
 ) => {
-  const limit = 300;
-  const offset = 300 * batch;
+  const limit = 1000;
+  const offset = 1000 * batch;
   const query = dbManager
     .select()
     .from(chapterSchema)
@@ -451,20 +493,21 @@ export const getFirstUnreadChapter = (
   filter?: ChapterFilterKey[],
   page?: string,
 ) =>
-  dbManager
-    .select()
-    .from(chapterSchema)
-    .where(
-      and(
-        eq(chapterSchema.novelId, novelId),
-        eq(chapterSchema.page, page || '1'),
-        eq(chapterSchema.unread, true),
-        chapterFilterToSQL(filter),
-      ),
-    )
-    .orderBy(asc(chapterSchema.position))
-    .limit(1)
-    .get();
+  dbManager.getSync(
+    dbManager
+      .select()
+      .from(chapterSchema)
+      .where(
+        and(
+          eq(chapterSchema.novelId, novelId),
+          eq(chapterSchema.page, page || '1'),
+          eq(chapterSchema.unread, true),
+          chapterFilterToSQL(filter),
+        ),
+      )
+      .orderBy(asc(chapterSchema.position))
+      .limit(1),
+  );
 
 export const getNovelChaptersByName = async (
   novelId: number,

src/database/queries/NovelQueries.ts

@@ -6,7 +6,7 @@ import { insertChapters } from './ChapterQueries';
 
 import { showToast } from '@utils/showToast';
 import { getString } from '@strings/translations';
-import { BackupNovel, NovelInfo } from '../types';
+import { BackupNovel, DBNovelInfo, NovelInfo } from '../types';
 import { SourceNovel } from '@plugins/types';
 import { NOVEL_STORAGE } from '@utils/Storages';
 import { downloadFile } from '@plugins/helpers/fetch';
@@ -82,21 +82,16 @@ export const getAllNovels = async (): Promise<NovelInfo[]> => {
   return dbManager.select().from(novelSchema).all();
 };
 
-export const getNovelById = async (
-  novelId: number,
-): Promise<NovelInfo | undefined> => {
-  const res = dbManager
-    .select()
-    .from(novelSchema)
-    .where(eq(novelSchema.id, novelId))
-    .get();
-  return res;
+export const getNovelById = (novelId: number): DBNovelInfo | undefined => {
+  return dbManager.getSync(
+    dbManager.select().from(novelSchema).where(eq(novelSchema.id, novelId)),
+  );
 };
 
 export const getNovelByPath = (
   novelPath: string,
   pluginId: string,
-): NovelInfo | undefined => {
+): DBNovelInfo | undefined => {
   const res = dbManager.getSync(
     dbManager
       .select()

src/database/utils/filter.ts

@@ -10,6 +10,12 @@ const FILTER_STATES = {
 } as const;
 export type FilterStates = typeof FILTER_STATES;
 
+export type FilterObject = {
+  unread?: boolean;
+  isDownloaded?: boolean;
+  bookmark?: boolean;
+};
+
 export class ChapterFilterObject {
   private filter: Map<
     ChapterFilterPositiveKey,
@@ -51,6 +57,26 @@ export class ChapterFilterObject {
     return res as ChapterFilterKey[];
   }
 
+  toFilterObject(): FilterObject {
+    const result: FilterObject = {};
+    for (const [key, value] of this.filter.entries()) {
+      if (value === FILTER_STATES.OFF) continue;
+
+      switch (key) {
+        case 'read':
+          result.unread = value !== FILTER_STATES.ON;
+          break;
+        case 'downloaded':
+          result.isDownloaded = value === FILTER_STATES.ON;
+          break;
+        case 'bookmarked':
+          result.bookmark = value === FILTER_STATES.ON;
+          break;
+      }
+    }
+    return result;
+  }
+
   set(key: ChapterFilterPositiveKey, value: keyof typeof FILTER_STATES) {
     this.filter.set(key, FILTER_STATES[value]);
     this.setState([...this.toArray()]);

src/database/utils/parser.ts

@@ -6,7 +6,8 @@ import {
 } from '@database/constants';
 import { SQL, sql } from 'drizzle-orm';
 
-export function chapterOrderToSQL(order: ChapterOrderKey) {
+export function chapterOrderToSQL(order?: ChapterOrderKey) {
+  if (!order) return sql.raw(CHAPTER_ORDER.positionAsc);
   const o = CHAPTER_ORDER[order] ?? CHAPTER_ORDER.positionAsc;
   return sql.raw(o);
 }