feat(filters): control logical groups external mach mode

Author: ChronicStone

src/query.ts

@@ -1,5 +1,5 @@
-import type { GenericObject, QueryFilter, QueryFilterGroup, QueryParams, QueryResult } from './types'
-import { getObjectProperty, processFilterWithLookup, processSearchQuery } from './utils'
+import type { FilterOptions, GenericObject, QueryFilter, QueryFilterGroup, QueryParams, QueryResult } from './types'
+import { getObjectProperty, getOperator, processFilterWithLookup, processSearchQuery } from './utils'
 
 export function query<T extends GenericObject, P extends QueryParams<T>>(
   data: T[],
@@ -33,17 +33,19 @@ function matchesSearch<T extends GenericObject>(item: T, search?: QueryParams<T>
   })
 }
 
-function matchesFilters<T extends GenericObject>(item: T, filters?: (QueryFilter | QueryFilterGroup)[]): boolean {
-  if (!filters || filters.length === 0)
+function matchesFilters<T extends GenericObject>(item: T, filters?: FilterOptions): boolean {
+  const _filters = (typeof filters === 'object' && ('groups' in filters) ? filters.groups : filters) ?? []
+  if (!_filters || _filters.length === 0)
     return true
-  const isGroup = filters.every(filter => 'filters' in filter)
-  const method = isGroup ? 'some' : 'every'
-  return filters.filter(filter => filter.condition?.() ?? true)[method]((group: QueryFilter | QueryFilterGroup) => {
+  const isGroup = _filters.every(filter => 'filters' in filter)
+  const groupOperator = getOperator(typeof filters === 'object' && 'operator' in filters ? filters.operator : 'OR')
+  const method = isGroup ? (groupOperator === 'AND' ? 'every' : 'some') : 'every'
+  return _filters.filter(filter => filter.condition?.() ?? true)[method]((group: QueryFilter | QueryFilterGroup) => {
     const groupFilters = 'filters' in group ? group.filters : [group]
     const op = 'filters' in group ? group.operator : 'OR'
     return groupFilters.filter(filter => filter.condition?.() ?? true)[op === 'AND' ? 'every' : 'some']((filter: QueryFilter) => {
       const value = getObjectProperty(item, filter.key)
-      const operator = typeof filter.operator === 'function' ? filter.operator() : filter.operator ?? 'OR'
+      const operator = getOperator(filter.operator)
       const params = (!('params' in filter) ? null : typeof filter.params === 'function' ? filter.params(filter.value) : filter.params) ?? null
       return processFilterWithLookup({
         type: filter.matchMode,
@@ -113,7 +115,7 @@ function* lazySortedQuery<T extends GenericObject>(
 
 function paginateQuery<T extends GenericObject, P extends QueryParams<T>>(data: Iterable<T>, params: P): QueryResult<T, P> {
   if (typeof params.limit === 'undefined') {
-    return { rows: Array.from(data) } as QueryResult<T, P>
+    return Array.from(data) as QueryResult<T, P>
   }
 
   else {

src/types.ts

@@ -88,7 +88,10 @@ export interface QueryFilterGroup<Paths extends string = string> {
   condition?: () => boolean
 }
 
-export type FilterOptions<Paths extends string = string> = Array<QueryFilterGroup<Paths>> | Array<QueryFilter<Paths>>
+export type FilterOptions<Paths extends string = string> = Array<QueryFilterGroup<Paths>> | Array<QueryFilter<Paths>> | {
+  groups: Array<QueryFilterGroup<Paths>>
+  operator: Operator
+}
 
 export interface SearchOptions<Paths extends string = string> {
   value: string
@@ -114,7 +117,7 @@ export interface QueryParams<
   page?: number
 }
 
-export type QueryResult<T extends GenericObject, P extends QueryParams<T>> = P extends { limit: number } ? { totalRows: number, totalPages: number, rows: T[], unpaginatedRows: T[] } : { rows: T[] }
+export type QueryResult<T extends GenericObject, P extends QueryParams<T>> = P extends { limit: number } ? { totalRows: number, totalPages: number, rows: T[], unpaginatedRows: T[] } : T[]
 
 export interface MatchModeProcessorMap {
   equals: (f: { value: any, filter: any }) => boolean

src/utils.ts

@@ -1,4 +1,4 @@
-import type { FilterMatchMode, GenericObject, MatchModeProcessorMap } from './types'
+import type { FilterMatchMode, GenericObject, MatchModeProcessorMap, Operator } from './types'
 
 export function getObjectProperty(object: Record<string, any>, key: string) {
   return key.split('.').reduce((o, i) => o?.[i], object)
@@ -141,3 +141,13 @@ export function processFilterWithLookup<
 
   return false
 }
+
+export function getOperator(operator?: Operator) {
+  return (typeof operator === 'function' ? operator() : operator) ?? 'OR'
+}
+
+export function omit<T extends object, K extends Array<keyof T>>(object: T, keys: K) {
+  const _result = { ...object }
+  for (const key of keys) delete _result[key]
+  return _result as Omit<T, K[number]>
+}

test/index.test.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import { describe, expect, it } from 'vitest'
 import { query } from '../src'
+import { omit } from '../src/utils'
 import PaginationFixtures from './fixtures/pagination.fixture.json'
 import SortingFixtures from './fixtures/sorting.fixture.json'
 import FilteringFixtures from './fixtures/filtering.fixture.json'
@@ -29,10 +30,11 @@ for (const fixture of fixtures) {
   describe(`${fixture.key} tests`, () => {
     for (const test of fixture.tests) {
       it(test.title, () => {
-        const { unpaginatedRows, ...result } = (query as any)(test.data, test.query)
+        const result = (query as any)(test.data, test.query)
+        const matchResult = Array.isArray(result) ? { rows: result } : omit(result, ['unpaginatedRows'])
         console.log('expected', JSON.stringify(test.result, null, 2))
-        console.log('actual', JSON.stringify(result, null, 2))
-        expect(result).toEqual(test.result)
+        console.log('actual', JSON.stringify(matchResult, null, 2))
+        expect(matchResult).toEqual(test.result)
       })
     }
   })