Use novel refactor

.github/workflows/build.yml

@@ -55,6 +55,12 @@ jobs:
       - name: Install Dependencies
         run: pnpm install --frozen-lockfile
 
+      - name: Run DB Tests
+        run: pnpm test:db
+
+      - name: Run RN Tests
+        run: pnpm test:rn
+
       - name: Create Environment File
         run: |
           cat > .env << EOF

.gitignore

@@ -93,3 +93,4 @@ flake.lock
 .agents/
 .claude/
 .jj/
+.sisyphus/

__mocks__/react-native-mmkv.js

@@ -1,9 +1,123 @@
 // Mock for react-native-mmkv (v3 uses NitroModules under the hood)
+const strings = new Map();
+const numbers = new Map();
+const booleans = new Map();
+const buffers = new Map();
+
+class MMKV {
+  set(key, value) {
+    if (typeof value === 'string') {
+      strings.set(key, value);
+      numbers.delete(key);
+      booleans.delete(key);
+      buffers.delete(key);
+      return;
+    }
+
+    if (typeof value === 'number') {
+      numbers.set(key, value);
+      strings.delete(key);
+      booleans.delete(key);
+      buffers.delete(key);
+      return;
+    }
+
+    if (typeof value === 'boolean') {
+      booleans.set(key, value);
+      strings.delete(key);
+      numbers.delete(key);
+      buffers.delete(key);
+      return;
+    }
+
+    buffers.set(key, value);
+    strings.delete(key);
+    numbers.delete(key);
+    booleans.delete(key);
+  }
+
+  getString(key) {
+    return strings.get(key);
+  }
+
+  getNumber(key) {
+    return numbers.get(key);
+  }
+
+  getBoolean(key) {
+    return booleans.get(key);
+  }
+
+  getBuffer(key) {
+    return buffers.get(key);
+  }
+
+  contains(key) {
+    return (
+      strings.has(key) ||
+      numbers.has(key) ||
+      booleans.has(key) ||
+      buffers.has(key)
+    );
+  }
+
+  delete(key) {
+    strings.delete(key);
+    numbers.delete(key);
+    booleans.delete(key);
+    buffers.delete(key);
+  }
+
+  clearAll() {
+    strings.clear();
+    numbers.clear();
+    booleans.clear();
+    buffers.clear();
+  }
+}
+
+const createTupleHook = getter => (key, fallback) =>
+  [
+    getter(key) ?? fallback,
+    jest.fn(value => {
+      if (value === undefined) {
+        strings.delete(key);
+        numbers.delete(key);
+        booleans.delete(key);
+        buffers.delete(key);
+        return;
+      }
+
+      if (typeof value === 'string') {
+        strings.set(key, value);
+      } else if (typeof value === 'number') {
+        numbers.set(key, value);
+      } else if (typeof value === 'boolean') {
+        booleans.set(key, value);
+      } else {
+        buffers.set(key, value);
+      }
+    }),
+  ];
+
 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(() => {
-      // Return a mock object that won't be used since MMKV has its own mock
-      return {};
-    }),
+    createHybridObject: jest.fn(() => ({})),
   },
 };

package.json

@@ -114,7 +114,8 @@
     "react-native-worklets": "^0.7.4",
     "react-native-zip-archive": "^7.0.2",
     "sanitize-html": "^2.17.1",
-    "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/NovelQueries.ts

@@ -82,15 +82,10 @@ 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): NovelInfo | undefined => {
+  return dbManager.getSync(
+    dbManager.select().from(novelSchema).where(eq(novelSchema.id, novelId)),
+  );
 };
 
 export const getNovelByPath = (

src/hooks/__tests__/mocks.ts

@@ -29,3 +29,99 @@ jest.mock('@hooks/persisted/useTrackedNovel');
 jest.mock('@hooks/persisted/useUpdates');
 jest.mock('@services/plugin/fetch');
 jest.mock('@components/Context/LibraryContext');
+
+const createMockChapterTextCache = () => {
+  const cache = new Map<number, string | Promise<string>>();
+
+  return {
+    read: jest.fn((chapterId: number) => cache.get(chapterId)),
+    write: jest.fn((chapterId: number, value: string | Promise<string>) => {
+      cache.set(chapterId, value);
+    }),
+    remove: jest.fn((chapterId: number) => cache.delete(chapterId)),
+    clear: jest.fn(() => cache.clear()),
+  };
+};
+
+export const createMockNovelStoreState = (
+  overrides: Record<string, unknown> = {},
+) => ({
+  loading: false,
+  fetching: false,
+  pageIndex: 0,
+  pages: ['1'],
+  novel: undefined,
+  chapters: [],
+  firstUnreadChapter: undefined,
+  batchInformation: {
+    batch: 0,
+    total: 0,
+  },
+  novelSettings: {
+    filter: [],
+    showChapterTitles: true,
+  },
+  chapterTextCache: createMockChapterTextCache(),
+  lastRead: undefined,
+
+  bootstrapNovel: jest.fn().mockResolvedValue(true),
+  getChapters: jest.fn().mockResolvedValue(undefined),
+  getNextChapterBatch: jest.fn().mockResolvedValue(undefined),
+  loadUpToBatch: jest.fn().mockResolvedValue(undefined),
+  refreshNovel: jest.fn().mockResolvedValue(undefined),
+
+  setNovel: jest.fn(),
+  setPages: jest.fn(),
+  setPageIndex: jest.fn(),
+  openPage: jest.fn().mockResolvedValue(undefined),
+  setNovelSettings: jest.fn(),
+  setLastRead: jest.fn(),
+  followNovel: jest.fn(),
+
+  updateChapter: jest.fn(),
+  setChapters: jest.fn(),
+  extendChapters: jest.fn(),
+
+  bookmarkChapters: jest.fn(),
+  markPreviouschaptersRead: jest.fn(),
+  markChapterRead: jest.fn(),
+  markChaptersRead: jest.fn(),
+  markPreviousChaptersUnread: jest.fn(),
+  markChaptersUnread: jest.fn(),
+  updateChapterProgress: jest.fn(),
+  deleteChapter: jest.fn(),
+  deleteChapters: jest.fn(),
+  refreshChapters: jest.fn(),
+  ...overrides,
+});
+
+export const createMockNovelStore = (
+  stateOverrides: Record<string, unknown> = {},
+) => {
+  let state = createMockNovelStoreState(stateOverrides);
+
+  return {
+    getState: jest.fn(() => state),
+    setState: jest.fn(nextState => {
+      const partial =
+        typeof nextState === 'function' ? nextState(state) : nextState;
+      state = {
+        ...state,
+        ...partial,
+      };
+    }),
+    subscribe: jest.fn(() => () => {}),
+  };
+};
+
+const defaultMockNovelContext = {
+  novelStore: createMockNovelStore(),
+  navigationBarHeight: 0,
+  statusBarHeight: 0,
+};
+
+export const mockUseNovelContext = jest.fn(() => defaultMockNovelContext);
+
+jest.mock('@screens/novel/NovelContext', () => ({
+  useNovelContext: () => mockUseNovelContext(),
+}));