@aiao/rxdb-react 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiao/rxdb-react",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -15,8 +15,8 @@
     }
   },
   "dependencies": {
-    "@aiao/rxdb": "0.0.8",
-    "@aiao/utils": "0.0.8"
+    "@aiao/rxdb": "0.0.10",
+    "@aiao/utils": "0.0.10"
   },
   "nx": {
     "name": "rxdb-react",

package/src/hooks.spec.ts

@@ -1,6 +1,20 @@
-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,
+  useFindDescendants,
+  useFindOne,
+  useFindOneOrFail,
+  useGet,
+  useGraphNeighbors,
+  useGraphPaths
+} from './hooks';
 
 // Mock React hooks
 let mockState: any[] = [];
@@ -32,7 +46,17 @@ 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 findPaths = vi.fn();
 }
 
 describe('useGet', () => {
@@ -124,4 +148,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/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/vite.config.mts

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