Filter

1import type { SwarmFilter } from "./types.js";
2import { readColumn } from "./utils.js";
3
4/**
5 * Compare two values for deep equality.
6 *
7 * Handles primitives via `===` and objects/arrays via JSON
8 * serialization. `null` and `undefined` only equal themselves.
9 *
10 * @param a - First value.
11 * @param b - Second value.
12 * @returns `true` if the values are deeply equal.
13 */
14function deepEquals(a: unknown, b: unknown): boolean {
15  if (a === b) {
16    return true;
17  }
18
19  if (a == null || b == null) {
20    return false;
21  }
22
23  return JSON.stringify(a) === JSON.stringify(b);
24}
25
26/**
27 * Evaluate a filter clause against a single table row.
28 *
29 * Supports leaf predicates (`equals`, `notEquals`, `in`, `exists`)
30 * and recursive combinators (`and`, `or`). Column paths support
31 * dot notation for nested access.
32 *
33 * @param filter - The filter clause to evaluate.
34 * @param row - The table row to test against.
35 * @returns `true` if the row matches the filter.
36 */
37export function evaluateFilter(
38  filter: SwarmFilter,
39  row: Record<string, unknown>,
40): boolean {
41  if (filter == null || typeof filter !== "object") {
42    throw new Error(
43      `evaluateFilter: expected a filter object, got ${JSON.stringify(filter)}`,
44    );
45  }
46
47  if ("and" in filter) {
48    return filter.and.every((f) => evaluateFilter(f, row));
49  }
50
51  if ("or" in filter) {
52    return filter.or.some((f) => evaluateFilter(f, row));
53  }
54
55  const value = readColumn(row, filter.column);
56
57  if ("equals" in filter) {
58    return deepEquals(value, filter.equals);
59  }
60
61  if ("notEquals" in filter) {
62    return !deepEquals(value, filter.notEquals);
63  }
64
65  if ("in" in filter) {
66    return filter.in.some((item) => deepEquals(value, item));
67  }
68
69  if ("exists" in filter) {
70    return filter.exists ? value != null : value == null;
71  }
72
73  return false;
74}