muya 2.3.1 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muya",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "author": "samuel.gjabel@gmail.com",
   "repository": "https://github.com/samuelgjabel/muya",
   "main": "cjs/index.js",

package/src/sqlite/__tests__/use-sqlite.test.tsx

@@ -79,11 +79,11 @@ describe('use-sqlite-state', () => {
     const { result } = renderHook(() => {
       reRenders++
       const [minAge, setMinAge] = useState(20)
-      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sorBy: 'age' }, [minAge]), setMinAge] as const
+      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sortBy: 'age' }, [minAge]), setMinAge] as const
     })
 
     await waitFor(() => {
-      expect(result.current[0][0].map((p) => p.name)).toEqual(['Alice', 'Bob', 'Carol'])
+      expect(result.current[0][0].map((p) => p.name)).toEqual(['Bob', 'Alice', 'Carol'])
       expect(reRenders).toBe(2)
     })
 
@@ -132,17 +132,17 @@ describe('use-sqlite-state', () => {
       { id: '3', name: 'Carol', age: 40 },
     ])
     const { result, rerender } = renderHook(
-      ({ order, limit }) => useSqliteValue(sql, { sorBy: 'age', order, limit }, [order, limit]),
+      ({ order, limit }) => useSqliteValue(sql, { sortBy: 'age', order, limit }, [order, limit]),
       { initialProps: { order: 'asc' as 'asc' | 'desc', limit: 2 } },
     )
     await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Bob'])
+      expect(result.current[0].map((p) => p.name)).toEqual(['Bob', 'Alice'])
     })
     act(() => {
       rerender({ order: 'desc', limit: 2 })
     })
     await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Bob'])
+      expect(result.current[0].map((p) => p.name)).toEqual(['Carol', 'Alice'])
     })
     act(() => {
       rerender({ order: 'desc', limit: 1 })
@@ -243,11 +243,11 @@ describe('use-sqlite-state', () => {
       people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
     }
     await sql.batchSet(people)
-    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sorBy: 'age', order }, [order]), {
+    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sortBy: 'age', order }, [order]), {
       initialProps: { order: 'asc' as 'asc' | 'desc' },
     })
     await waitFor(() => {
-      expect(result.current[0][0].age).toBe(21)
+      expect(result.current[0][0].age).toBe(20)
     })
     act(() => {
       rerender({ order: 'desc' })
@@ -268,14 +268,14 @@ describe('use-sqlite-state', () => {
       useSqliteValue(
         sql,
         {
-          sorBy: 'age',
+          sortBy: 'age',
           select: (d) => d.name,
         },
         [],
       ),
     )
     await waitFor(() => {
-      expect(result.current[0]).toEqual(['Alice', 'Bob', 'Carol'])
+      expect(result.current[0]).toEqual(['Bob', 'Alice', 'Carol'])
     })
   })
   it('should add 50 documents and then load with another hook', async () => {
@@ -286,7 +286,7 @@ describe('use-sqlite-state', () => {
       return useSqliteValue(
         sql,
         {
-          sorBy: 'age',
+          sortBy: 'age',
           order: 'desc',
         },
         [],

package/src/sqlite/select-sql.ts

@@ -1,13 +1,13 @@
 import { createState } from '../create-state'
 import type { GetState } from '../types'
 import type { SyncTable } from './create-sqlite'
-import type { DocType } from './table/table.types'
+import type { DocType, DotPath } from './table/table.types'
 import type { Where } from './table/where'
 
 export type CreateState<Document, Params extends unknown[]> = (...params: Params) => GetState<Document[]>
 
 export interface SqlSeachOptions<Document extends DocType> {
-  readonly sorBy?: keyof Document
+  readonly sortBy?: DotPath<Document>
   readonly order?: 'asc' | 'desc'
   readonly limit?: number
   readonly offset?: number

package/src/sqlite/table/table.types.ts

@@ -1,4 +1,5 @@
 // table.types.ts
+import type { SqlSeachOptions } from '../select-sql'
 import type { Backend } from './backend'
 import type { Where } from './where'
 
@@ -27,13 +28,7 @@ export interface DbOptions<Document extends DocType> {
   readonly disablePragmaOptimization?: boolean
 }
 
-export interface SearchOptions<Document extends DocType, Selected = Document> {
-  readonly sortBy?: DotPath<Document>
-  readonly order?: 'asc' | 'desc'
-  readonly limit?: number
-  readonly offset?: number
-  readonly where?: Where<Document>
-  readonly stepSize?: number
+export interface SearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
   readonly select?: (document: Document, meta: { rowId: number }) => Selected
 }
 

package/types/sqlite/select-sql.d.ts

@@ -1,10 +1,10 @@
 import type { GetState } from '../types';
 import type { SyncTable } from './create-sqlite';
-import type { DocType } from './table/table.types';
+import type { DocType, DotPath } from './table/table.types';
 import type { Where } from './table/where';
 export type CreateState<Document, Params extends unknown[]> = (...params: Params) => GetState<Document[]>;
 export interface SqlSeachOptions<Document extends DocType> {
-    readonly sorBy?: keyof Document;
+    readonly sortBy?: DotPath<Document>;
     readonly order?: 'asc' | 'desc';
     readonly limit?: number;
     readonly offset?: number;

package/types/sqlite/table/table.types.d.ts

@@ -1,3 +1,4 @@
+import type { SqlSeachOptions } from '../select-sql';
 import type { Backend } from './backend';
 import type { Where } from './where';
 export type DocType = {
@@ -16,13 +17,7 @@ export interface DbOptions<Document extends DocType> {
     readonly key?: DotPath<Document>;
     readonly disablePragmaOptimization?: boolean;
 }
-export interface SearchOptions<Document extends DocType, Selected = Document> {
-    readonly sortBy?: DotPath<Document>;
-    readonly order?: 'asc' | 'desc';
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly where?: Where<Document>;
-    readonly stepSize?: number;
+export interface SearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
     readonly select?: (document: Document, meta: {
         rowId: number;
     }) => Selected;