@aiao/rxdb-react 0.0.9 → 0.0.11

package/dist/hooks.d.ts

@@ -69,6 +69,14 @@ export declare const useFindOneOrFail: <T extends EntityType>(EntityType: T, opt
  * ```
  */
 export declare const useFind: <T extends EntityType>(EntityType: T, options: UseOptions<EntityStaticType<T, "findOptions">>) => RxDBResource<InstanceType<T>[]>;
+/**
+ * Find entities using cursor-based pagination
+ *
+ * @param EntityType The entity class
+ * @param options Cursor pagination options (where, orderBy, limit, after, before)
+ * @returns A resource object containing an array of entities
+ */
+export declare const useFindByCursor: <T extends EntityType>(EntityType: T, options: UseOptions<EntityStaticType<T, "findByCursorOptions">>) => RxDBResource<InstanceType<T>[]>;
 /**
  * Find all entities
  *

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './hooks';
 export * from './rxdb-react';
+export * from './useInfiniteScroll';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,72 +1,135 @@
-import { isFunction as m } from "@aiao/utils";
-import { useState as i, useRef as h, useMemo as F, useEffect as A, createContext as B, useContext as E } from "react";
-import { jsx as O } from "react/jsx-runtime";
-const s = (r, e, o, c) => {
-  const [D, R] = i(o), [b, d] = i(void 0), [g, f] = i(!0), [p, l] = i(void 0), [y, v] = i(!1), t = h(void 0), u = h(!0), x = F(() => m(c) ? c() : c, [c]);
-  return A(() => {
-    u.current = !0, t.current && (t.current.unsubscribe(), t.current = void 0);
-    const a = r[e];
-    if (!a || typeof a != "function") {
-      const n = new Error(`Method "${String(e)}" not found on EntityType`);
+import { isFunction as H, cloneDeep as J } from "@aiao/utils";
+import { useState as a, useRef as f, useMemo as P, useEffect as N, createContext as Q, useContext as U, useCallback as m } from "react";
+import { jsx as W } from "react/jsx-runtime";
+const s = (r, e, c, g) => {
+  const [D, p] = a(c), [y, l] = a(void 0), [B, d] = a(!0), [u, C] = a(void 0), [I, b] = a(!1), o = f(void 0), i = f(!0), M = P(() => H(g) ? g() : g, [g]);
+  return N(() => {
+    i.current = !0, o.current && (o.current.unsubscribe(), o.current = void 0);
+    const h = r[e];
+    if (!h || typeof h != "function") {
+      const t = new Error(`Method "${String(e)}" not found on EntityType`);
       Promise.resolve().then(() => {
-        u.current && (d(n), f(!1));
+        i.current && (l(t), d(!1));
       });
       return;
     }
     try {
-      t.current = a(x).subscribe({
-        next: (n) => {
-          u.current && (f(!1), v(!0), d(void 0), Array.isArray(n) ? l(n.length === 0) : l(n == null), R(n));
+      o.current = h(M).subscribe({
+        next: (t) => {
+          i.current && (d(!1), b(!0), l(void 0), Array.isArray(t) ? C(t.length === 0) : C(t == null), p(t));
         },
-        error: (n) => {
-          u.current && (f(!1), v(!1), d(n), console.error(`RxDB query error in ${String(e)}:`, n));
+        error: (t) => {
+          i.current && (d(!1), b(!1), l(t), console.error(`RxDB query error in ${String(e)}:`, t));
         }
       });
-    } catch (n) {
-      const P = n instanceof Error ? n : new Error(String(n));
+    } catch (t) {
+      const x = t instanceof Error ? t : new Error(String(t));
       Promise.resolve().then(() => {
-        u.current && (f(!1), d(P));
+        i.current && (d(!1), l(x));
       });
     }
     return () => {
-      u.current = !1, t.current && (t.current.unsubscribe(), t.current = void 0);
+      i.current = !1, o.current && (o.current.unsubscribe(), o.current = void 0);
     };
-  }, [r, e, x]), {
+  }, [r, e, M]), {
     value: D,
-    error: b,
-    isLoading: g,
-    isEmpty: p,
-    hasValue: y
+    error: y,
+    isLoading: B,
+    isEmpty: u,
+    hasValue: I
   };
-}, S = (r, e) => s(r, "get", void 0, e), G = (r, e) => s(r, "findOne", void 0, e), V = (r, e) => s(r, "findOneOrFail", void 0, e), q = (r, e) => s(r, "find", [], e), I = (r, e) => s(r, "findAll", [], e), L = (r, e) => s(r, "count", 0, e), $ = (r, e) => s(r, "findDescendants", [], e), j = (r, e) => s(r, "countDescendants", 0, e), k = (r, e) => s(r, "findAncestors", [], e), H = (r, e) => s(r, "countAncestors", 0, e), Q = (r, e) => s(r, "findNeighbors", [], e), z = (r, e) => s(r, "countNeighbors", 0, e), J = (r, e) => s(r, "findPaths", [], e);
-function C() {
-  const r = B(void 0);
+}, re = (r, e) => s(r, "get", void 0, e), te = (r, e) => s(r, "findOne", void 0, e), ne = (r, e) => s(r, "findOneOrFail", void 0, e), se = (r, e) => s(r, "find", [], e), oe = (r, e) => s(r, "findByCursor", [], e), ce = (r, e) => s(r, "findAll", [], e), ue = (r, e) => s(r, "count", 0, e), ie = (r, e) => s(r, "findDescendants", [], e), fe = (r, e) => s(r, "countDescendants", 0, e), ae = (r, e) => s(r, "findAncestors", [], e), le = (r, e) => s(r, "countAncestors", 0, e), de = (r, e) => s(r, "findNeighbors", [], e), ge = (r, e) => s(r, "countNeighbors", 0, e), he = (r, e) => s(r, "findPaths", [], e);
+function X() {
+  const r = Q(void 0);
   return {
     useRxDB: ((e) => {
-      const o = E(r);
+      const c = U(r);
       if (e !== void 0) return e;
-      if (!o) throw new Error("No RxDB instance found, use RxDBProvider to provide one");
-      return o;
+      if (!c) throw new Error("No RxDB instance found, use RxDBProvider to provide one");
+      return c;
     }),
-    RxDBProvider: ({ children: e, db: o }) => /* @__PURE__ */ O(r.Provider, { value: o, children: e })
+    RxDBProvider: ({ children: e, db: c }) => /* @__PURE__ */ W(r.Provider, { value: c, children: e })
+  };
+}
+const { RxDBProvider: ve, useRxDB: Y } = X();
+function pe(r, e) {
+  const c = Y(), [g, D] = a([]), p = f([]), y = m(
+    (n) => {
+      const F = typeof n == "function" ? n(p.current) : n;
+      p.current = F, D(F);
+    },
+    []
+  ), [l, B] = a(!1), d = f(!1), u = m((n) => {
+    d.current = n, B(n);
+  }, []), [C, I] = a(!0), b = f(!0), o = m((n) => {
+    b.current = n, I(n);
+  }, []), [i, M] = a(!1), h = f(!1), t = f(!1), x = f([]), O = P(() => H(e) ? e() : e, [e]), E = P(() => JSON.stringify(O), [O]), A = P(() => g.flat(), [g]), V = P(
+    () => A.length === 0 && !l && i,
+    [A.length, l, i]
+  ), R = m(() => {
+    x.current.forEach((n) => n.unsubscribe()), x.current = [];
+  }, []), v = m(() => {
+    if (d.current || !b.current || !t.current) return;
+    u(!0);
+    const n = p.current, F = n.length, S = n.length > 0 ? n[n.length - 1] : void 0, q = S && S.length > 0 ? S[S.length - 1] : void 0, L = J(O);
+    q && (L.after = q);
+    const K = c.entityManager.getRepository(r).findByCursor(L).subscribe({
+      next: (z) => {
+        if (!t.current) return;
+        y((j) => {
+          const G = [...j];
+          return G[F] = z, G;
+        });
+        const $ = L.limit || 100;
+        z.length < $ && o(!1), u(!1);
+      },
+      error: () => {
+        t.current && u(!1);
+      },
+      complete: () => {
+        t.current && u(!1);
+      }
+    });
+    x.current.push(K);
+  }, [r, O, c, o, u, y]), k = m(() => {
+    if (!t.current) {
+      console.warn("Cannot refresh: component is unmounted");
+      return;
+    }
+    R(), y([]), u(!1), o(!0), v();
+  }, [R, v, o, u, y]);
+  N(() => (t.current = !0, h.current || (h.current = !0, M(!0), v()), () => {
+    t.current = !1, R();
+  }), [R, v]);
+  const w = f(E);
+  return N(() => {
+    h.current && w.current !== E && (w.current = E, R(), p.current = [], d.current = !1, b.current = !0, D([]), B(!1), I(!0), v());
+  }, [E, R, v]), {
+    value: A,
+    isEmpty: V,
+    isLoading: l,
+    hasMore: C,
+    loadMore: v,
+    refresh: k
   };
 }
-const { RxDBProvider: K, useRxDB: T } = C();
 export {
-  K as RxDBProvider,
-  C as makeRxDBProvider,
-  L as useCount,
-  H as useCountAncestors,
-  j as useCountDescendants,
-  z as useCountNeighbors,
-  q as useFind,
-  I as useFindAll,
-  k as useFindAncestors,
-  $ as useFindDescendants,
-  G as useFindOne,
-  V as useFindOneOrFail,
-  S as useGet,
-  Q as useGraphNeighbors,
-  J as useGraphPaths,
-  T as useRxDB
+  ve as RxDBProvider,
+  X as makeRxDBProvider,
+  ue as useCount,
+  le as useCountAncestors,
+  fe as useCountDescendants,
+  ge as useCountNeighbors,
+  se as useFind,
+  ce as useFindAll,
+  ae as useFindAncestors,
+  oe as useFindByCursor,
+  ie as useFindDescendants,
+  te as useFindOne,
+  ne as useFindOneOrFail,
+  re as useGet,
+  de as useGraphNeighbors,
+  he as useGraphPaths,
+  pe as useInfiniteScroll,
+  Y as useRxDB
 };

package/dist/useInfiniteScroll.d.ts

@@ -0,0 +1,29 @@
+import { EntityStaticType, EntityType } from '../../rxdb/src/index.ts';
+type UseOptions<T> = T | (() => T);
+export interface InfiniteScrollResource<T> {
+    value: T[];
+    isEmpty: boolean;
+    isLoading: boolean;
+    hasMore: boolean;
+    loadMore: () => void;
+    refresh: () => void;
+}
+/**
+ * Infinite scroll hook for cursor-based pagination
+ *
+ * @param EntityType The entity class
+ * @param options Query options with cursor pagination
+ * @returns A resource object with infinite scroll controls
+ *
+ * @example
+ * ```typescript
+ * const resource = useInfiniteScroll(Todo, {
+ *   where: { completed: false },
+ *   orderBy: [{ field: 'createdAt', sort: 'desc' }],
+ *   limit: 50
+ * });
+ * ```
+ */
+export declare function useInfiniteScroll<T extends EntityType>(EntityType: T, options: UseOptions<EntityStaticType<T, 'findByCursorOptions'>>): InfiniteScrollResource<InstanceType<T>>;
+export {};
+//# sourceMappingURL=useInfiniteScroll.d.ts.map

package/dist/useInfiniteScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteScroll.d.ts","sourceRoot":"","sources":["../src/useInfiniteScroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAK1D,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAEnC,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,UAAU,EACpD,UAAU,EAAE,CAAC,EACb,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,GAC9D,sBAAsB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAyJzC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiao/rxdb-react",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -15,8 +15,12 @@
     }
   },
   "dependencies": {
-    "@aiao/rxdb": "0.0.9",
-    "@aiao/utils": "0.0.9"
+    "@aiao/rxdb": "0.0.11",
+    "@aiao/utils": "0.0.11"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "rxjs": "^7.8.0"
   },
   "nx": {
     "name": "rxdb-react",

package/src/hooks.spec.ts

@@ -1,6 +1,21 @@
-import { of } from 'rxjs';
+import { of, Subject, throwError } from 'rxjs';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { useFind, useFindOne, useGet } from './hooks';
+import {
+  useCount,
+  useCountAncestors,
+  useCountDescendants,
+  useCountNeighbors,
+  useFind,
+  useFindAll,
+  useFindAncestors,
+  useFindByCursor,
+  useFindDescendants,
+  useFindOne,
+  useFindOneOrFail,
+  useGet,
+  useGraphNeighbors,
+  useGraphPaths
+} from './hooks';
 
 // Mock React hooks
 let mockState: any[] = [];
@@ -32,7 +47,18 @@ class MockEntity {
   name!: string;
   static get = vi.fn();
   static findOne = vi.fn();
+  static findOneOrFail = vi.fn();
   static find = vi.fn();
+  static findAll = vi.fn();
+  static count = vi.fn();
+  static findDescendants = vi.fn();
+  static countDescendants = vi.fn();
+  static findAncestors = vi.fn();
+  static countAncestors = vi.fn();
+  static findNeighbors = vi.fn();
+  static countNeighbors = vi.fn();
+  static findByCursor = vi.fn();
+  static findPaths = vi.fn();
 }
 
 describe('useGet', () => {
@@ -109,6 +135,30 @@ describe('useFind', () => {
   });
 });
 
+describe('useFindByCursor', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('should call findByCursor method', () => {
+    const mockData = [
+      { id: '1', name: 'User1' },
+      { id: '2', name: 'User2' }
+    ];
+    MockEntity.findByCursor.mockReturnValue(of(mockData));
+
+    useFindByCursor(MockEntity as any, {
+      where: {},
+      orderBy: [{ field: 'id', sort: 'ASC' }]
+    });
+
+    expect(MockEntity.findByCursor).toHaveBeenCalled();
+  });
+});
+
 describe('Hook cleanup', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -124,4 +174,254 @@ describe('Hook cleanup', () => {
 
     expect(mockEffectCleanups.length).toBeGreaterThan(0);
   });
+
+  it('should unsubscribe on cleanup', () => {
+    const mockUnsubscribe = vi.fn();
+    const mockSubscription = { unsubscribe: mockUnsubscribe };
+    const subject = new Subject();
+    MockEntity.get.mockReturnValue(subject.asObservable());
+    (subject.subscribe as any) = vi.fn(() => mockSubscription);
+
+    MockEntity.get.mockReturnValue({
+      subscribe: vi.fn(() => mockSubscription)
+    });
+
+    useGet(MockEntity as any, '1');
+
+    // Execute cleanup
+    mockEffectCleanups.forEach(cleanup => cleanup());
+
+    expect(mockUnsubscribe).toHaveBeenCalled();
+  });
+
+  it('should clean up previous subscription on re-render', () => {
+    const mockUnsubscribe = vi.fn();
+    const mockSubscription = { unsubscribe: mockUnsubscribe };
+
+    MockEntity.get.mockReturnValue({
+      subscribe: vi.fn(() => mockSubscription)
+    });
+
+    // First render
+    useGet(MockEntity as any, '1');
+
+    // Simulate re-render by calling effect again (the effect will clean up previous subscription)
+    mockState = [];
+    mockStateIndex = 0;
+
+    // Second render - this should trigger cleanup of previous subscription
+    useGet(MockEntity as any, '2');
+
+    // The cleanup from first render should have been called
+    expect(mockEffectCleanups.length).toBeGreaterThan(0);
+  });
+});
+
+describe('Error handling', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('should handle method not found error', async () => {
+    // Use a mock entity without the method
+    const NoMethodEntity = {} as any;
+
+    const result = useGet(NoMethodEntity, '1');
+
+    // Wait for Promise.resolve to complete
+    await new Promise(resolve => setTimeout(resolve, 0));
+
+    expect(result).toBeDefined();
+  });
+
+  it('should handle subscription error', () => {
+    const testError = new Error('Test error');
+    MockEntity.get.mockReturnValue(throwError(() => testError));
+
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
+    const result = useGet(MockEntity as any, '1');
+
+    expect(result).toBeDefined();
+    consoleSpy.mockRestore();
+  });
+
+  it('should handle exception during query execution', () => {
+    MockEntity.get.mockImplementation(() => {
+      throw new Error('Sync error');
+    });
+
+    const result = useGet(MockEntity as any, '1');
+
+    expect(result).toBeDefined();
+  });
+});
+
+describe('isEmpty behavior', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('should set isEmpty true for empty array', () => {
+    MockEntity.find.mockReturnValue(of([]));
+
+    const result = useFind(MockEntity as any, {});
+
+    expect(result).toBeDefined();
+  });
+
+  it('should set isEmpty false for non-empty array', () => {
+    MockEntity.find.mockReturnValue(of([{ id: '1' }]));
+
+    const result = useFind(MockEntity as any, {});
+
+    expect(result).toBeDefined();
+  });
+
+  it('should set isEmpty true for null value', () => {
+    MockEntity.findOne.mockReturnValue(of(null));
+
+    const result = useFindOne(MockEntity as any, {});
+
+    expect(result).toBeDefined();
+  });
+
+  it('should set isEmpty false for non-null value', () => {
+    MockEntity.findOne.mockReturnValue(of({ id: '1' }));
+
+    const result = useFindOne(MockEntity as any, {});
+
+    expect(result).toBeDefined();
+  });
+});
+
+describe('useFindOneOrFail', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('should call findOneOrFail method', () => {
+    MockEntity.findOneOrFail.mockReturnValue(of({ id: '1', name: 'Found' }));
+
+    useFindOneOrFail(MockEntity as any, { where: { id: '1' } });
+
+    expect(MockEntity.findOneOrFail).toHaveBeenCalledWith({ where: { id: '1' } });
+  });
+});
+
+describe('useFindAll', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('should call findAll method', () => {
+    MockEntity.findAll.mockReturnValue(of([{ id: '1' }, { id: '2' }]));
+
+    useFindAll(MockEntity as any, {});
+
+    expect(MockEntity.findAll).toHaveBeenCalled();
+  });
+});
+
+describe('useCount', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('should call count method', () => {
+    MockEntity.count.mockReturnValue(of(5));
+
+    useCount(MockEntity as any, {});
+
+    expect(MockEntity.count).toHaveBeenCalled();
+  });
+});
+
+describe('Tree Repository Hooks', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('useFindDescendants should call findDescendants', () => {
+    MockEntity.findDescendants.mockReturnValue(of([{ id: '2' }]));
+
+    useFindDescendants(MockEntity as any, { entityId: '1' });
+
+    expect(MockEntity.findDescendants).toHaveBeenCalledWith({ entityId: '1' });
+  });
+
+  it('useCountDescendants should call countDescendants', () => {
+    MockEntity.countDescendants.mockReturnValue(of(3));
+
+    useCountDescendants(MockEntity as any, { entityId: '1' });
+
+    expect(MockEntity.countDescendants).toHaveBeenCalledWith({ entityId: '1' });
+  });
+
+  it('useFindAncestors should call findAncestors', () => {
+    MockEntity.findAncestors.mockReturnValue(of([{ id: '0' }]));
+
+    useFindAncestors(MockEntity as any, { entityId: '1' });
+
+    expect(MockEntity.findAncestors).toHaveBeenCalledWith({ entityId: '1' });
+  });
+
+  it('useCountAncestors should call countAncestors', () => {
+    MockEntity.countAncestors.mockReturnValue(of(2));
+
+    useCountAncestors(MockEntity as any, { entityId: '1' });
+
+    expect(MockEntity.countAncestors).toHaveBeenCalledWith({ entityId: '1' });
+  });
+});
+
+describe('Graph Repository Hooks', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+  });
+
+  it('useGraphNeighbors should call findNeighbors', () => {
+    MockEntity.findNeighbors.mockReturnValue(of([{ id: '2' }]));
+
+    useGraphNeighbors(MockEntity as any, { entityId: '1', direction: 'out', level: 1 });
+
+    expect(MockEntity.findNeighbors).toHaveBeenCalledWith({ entityId: '1', direction: 'out', level: 1 });
+  });
+
+  it('useCountNeighbors should call countNeighbors', () => {
+    MockEntity.countNeighbors.mockReturnValue(of(5));
+
+    useCountNeighbors(MockEntity as any, { entityId: '1', direction: 'out', level: 1 });
+
+    expect(MockEntity.countNeighbors).toHaveBeenCalledWith({ entityId: '1', direction: 'out', level: 1 });
+  });
+
+  it('useGraphPaths should call findPaths', () => {
+    MockEntity.findPaths.mockReturnValue(of([['1', '2', '3']]));
+
+    useGraphPaths(MockEntity as any, { fromId: '1', toId: '3', maxDepth: 5 });
+
+    expect(MockEntity.findPaths).toHaveBeenCalledWith({ fromId: '1', toId: '3', maxDepth: 5 });
+  });
 });

package/src/hooks.ts

@@ -205,6 +205,18 @@ export const useFind = <T extends EntityType>(
   options: UseOptions<EntityStaticType<T, 'findOptions'>>
 ): RxDBResource<InstanceType<T>[]> => useRepositoryQuery<T, InstanceType<T>[]>(EntityType, 'find', [], options);
 
+/**
+ * Find entities using cursor-based pagination
+ *
+ * @param EntityType The entity class
+ * @param options Cursor pagination options (where, orderBy, limit, after, before)
+ * @returns A resource object containing an array of entities
+ */
+export const useFindByCursor = <T extends EntityType>(
+  EntityType: T,
+  options: UseOptions<EntityStaticType<T, 'findByCursorOptions'>>
+): RxDBResource<InstanceType<T>[]> => useRepositoryQuery<T, InstanceType<T>[]>(EntityType, 'findByCursor', [], options);
+
 /**
  * Find all entities
  *

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './hooks';
 export * from './rxdb-react';
+export * from './useInfiniteScroll';

package/src/rxdb-react.spec.tsx

@@ -1,7 +1,18 @@
 import React from 'react';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { makeRxDBProvider, RxDBProvider, useRxDB } from './rxdb-react';
 
+// Mock React hooks for testing useRxDB behavior
+let mockContextValue: any = undefined;
+vi.mock('react', async () => {
+  const actual = await vi.importActual<typeof React>('react');
+  return {
+    ...actual,
+    useContext: () => mockContextValue,
+    createContext: actual.createContext
+  };
+});
+
 describe('makeRxDBProvider', () => {
   it('should create RxDBProvider and useRxDB hook', () => {
     const { RxDBProvider, useRxDB } = makeRxDBProvider();
@@ -39,3 +50,32 @@ describe('Default exports', () => {
     expect(typeof makeRxDBProvider).toBe('function');
   });
 });
+
+describe('useRxDB behavior', () => {
+  it('should return provided db parameter if given', () => {
+    const { useRxDB } = makeRxDBProvider();
+    const directDB = { name: 'direct-db' } as any;
+    mockContextValue = { name: 'context-db' };
+
+    const result = useRxDB(directDB);
+
+    expect(result).toBe(directDB);
+  });
+
+  it('should return context db when no parameter given', () => {
+    const { useRxDB } = makeRxDBProvider();
+    const contextDB = { name: 'context-db' };
+    mockContextValue = contextDB;
+
+    const result = useRxDB();
+
+    expect(result).toBe(contextDB);
+  });
+
+  it('should throw error when no db in context and no parameter', () => {
+    const { useRxDB } = makeRxDBProvider();
+    mockContextValue = undefined;
+
+    expect(() => useRxDB()).toThrow('No RxDB instance found, use RxDBProvider to provide one');
+  });
+});

package/src/useInfiniteScroll.spec.ts

@@ -0,0 +1,159 @@
+import { of, throwError } from 'rxjs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Import after mocks are set up
+import { useInfiniteScroll } from './useInfiniteScroll';
+
+// Mock findByCursor + repository
+const mockFindByCursor = vi.fn();
+const mockGetRepository = vi.fn(() => ({ findByCursor: mockFindByCursor }));
+
+// Mock useRxDB before importing useInfiniteScroll
+vi.mock('./rxdb-react', () => ({
+  useRxDB: () => ({ entityManager: { getRepository: mockGetRepository } })
+}));
+
+// Mock React hooks
+let mockState: any[] = [];
+let mockStateIndex = 0;
+let mockEffectCleanups: Array<() => void> = [];
+
+vi.mock('react', () => ({
+  useState: (initial: any) => {
+    const index = mockStateIndex++;
+    if (mockState[index] === undefined) {
+      mockState[index] = typeof initial === 'function' ? initial() : initial;
+    }
+    const setState = (newValue: any) => {
+      mockState[index] = typeof newValue === 'function' ? newValue(mockState[index]) : newValue;
+    };
+    return [mockState[index], setState];
+  },
+  useEffect: (effect: () => any) => {
+    const cleanup = effect();
+    if (cleanup) mockEffectCleanups.push(cleanup);
+  },
+  useRef: (initial: any) => ({ current: initial }),
+  useMemo: (fn: () => any) => fn(),
+  useCallback: (fn: any) => fn
+}));
+
+class MockEntity {
+  id!: string;
+  name!: string;
+}
+
+const defaultOptions = {
+  where: {},
+  orderBy: [{ field: 'id', sort: 'ASC' }],
+  limit: 10
+};
+
+describe('useInfiniteScroll (React)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState = [];
+    mockStateIndex = 0;
+    mockEffectCleanups = [];
+    mockGetRepository.mockReturnValue({ findByCursor: mockFindByCursor });
+  });
+
+  afterEach(() => {
+    mockEffectCleanups.forEach(cleanup => cleanup());
+    mockEffectCleanups = [];
+  });
+
+  it('should export useInfiniteScroll function', () => {
+    expect(useInfiniteScroll).toBeDefined();
+    expect(typeof useInfiniteScroll).toBe('function');
+  });
+
+  it('should return InfiniteScrollResource structure', () => {
+    mockFindByCursor.mockReturnValue(of([]));
+
+    const resource = useInfiniteScroll(MockEntity as any, defaultOptions);
+
+    expect(resource.value).toBeDefined();
+    expect(typeof resource.isEmpty).toBe('boolean');
+    expect(typeof resource.isLoading).toBe('boolean');
+    expect(typeof resource.hasMore).toBe('boolean');
+    expect(typeof resource.loadMore).toBe('function');
+    expect(typeof resource.refresh).toBe('function');
+  });
+
+  it('should call findByCursor on initial load', () => {
+    mockFindByCursor.mockReturnValue(of([{ id: '1', name: 'a' }]));
+
+    useInfiniteScroll(MockEntity as any, defaultOptions);
+
+    expect(mockGetRepository).toHaveBeenCalledWith(MockEntity);
+    expect(mockFindByCursor).toHaveBeenCalled();
+  });
+
+  it('should return value from subscription', () => {
+    const items = [
+      { id: '1', name: 'a' },
+      { id: '2', name: 'b' }
+    ];
+    mockFindByCursor.mockReturnValue(of(items));
+
+    const resource = useInfiniteScroll(MockEntity as any, { ...defaultOptions, limit: 10 });
+
+    expect(resource).toBeDefined();
+    expect(mockFindByCursor).toHaveBeenCalledTimes(1);
+  });
+
+  it('should support function options', () => {
+    mockFindByCursor.mockReturnValue(of([]));
+
+    const resource = useInfiniteScroll(MockEntity as any, () => ({
+      where: { status: 'active' },
+      orderBy: [{ field: 'id', sort: 'ASC' }],
+      limit: 20
+    }));
+
+    expect(resource).toBeDefined();
+    expect(mockFindByCursor).toHaveBeenCalled();
+  });
+
+  it('should clean up subscriptions on unmount', () => {
+    const unsubscribeSpy = vi.fn();
+    mockFindByCursor.mockReturnValue({
+      subscribe: (observer: any) => {
+        observer.next([]);
+        return { unsubscribe: unsubscribeSpy };
+      }
+    });
+
+    useInfiniteScroll(MockEntity as any, defaultOptions);
+
+    mockEffectCleanups.forEach(cleanup => cleanup());
+    mockEffectCleanups = [];
+
+    expect(unsubscribeSpy).toHaveBeenCalled();
+  });
+
+  it('should handle subscription errors gracefully', () => {
+    mockFindByCursor.mockReturnValue(throwError(() => new Error('fail')));
+
+    expect(() => {
+      useInfiniteScroll(MockEntity as any, defaultOptions);
+    }).not.toThrow();
+  });
+
+  it('should expose refresh function', () => {
+    mockFindByCursor.mockReturnValue(of([]));
+
+    const resource = useInfiniteScroll(MockEntity as any, defaultOptions);
+
+    expect(typeof resource.refresh).toBe('function');
+  });
+
+  it('should expose loadMore function', () => {
+    mockFindByCursor.mockReturnValue(of([]));
+
+    const resource = useInfiniteScroll(MockEntity as any, defaultOptions);
+
+    expect(typeof resource.loadMore).toBe('function');
+  });
+});

package/src/useInfiniteScroll.ts

@@ -0,0 +1,189 @@
+import { EntityStaticType, EntityType } from '@aiao/rxdb';
+import { cloneDeep, isFunction } from '@aiao/utils';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useRxDB } from './rxdb-react';
+
+type UseOptions<T> = T | (() => T);
+
+export interface InfiniteScrollResource<T> {
+  value: T[];
+  isEmpty: boolean;
+  isLoading: boolean;
+  hasMore: boolean;
+  loadMore: () => void;
+  refresh: () => void;
+}
+
+/**
+ * Infinite scroll hook for cursor-based pagination
+ *
+ * @param EntityType The entity class
+ * @param options Query options with cursor pagination
+ * @returns A resource object with infinite scroll controls
+ *
+ * @example
+ * ```typescript
+ * const resource = useInfiniteScroll(Todo, {
+ *   where: { completed: false },
+ *   orderBy: [{ field: 'createdAt', sort: 'desc' }],
+ *   limit: 50
+ * });
+ * ```
+ */
+export function useInfiniteScroll<T extends EntityType>(
+  EntityType: T,
+  options: UseOptions<EntityStaticType<T, 'findByCursorOptions'>>
+): InfiniteScrollResource<InstanceType<T>> {
+  const rxdb = useRxDB();
+
+  const [pages, setPages] = useState<InstanceType<T>[][]>([]);
+  const pagesRef = useRef<InstanceType<T>[][]>([]);
+  const setPagesState = useCallback(
+    (next: InstanceType<T>[][] | ((prev: InstanceType<T>[][]) => InstanceType<T>[][])) => {
+      const resolved =
+        typeof next === 'function' ?
+          (next as (prev: InstanceType<T>[][]) => InstanceType<T>[][])(pagesRef.current)
+        : next;
+      pagesRef.current = resolved;
+      setPages(resolved);
+    },
+    []
+  );
+  const [isLoading, setIsLoading] = useState(false);
+  const isLoadingRef = useRef(false);
+  const setIsLoadingState = useCallback((value: boolean) => {
+    isLoadingRef.current = value;
+    setIsLoading(value);
+  }, []);
+  const [hasMore, setHasMore] = useState(true);
+  const hasMoreRef = useRef(true);
+  const setHasMoreState = useCallback((value: boolean) => {
+    hasMoreRef.current = value;
+    setHasMore(value);
+  }, []);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const isInitializedRef = useRef(false);
+  const isMounted = useRef(false);
+  const subscriptions = useRef<{ unsubscribe: () => void }[]>([]);
+
+  const resolvedOptions = useMemo(() => {
+    return isFunction(options) ? options() : options;
+  }, [options]);
+
+  const optionsKey = useMemo(() => JSON.stringify(resolvedOptions), [resolvedOptions]);
+
+  const allItems = useMemo(() => pages.flat(), [pages]);
+  const isEmpty = useMemo(
+    () => allItems.length === 0 && !isLoading && isInitialized,
+    [allItems.length, isLoading, isInitialized]
+  );
+
+  const clearSubscriptions = useCallback(() => {
+    subscriptions.current.forEach(sub => sub.unsubscribe());
+    subscriptions.current = [];
+  }, []);
+
+  const loadMore = useCallback(() => {
+    if (isLoadingRef.current || !hasMoreRef.current || !isMounted.current) return;
+
+    setIsLoadingState(true);
+
+    const currentPages = pagesRef.current;
+    const currentIndex = currentPages.length;
+    const lastPage = currentPages.length > 0 ? currentPages[currentPages.length - 1] : undefined;
+    const lastEntity = lastPage && lastPage.length > 0 ? lastPage[lastPage.length - 1] : undefined;
+
+    const queryOptions = cloneDeep(resolvedOptions);
+    if (lastEntity) {
+      queryOptions.after = lastEntity;
+    }
+
+    const repository = rxdb.entityManager.getRepository(EntityType);
+
+    const subscription = repository.findByCursor(queryOptions).subscribe({
+      next: (result: InstanceType<T>[]) => {
+        if (!isMounted.current) return;
+
+        setPagesState(prev => {
+          const updated = [...prev];
+          updated[currentIndex] = result;
+          return updated;
+        });
+
+        const limit = queryOptions.limit || 100;
+        if (result.length < limit) {
+          setHasMoreState(false);
+        }
+
+        setIsLoadingState(false);
+      },
+      error: () => {
+        if (!isMounted.current) return;
+        setIsLoadingState(false);
+      },
+      complete: () => {
+        if (!isMounted.current) return;
+        setIsLoadingState(false);
+      }
+    });
+
+    subscriptions.current.push(subscription);
+  }, [EntityType, resolvedOptions, rxdb, setHasMoreState, setIsLoadingState, setPagesState]);
+
+  const refresh = useCallback(() => {
+    if (!isMounted.current) {
+      console.warn('Cannot refresh: component is unmounted');
+      return;
+    }
+    clearSubscriptions();
+    setPagesState([]);
+    setIsLoadingState(false);
+    setHasMoreState(true);
+    loadMore();
+  }, [clearSubscriptions, loadMore, setHasMoreState, setIsLoadingState, setPagesState]);
+
+  // Initial load
+  useEffect(() => {
+    isMounted.current = true;
+    if (!isInitializedRef.current) {
+      isInitializedRef.current = true;
+      // eslint-disable-next-line react-hooks/set-state-in-effect -- 初始化标记仅在首次 mount 时设置一次
+      setIsInitialized(true);
+
+      loadMore();
+    }
+
+    return () => {
+      isMounted.current = false;
+      clearSubscriptions();
+    };
+  }, [clearSubscriptions, loadMore]);
+
+  // Reload on options change
+  const prevOptionsKey = useRef(optionsKey);
+  useEffect(() => {
+    if (!isInitializedRef.current) return;
+
+    if (prevOptionsKey.current !== optionsKey) {
+      prevOptionsKey.current = optionsKey;
+      clearSubscriptions();
+      pagesRef.current = [];
+      isLoadingRef.current = false;
+      hasMoreRef.current = true;
+      // eslint-disable-next-line react-hooks/set-state-in-effect
+      setPages([]);
+      setIsLoading(false);
+      setHasMore(true);
+      loadMore();
+    }
+  }, [optionsKey, clearSubscriptions, loadMore]);
+
+  return {
+    value: allItems,
+    isEmpty,
+    isLoading,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}

package/vite.config.mts

@@ -72,9 +72,11 @@ export default defineConfig({
     coverage: {
       enabled: true,
       reportsDirectory: '../../coverage/packages/rxdb-react',
-      provider: 'v8',
+      provider: 'v8' as const,
+      reporter: ['text', 'json', 'clover', 'lcovonly'],
       include: ['src/**/*'],
-      exclude: ['**/index.ts', '**/dist/**']
+      exclude: ['**/index.ts', '**/dist/**'],
+      all: false
     }
   }
 });