quetch 0.27.0 → 0.28.0

package/lib/tools/filterFromValue.test.ts

@@ -6,64 +6,34 @@ import { filterFromValue } from "./filterFromValue.js";
 
 test("returns filter from context", () => {
   expect(filterFromValue({ a: 1 })).toEqual({
-    operator: "all",
-    value: [
-      {
-        field: "a",
-        operator: "equal",
-        value: 1,
-      },
-    ],
+    field: "a",
+    operator: "equal",
+    value: 1,
   });
   expect(filterFromValue({ a: { b: 1 } })).toEqual({
-    operator: "all",
-    value: [
-      {
-        field: ["a", "b"],
-        operator: "equal",
-        value: 1,
-      },
-    ],
+    field: ["a", "b"],
+    operator: "equal",
+    value: 1,
   });
   expect(filterFromValue({ a: { b: undefined } })).toEqual({
-    operator: "all",
-    value: [
-      {
-        field: ["a", "b"],
-        operator: "equal",
-        value: undefined,
-      },
-    ],
+    field: ["a", "b"],
+    operator: "equal",
+    value: undefined,
   });
   expect(filterFromValue({ a: { b: null } })).toEqual({
-    operator: "all",
-    value: [
-      {
-        field: ["a", "b"],
-        operator: "equal",
-        value: null,
-      },
-    ],
+    field: ["a", "b"],
+    operator: "equal",
+    value: null,
   });
   expect(filterFromValue({ [SELF]: 3 })).toEqual({
-    operator: "all",
-    value: [
-      {
-        field: SELF,
-        operator: "equal",
-        value: 3,
-      },
-    ],
+    field: SELF,
+    operator: "equal",
+    value: 3,
   });
   expect(filterFromValue({ a: null })).toEqual({
-    operator: "all",
-    value: [
-      {
-        field: "a",
-        operator: "equal",
-        value: null,
-      },
-    ],
+    field: "a",
+    operator: "equal",
+    value: null,
   });
   expect(filterFromValue({ a: { b: 1 }, c: 2 })).toEqual({
     operator: "all",

package/lib/tools/testFilter.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from "vitest";
 
 import { CACHE } from "../constants/CACHE.js";
 import { SELF } from "../constants.js";
-import type { FilterChildren } from "../types.js";
+import type { FilterChildren, FilterContext } from "../types.js";
 
 import { filterFromValue } from "./filterFromValue.js";
 import { testFilter } from "./testFilter.js";
@@ -351,15 +351,15 @@ test("tests filter with paths", () => {
 });
 
 test("tests filter with children predicates", () => {
-  expect(testFilter({ operator: "children", value: "a" }, { id: "a/b" })).toBe(
-    true,
-  );
   expect(
-    testFilter({ operator: "notChildren", value: "a" }, { id: "a/b" }),
+    testFilter({ operator: "children", value: { id: "a" } }, { id: "a/b" }),
+  ).toBe(true);
+  expect(
+    testFilter({ operator: "notChildren", value: { id: "a" } }, { id: "a/b" }),
   ).toBe(false);
   expect(
     testFilter(
-      { operator: "children", value: ".a" },
+      { operator: "children", value: { path: ".a" } },
       { path: ".a.b" },
       {
         pathField: "path",
@@ -369,7 +369,7 @@ test("tests filter with children predicates", () => {
   ).toBe(true);
   expect(
     testFilter(
-      { operator: "notChildren", value: ".a" },
+      { operator: "notChildren", value: { path: ".a" } },
       { path: ".a.b" },
       {
         pathField: "path",
@@ -379,7 +379,7 @@ test("tests filter with children predicates", () => {
   ).toBe(false);
   const filterChildren: FilterChildren<{ path: string }> = {
     operator: "children",
-    value: "a",
+    value: { path: "a" },
   };
   expect(
     testFilter(
@@ -390,22 +390,40 @@ test("tests filter with children predicates", () => {
           return {
             field: "path",
             operator: "startWith",
-            value: `.${filter.value}.`,
+            value: `.${filter.value?.path}.`,
+          };
+        },
+      },
+    ),
+  ).toBe(true);
+  expect(
+    testFilter(
+      {
+        operator: "all",
+        value: [filterChildren],
+      },
+      { path: ".a.b" },
+      {
+        transformFilterChildren(filter) {
+          return {
+            field: "path",
+            operator: "startWith",
+            value: `.${filter.value?.path}.`,
           };
         },
       },
     ),
   ).toBe(true);
   expect(filterChildren[CACHE]).toBeDefined();
-  expect(testFilter({ operator: "children", value: "b" }, { id: "a/b" })).toBe(
-    false,
-  );
   expect(
-    testFilter({ operator: "notChildren", value: "b" }, { id: "a/b" }),
+    testFilter({ operator: "children", value: { id: "b" } }, { id: "a/b" }),
+  ).toBe(false);
+  expect(
+    testFilter({ operator: "notChildren", value: { id: "b" } }, { id: "a/b" }),
   ).toBe(true);
   expect(
     testFilter(
-      { operator: "children", value: "ba" },
+      { operator: "children", value: { path: "ba" } },
       { path: ".a.b" },
       {
         pathField: "path",
@@ -415,7 +433,7 @@ test("tests filter with children predicates", () => {
   ).toBe(false);
   expect(
     testFilter(
-      { operator: "notChildren", value: "ba" },
+      { operator: "notChildren", value: { path: "ba" } },
       { path: ".a.b" },
       {
         pathField: "path",
@@ -424,3 +442,54 @@ test("tests filter with children predicates", () => {
     ),
   ).toBe(true);
 });
+
+test("tests filter with context predicates", () => {
+  const context = { id: "a" };
+  expect(testFilter({ operator: "is", value: context }, { id: "a" })).toBe(
+    true,
+  );
+  expect(testFilter({ operator: "notIs", value: context }, { id: "a" })).toBe(
+    false,
+  );
+  const filterContext: FilterContext<typeof context> = {
+    operator: "is",
+    value: context,
+  };
+  expect(
+    testFilter(
+      filterContext,
+      { id: "a" },
+      {
+        transformFilterContext(filter) {
+          return {
+            field: "id",
+            operator: "equal",
+            value: filter.value?.id ?? "",
+          };
+        },
+      },
+    ),
+  ).toBe(true);
+  expect(
+    testFilter(
+      { operator: "all", value: [filterContext] },
+      { id: "a" },
+      {
+        transformFilterContext(filter) {
+          return {
+            field: "id",
+            operator: "equal",
+            value: filter.value?.id ?? "",
+          };
+        },
+      },
+    ),
+  ).toBe(true);
+  expect(filterContext[CACHE]).toBeDefined();
+  expect(testFilter({ operator: "is", value: { id: "b" } }, { id: "a" })).toBe(
+    false,
+  );
+  expect(
+    testFilter({ operator: "notIs", value: { id: "b" } }, { id: "a" }),
+  ).toBe(true);
+});

package/lib/tools/testFilter.ts

@@ -2,9 +2,16 @@ import { EMPTY_OBJECT } from "unchangeable";
 
 import { CACHE } from "../constants/CACHE.js";
 import type { QuerySettings } from "../types/QuerySettings.js";
-import type { FieldFiltered, Filter, FilterString } from "../types.js";
+import type {
+  Context,
+  FieldFiltered,
+  Filter,
+  FilterString,
+  IntrinsicFilter,
+} from "../types.js";
 
 import { filterChildren } from "./filterChildren.js";
+import { filterFromValue } from "./filterFromValue.js";
 import { get } from "./get.js";
 
 const { isArray } = Array;
@@ -38,7 +45,9 @@ export function testFilter<T>(
   }
   switch (filter.operator) {
     case "all":
-      return filter.value.every((filter) => testFilter(filter, value));
+      return filter.value.every((filter) =>
+        testFilter(filter, value, settings),
+      );
     case "any": {
       const length = filter.value?.length ?? 0;
       const minimum = filter.minimum ?? (length > 0 ? 1 : 0);
@@ -47,10 +56,13 @@ export function testFilter<T>(
         return true;
       }
       if (minimum === 1 && maximum >= length) {
-        return filter.value.some((filter) => testFilter(filter, value));
+        return filter.value.some((filter) =>
+          testFilter(filter, value, settings),
+        );
       }
       const matched = filter.value.reduce(
-        (count, filter) => count + (testFilter(filter, value) ? 1 : 0),
+        (count, filter) =>
+          count + (testFilter(filter, value, settings) ? 1 : 0),
         0,
       );
       return matched >= minimum && matched <= maximum;
@@ -59,7 +71,9 @@ export function testFilter<T>(
       if (filter.value === undefined || filter.value.length === 0) {
         return false;
       }
-      return filter.value.every((filter) => !testFilter(filter, value));
+      return filter.value.every(
+        (filter) => !testFilter(filter, value, settings),
+      );
     }
     case "exist":
       return get(value, filter.field as any) !== undefined;
@@ -124,16 +138,31 @@ export function testFilter<T>(
             filter[CACHE] = settings.transformFilterChildren(filter);
             break;
           default: {
-            const {
-              pathField = "id" as FieldFiltered<T, string>,
-              pathFieldSeparator,
-            } = settings || EMPTY_OBJECT;
-            filter[CACHE] = filterChildren(
-              filter.value as string,
-              pathField,
-              filter.deep,
+            const { pathField = "id", pathFieldSeparator } =
+              settings || EMPTY_OBJECT;
+            pathField;
+            filter[CACHE] = filterChildren<Context<T>>(
+              (get(filter.value, pathField as any) as string) ?? "",
+              pathField as FieldFiltered<Context<T>, string>,
+              filter.minDepth,
+              filter.maxDepth,
               pathFieldSeparator,
-            );
+            ) as IntrinsicFilter<T>;
+          }
+        }
+      }
+      return negate(testFilter(filter[CACHE], value, settings), not);
+    }
+    case "is":
+    case "notIs": {
+      const not = filter.operator[0] === "n";
+      if (filter[CACHE] === undefined) {
+        switch (true) {
+          case settings?.transformFilterContext !== undefined:
+            filter[CACHE] = settings.transformFilterContext(filter);
+            break;
+          default: {
+            filter[CACHE] = filterFromValue(filter.value as T);
           }
         }
       }

package/lib/types/Filter.ts

@@ -1,6 +1,7 @@
 import type { FilterArray } from "./FilterArray";
 import type { FilterBoolean } from "./FilterBoolean";
 import type { FilterChildren } from "./FilterChildren";
+import type { FilterContext } from "./FilterContext";
 import type { FilterCustom } from "./FilterCustom";
 import type { FilterField } from "./FilterField";
 import type { FilterGroup } from "./FilterGroup";
@@ -22,4 +23,5 @@ export type Filter<T> =
   | FilterGroup<T>
   | FilterString<T>
   | FilterStringIntersect<T>
+  | FilterContext<T>
   | FilterStringMatch<T>;

package/lib/types/FilterChildren.ts

@@ -5,11 +5,21 @@ import type { IntrinsicFilter } from "./IntrinsicFilter.js";
 
 /**
  * Matches the direct children of a specified `value` item.
- * If `deep` is `true`, also captures all the descendants.
  */
 export type FilterChildren<T> = {
   operator: "children" | "notChildren";
-  value?: Context<T> | string;
-  deep?: boolean;
+  value?: Context<T>;
+  /**
+   * Minimum depth of the children to match. If `0`, matches the direct children. If `1`, matches the grandchildren, and so on.
+   *
+   * @default 0
+   */
+  minDepth?: number;
+  /**
+   * Maximum depth of the children to match. If `0`, matches the direct children. If `1`, matches the grandchildren, and so on.
+   *
+   * @default Infinity
+   */
+  maxDepth?: number;
   [CACHE]?: IntrinsicFilter<T>;
 };

package/lib/types/FilterContext.ts

@@ -0,0 +1,13 @@
+import type { CACHE } from "../constants/CACHE.js";
+
+import type { Context } from "./Context";
+import type { IntrinsicFilter } from "./IntrinsicFilter.js";
+
+/**
+ * Matches items identified by their context.
+ */
+export type FilterContext<T> = {
+  operator: "is" | "notIs";
+  value: Context<T>;
+  [CACHE]?: IntrinsicFilter<T>;
+};

package/lib/types/QuerySettings.ts

@@ -1,5 +1,6 @@
 import type { FieldFiltered } from "./FieldFiltered";
 import type { FilterChildren } from "./FilterChildren";
+import type { FilterContext } from "./FilterContext";
 import type { IntrinsicFilter } from "./IntrinsicFilter";
 
 /**
@@ -29,6 +30,13 @@ export type QuerySettings<T> = {
    * @returns A filter that captures the items expressed by the provided `FilterChildren`.
    */
   transformFilterChildren?: (filter: FilterChildren<T>) => IntrinsicFilter<T>;
+  /**
+   * Returns a filter that captures the items expressed by the provided `FilterContext`. The return filter cannot use filters of type `FilterContext` or `FilterChildren`.
+   *
+   * @param filter
+   * @returns
+   */
+  transformFilterContext?: (filter: FilterContext<T>) => IntrinsicFilter<T>;
   /**
    * Abort signal to abort the query.
    */

package/lib/types.ts

@@ -18,6 +18,7 @@ export type { Filter } from "./types/Filter";
 export type { FilterArray } from "./types/FilterArray";
 export type { FilterBoolean } from "./types/FilterBoolean";
 export type { FilterChildren } from "./types/FilterChildren";
+export type { FilterContext } from "./types/FilterContext";
 export type { FilterCustom } from "./types/FilterCustom";
 export type { FilterField } from "./types/FilterField";
 export type { FilterGroup } from "./types/FilterGroup";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quetch",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "type": "module",
   "main": "./dist/main.js",
   "exports": {