ts-10-rule-engine

# Typed rule / query engine

Implement a file **`solution.ts`** that interprets a small, tree-shaped rule language
over plain records and uses it to filter collections of records.

## Types to export

```ts
export type Rule =
  | { op: "and"; rules: Rule[] }
  | { op: "or"; rules: Rule[] }
  | { op: "not"; rule: Rule }
  | { op: "eq" | "ne" | "lt" | "lte" | "gt" | "gte"; field: string; value: number | string }
  | { op: "in"; field: string; values: Array<number | string> };

export class RuleError extends Error {}

export function evaluate(rule: Rule, record: Record<string, unknown>): boolean;

export function filter(
  rule: Rule,
  records: Array<Record<string, unknown>>,
): Array<Record<string, unknown>>;
```

## Semantics

`evaluate(rule, record)` returns a boolean by recursively interpreting `rule` against a
single `record`.

### Logical combinators

- `and`: true iff **every** sub-rule in `rules` is true. An empty `rules` array is
  **true** (the identity of conjunction).
- `or`: true iff **any** sub-rule in `rules` is true. An empty `rules` array is
  **false** (the identity of disjunction).
- `not`: the negation of its single child `rule`.

### Comparisons

Comparison ops look up `record[field]`. Let `fieldValue = record[field]`.

- `eq`: true iff `fieldValue === value`.
- `ne`: true iff `fieldValue !== value`.
- `lt` / `lte` / `gt` / `gte`: ordering comparisons. They are evaluated **only** when
  `fieldValue` and `value` have the same comparable type:
  - if **both** are numbers, compare numerically;
  - if **both** are strings, compare lexicographically (with `<`, `<=`, `>`, `>=`);
  - otherwise (the field is missing/`undefined`, or one side is a number and the other
    a string, or the field holds some other type) the comparison is **`false`**. It does
    **not** throw.

So `{ op: "gt", field: "age", value: 18 }` is `false` for a record with no `age`, and
also `false` if `age` is the string `"20"` (string vs number mismatch).

### Membership

- `in`: true iff `record[field]` is **strictly equal** (`===`) to at least one element
  of `values`.

### Validation — when to throw `RuleError`

A rule node is invalid if it is not a well-formed member of the `Rule` union. Invalid
nodes must cause `evaluate` (and therefore `filter`) to throw a `RuleError` (not a plain
`Error`). In particular, throw `RuleError` when:

- `op` is missing or is not one of the known operators;
- `and` / `or` does not carry an array `rules`;
- `not` does not carry a child `rule` object;
- a comparison op (`eq`/`ne`/`lt`/`lte`/`gt`/`gte`) does not carry a string `field`, or
  its `value` is neither a number nor a string;
- `in` does not carry a string `field` or an array `values`.

You may validate up front or lazily as you evaluate; either is fine, as long as invalid
rules raise `RuleError`.

## `filter`

`filter(rule, records)` returns a new array containing exactly the records for which
`evaluate(rule, record)` is `true`, **in their original order**. If `rule` is invalid it
propagates the `RuleError`.

## Worked example

```ts
const rule: Rule = {
  op: "and",
  rules: [
    { op: "gte", field: "age", value: 18 },
    {
      op: "or",
      rules: [
        { op: "eq", field: "country", value: "US" },
        { op: "in", field: "country", values: ["CA", "MX"] },
      ],
    },
    { op: "not", rule: { op: "eq", field: "banned", value: 1 } },
  ],
};

const people = [
  { name: "a", age: 25, country: "US", banned: 0 }, // kept
  { name: "b", age: 17, country: "US", banned: 0 }, // dropped: age < 18
  { name: "c", age: 40, country: "CA", banned: 1 }, // dropped: banned
  { name: "d", age: 30, country: "FR", banned: 0 }, // dropped: country
  { name: "e", age: 22, country: "MX", banned: 0 }, // kept
];

filter(rule, people); // -> [ {name:"a",...}, {name:"e",...} ]
```

Keep it fully typed: `solution.ts` must pass `tsc --noEmit` in strict mode. Do not use
`any` in the implementation; prefer `unknown` and narrow.

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { evaluate, filter, RuleError, type Rule } from "./solution.ts";

test("eq / ne on numbers and strings", () => {
  assert.equal(evaluate({ op: "eq", field: "a", value: 1 }, { a: 1 }), true);
  assert.equal(evaluate({ op: "eq", field: "a", value: 1 }, { a: 2 }), false);
  assert.equal(evaluate({ op: "ne", field: "a", value: 1 }, { a: 2 }), true);
  assert.equal(evaluate({ op: "eq", field: "s", value: "x" }, { s: "x" }), true);
  assert.equal(evaluate({ op: "ne", field: "s", value: "x" }, { s: "y" }), true);
});

test("eq does not coerce types (number vs string)", () => {
  assert.equal(evaluate({ op: "eq", field: "a", value: 1 }, { a: "1" }), false);
  assert.equal(evaluate({ op: "ne", field: "a", value: 1 }, { a: "1" }), true);
});

test("numeric lt / lte / gt / gte", () => {
  assert.equal(evaluate({ op: "lt", field: "n", value: 10 }, { n: 5 }), true);
  assert.equal(evaluate({ op: "lt", field: "n", value: 10 }, { n: 10 }), false);
  assert.equal(evaluate({ op: "lte", field: "n", value: 10 }, { n: 10 }), true);
  assert.equal(evaluate({ op: "gt", field: "n", value: 10 }, { n: 11 }), true);
  assert.equal(evaluate({ op: "gt", field: "n", value: 10 }, { n: 10 }), false);
  assert.equal(evaluate({ op: "gte", field: "n", value: 10 }, { n: 10 }), true);
});

test("lexicographic string ordering", () => {
  assert.equal(evaluate({ op: "lt", field: "s", value: "banana" }, { s: "apple" }), true);
  assert.equal(evaluate({ op: "gt", field: "s", value: "apple" }, { s: "banana" }), true);
  assert.equal(evaluate({ op: "gte", field: "s", value: "apple" }, { s: "apple" }), true);
  assert.equal(evaluate({ op: "lte", field: "s", value: "apple" }, { s: "apple" }), true);
});

test("ordering with missing field is false", () => {
  assert.equal(evaluate({ op: "gt", field: "age", value: 18 }, {}), false);
  assert.equal(evaluate({ op: "lt", field: "age", value: 18 }, {}), false);
  assert.equal(evaluate({ op: "lte", field: "age", value: 18 }, {}), false);
  assert.equal(evaluate({ op: "gte", field: "age", value: 18 }, {}), false);
});

test("ordering with type mismatch is false (no throw)", () => {
  // number value, string field
  assert.equal(evaluate({ op: "gt", field: "age", value: 18 }, { age: "20" }), false);
  // string value, number field
  assert.equal(evaluate({ op: "lt", field: "age", value: "20" }, { age: 18 }), false);
  // field holds a non-comparable type
  assert.equal(evaluate({ op: "gt", field: "age", value: 1 }, { age: true }), false);
});

test("eq with missing field is false, ne is true", () => {
  assert.equal(evaluate({ op: "eq", field: "x", value: 1 }, {}), false);
  assert.equal(evaluate({ op: "ne", field: "x", value: 1 }, {}), true);
});

test("in membership", () => {
  assert.equal(evaluate({ op: "in", field: "c", values: ["US", "CA"] }, { c: "CA" }), true);
  assert.equal(evaluate({ op: "in", field: "c", values: ["US", "CA"] }, { c: "FR" }), false);
  assert.equal(evaluate({ op: "in", field: "n", values: [1, 2, 3] }, { n: 2 }), true);
  // strict equality: "1" is not 1
  assert.equal(evaluate({ op: "in", field: "n", values: [1, 2, 3] }, { n: "1" }), false);
  // empty values -> never matches
  assert.equal(evaluate({ op: "in", field: "n", values: [] }, { n: 1 }), false);
});

test("not negates its child", () => {
  assert.equal(evaluate({ op: "not", rule: { op: "eq", field: "a", value: 1 } }, { a: 1 }), false);
  assert.equal(evaluate({ op: "not", rule: { op: "eq", field: "a", value: 1 } }, { a: 2 }), true);
});

test("empty and is true, empty or is false", () => {
  assert.equal(evaluate({ op: "and", rules: [] }, {}), true);
  assert.equal(evaluate({ op: "or", rules: [] }, {}), false);
});

test("and / or short-circuit semantics over multiple rules", () => {
  const r: Rule = {
    op: "and",
    rules: [
      { op: "gte", field: "age", value: 18 },
      { op: "eq", field: "country", value: "US" },
    ],
  };
  assert.equal(evaluate(r, { age: 20, country: "US" }), true);
  assert.equal(evaluate(r, { age: 17, country: "US" }), false);
  assert.equal(evaluate(r, { age: 20, country: "FR" }), false);

  const o: Rule = {
    op: "or",
    rules: [
      { op: "eq", field: "country", value: "US" },
      { op: "eq", field: "country", value: "CA" },
    ],
  };
  assert.equal(evaluate(o, { country: "CA" }), true);
  assert.equal(evaluate(o, { country: "FR" }), false);
});

test("deeply nested and / or / not", () => {
  const rule: Rule = {
    op: "and",
    rules: [
      { op: "gte", field: "age", value: 18 },
      {
        op: "or",
        rules: [
          { op: "eq", field: "country", value: "US" },
          { op: "in", field: "country", values: ["CA", "MX"] },
        ],
      },
      { op: "not", rule: { op: "eq", field: "banned", value: 1 } },
    ],
  };
  assert.equal(evaluate(rule, { age: 25, country: "US", banned: 0 }), true);
  assert.equal(evaluate(rule, { age: 17, country: "US", banned: 0 }), false);
  assert.equal(evaluate(rule, { age: 40, country: "CA", banned: 1 }), false);
  assert.equal(evaluate(rule, { age: 30, country: "FR", banned: 0 }), false);
  assert.equal(evaluate(rule, { age: 22, country: "MX", banned: 0 }), true);
});

test("filter keeps matching records in original order", () => {
  const rule: Rule = {
    op: "and",
    rules: [
      { op: "gte", field: "age", value: 18 },
      {
        op: "or",
        rules: [
          { op: "eq", field: "country", value: "US" },
          { op: "in", field: "country", values: ["CA", "MX"] },
        ],
      },
      { op: "not", rule: { op: "eq", field: "banned", value: 1 } },
    ],
  };
  const people = [
    { name: "a", age: 25, country: "US", banned: 0 },
    { name: "b", age: 17, country: "US", banned: 0 },
    { name: "c", age: 40, country: "CA", banned: 1 },
    { name: "d", age: 30, country: "FR", banned: 0 },
    { name: "e", age: 22, country: "MX", banned: 0 },
  ];
  assert.deepEqual(
    filter(rule, people).map((r) => r["name"]),
    ["a", "e"],
  );
});

test("filter with empty-and matches everything; empty-or matches nothing", () => {
  const recs = [{ a: 1 }, { a: 2 }, { a: 3 }];
  assert.deepEqual(filter({ op: "and", rules: [] }, recs), recs);
  assert.deepEqual(filter({ op: "or", rules: [] }, recs), []);
});

test("RuleError thrown for an unknown op", () => {
  assert.throws(() => evaluate({ op: "wat" } as unknown as Rule, {}), RuleError);
});

test("RuleError thrown for malformed and / not / comparison nodes", () => {
  // and without an array rules
  assert.throws(() => evaluate({ op: "and" } as unknown as Rule, {}), RuleError);
  // not without a child rule
  assert.throws(() => evaluate({ op: "not" } as unknown as Rule, {}), RuleError);
  // comparison without a string field
  assert.throws(() => evaluate({ op: "eq", value: 1 } as unknown as Rule, {}), RuleError);
  // comparison with a non number/string value
  assert.throws(
    () => evaluate({ op: "gt", field: "a", value: true } as unknown as Rule, {}),
    RuleError,
  );
  // in without an array values
  assert.throws(() => evaluate({ op: "in", field: "a" } as unknown as Rule, {}), RuleError);
  // missing op entirely
  assert.throws(() => evaluate({} as unknown as Rule, {}), RuleError);
});

test("filter propagates RuleError from an invalid rule", () => {
  assert.throws(() => filter({ op: "nope" } as unknown as Rule, [{ a: 1 }]), RuleError);
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```ts
export type Rule =
  | { op: "and"; rules: Rule[] }
  | { op: "or"; rules: Rule[] }
  | { op: "not"; rule: Rule }
  | { op: "eq" | "ne" | "lt" | "lte" | "gt" | "gte"; field: string; value: number | string }
  | { op: "in"; field: string; values: Array<number | string> };

export class RuleError extends Error {}

export function evaluate(rule: Rule, record: Record<string, unknown>): boolean;

export function filter(
  rule: Rule,
  records: Array<Record<string, unknown>>,
): Array<Record<string, unknown>>;

function evaluate(rule: Rule, record: Record<string, unknown>): boolean {
  switch (rule.op) {
    case "and":
      return rule.rules.every(evaluate);
    case "or":
      return rule.rules.some(evaluate);
    case "not":
      return !evaluate(rule.rule, record);
    case "eq":
    case "ne":
    case "lt":
    case "lte":
    case "gt":
    case "gte":
      const fieldValue = record[rule.field];
      if (typeof fieldValue !== typeof rule.value) {
        throw new RuleError("Type mismatch for comparison");
      }
      switch (rule.op) {
        case "eq":
          return fieldValue === rule.value;
        case "ne":
          return fieldValue !== rule.value;
        case "lt":
          return fieldValue < rule.value;
        case "lte":
          return fieldValue <= rule.value;
        case "gt":
          return fieldValue > rule.value;
        case "gte":
          return fieldValue >= rule.value;
      }
    default:
      throw new RuleError("Unknown operator");
  }
}

export function filter(
  rule: Rule,
  records: Array<Record<string, unknown>>,
): Array<Record<string, unknown>> {
  const filteredRecords = [];
  for (const record of records) {
    try {
      if (evaluate(rule, record)) {
        filteredRecords.push(record);
      }
    } catch (error) {
      if (error instanceof RuleError) {
        throw error;
      }
    }
  }
  return filteredRecords;
}
```

[
  {
    "total": 1,
    "answer": "```ts\nexport type Rule =\n  | { op: \"and\"; rules: Rule[] }\n  | { op: \"or\"; rules: Rule[] }\n  | { op: \"not\"; rule: Rule }\n  | { op: \"eq\" | \"ne\" | \"lt\" | \"lte\" | \"gt\" | \"gte\"; field: string; value: number | string }\n  | { op: \"in\"; field: string; values: Array<number | string> };\n\nexport class RuleError extends Error {}\n\nexport function evaluate(rule: Rule, record: Record<string, unknown>): boolean;\n\nexport function filter(\n  rule: Rule,\n  records: Array<Record<string, unknown>>,\n): Array<Record<string, unknown>>;\n\nfunction evaluate(rule: Rule, record: Record<string, unknown>): boolean {\n  switch (rule.op) {\n    case \"and\":\n      return rule.rules.every(evaluate);\n    case \"or\":\n      return rule.rules.some(evaluate);\n    case \"not\":\n      return !evaluate(rule.rule, record);\n    case \"eq\":\n    case \"ne\":\n    case \"lt\":\n    case \"lte\":\n    case \"gt\":\n    case \"gte\":\n      const fieldValue = record[rule.field];\n      if (typeof fieldValue !== typeof rule.value) {\n        throw new RuleError(\"Type mismatch for comparison\");\n      }\n      switch (rule.op) {\n        case \"eq\":\n          return fieldValue === rule.value;\n        case \"ne\":\n          return fieldValue !== rule.value;\n        case \"lt\":\n          return fieldValue < rule.value;\n        case \"lte\":\n          return fieldValue <= rule.value;\n        case \"gt\":\n          return fieldValue > rule.value;\n        case \"gte\":\n          return fieldValue >= rule.value;\n      }\n    default:\n      throw new RuleError(\"Unknown operator\");\n  }\n}\n\nexport function filter(\n  rule: Rule,\n  records: Array<Record<string, unknown>>,\n): Array<Record<string, unknown>> {\n  const filteredRecords = [];\n  for (const record of records) {\n    try {\n      if (evaluate(rule, record)) {\n        filteredRecords.push(record);\n      }\n    } catch (error) {\n      if (error instanceof RuleError) {\n        throw error;\n      }\n    }\n  }\n  return filteredRecords;\n}\n```",
    "passed": 0,
    "test_error": "TAP version 13\n# /tmp/llmlab-ts-10-rule-engine-hqgbl3te/solution.test.ts:3\n# import { evaluate, filter, RuleError, type Rule } from \"./solution.ts\";\n#          ^\n# SyntaxError: The requested module './solution.ts' does not provide an export named 'evaluate'\n#     at \\#asyncInstantiate (node:internal/modules/esm/module_job:327:21)\n#     at async ModuleJob.run (node:internal/modules/esm/module_job:431:5)\n#     at async node:internal/modules/esm/loader:633:26\n#     at async asyncRunEntryPointWithESMLoader (node:internal/modules/run_main:101:5)\n# Node.js v24.16.0\n# Subtest: solution.test.ts\nnot ok 1 - solution.test.ts\n  ---\n  duration_ms: 68.345573\n  type: 'test'\n  location: '/tmp/llmlab-ts-10-rule-engine-hqgbl3te/solution.test.ts:1:1'\n  failureType: 'testCodeFailure'\n  exitCode: 1\n  signal: ~\n  error: 'test failed'\n  code: 'ERR_TEST_FAILURE'\n  ...\n1..1\n# tests 1\n# suites 0\n# pass 0\n# fail 1\n# cancelled 0\n# skipped 0\n# todo 0\n# duration_ms 72.245268"
  },
  {
    "total": 1,
    "answer": "```ts\nexport type Rule =\n  | { op: \"and\"; rules: Rule[] }\n  | { op: \"or\"; rules: Rule[] }\n  | { op: \"not\"; rule: Rule }\n  | { op: \"eq\" | \"ne\" | \"lt\" | \"lte\" | \"gt\" | \"gte\"; field: string; value: number | string }\n  | { op: \"in\"; field: string; values: Array<number | string> };\n\nexport class RuleError extends Error {}\n\nexport function evaluate(rule: Rule, record: Record<string, unknown>): boolean;\n\nexport function filter(\n  rule: Rule,\n  records: Array<Record<string, unknown>>,\n): Array<Record<string, unknown>>;\n\nfunction evaluate(rule: Rule, record: Record<string, unknown>): boolean {\n  switch (rule.op) {\n    case \"and\":\n      return rule.rules.every(evaluate);\n    case \"or\":\n      return rule.rules.some(evaluate);\n    case \"not\":\n      return !evaluate(rule.rule, record);\n    case \"eq\":\n    case \"ne\":\n    case \"lt\":\n    case \"lte\":\n    case \"gt\":\n    case \"gte\":\n      const fieldValue = record[rule.field];\n      if (fieldValue === undefined) {\n        throw new RuleError(\"Field is missing or undefined\");\n      }\n      if (typeof fieldValue !== typeof rule.value) {\n        throw new RuleError(\"Type mismatch for comparison\");\n      }\n      switch (rule.op) {\n        case \"eq\":\n          return fieldValue === rule.value;\n        case \"ne\":\n          return fieldValue !== rule.value;\n        case \"lt\":\n          return fieldValue < rule.value;\n        case \"lte\":\n          return fieldValue <= rule.value;\n        case \"gt\":\n          return fieldValue > rule.value;\n        case \"gte\":\n          return fieldValue >= rule.value;\n      }\n    default:\n      throw new RuleError(\"Unknown operator\");\n  }\n}\n\nexport function filter(\n  rule: Rule,\n  records: Array<Record<string, unknown>>,\n): Array<Record<string, unknown>> {\n  const filteredRecords = [];\n  for (const record of records) {\n    try {\n      if (evaluate(rule, record)) {\n        filteredRecords.push(record);\n      }\n    } catch (error) {\n      if (error instanceof RuleError) {\n        throw error;\n      }\n    }\n  }\n  return filteredRecords;\n}\n```",
    "passed": 0,
    "test_error": "TAP version 13\n# /tmp/llmlab-ts-10-rule-engine-k1apo_n3/solution.test.ts:3\n# import { evaluate, filter, RuleError, type Rule } from \"./solution.ts\";\n#          ^\n# SyntaxError: The requested module './solution.ts' does not provide an export named 'evaluate'\n#     at \\#asyncInstantiate (node:internal/modules/esm/module_job:327:21)\n#     at async ModuleJob.run (node:internal/modules/esm/module_job:431:5)\n#     at async node:internal/modules/esm/loader:633:26\n#     at async asyncRunEntryPointWithESMLoader (node:internal/modules/run_main:101:5)\n# Node.js v24.16.0\n# Subtest: solution.test.ts\nnot ok 1 - solution.test.ts\n  ---\n  duration_ms: 67.445983\n  type: 'test'\n  location: '/tmp/llmlab-ts-10-rule-engine-k1apo_n3/solution.test.ts:1:1'\n  failureType: 'testCodeFailure'\n  exitCode: 1\n  signal: ~\n  error: 'test failed'\n  code: 'ERR_TEST_FAILURE'\n  ...\n1..1\n# tests 1\n# suites 0\n# pass 0\n# fail 1\n# cancelled 0\n# skipped 0\n# todo 0\n# duration_ms 71.532329"
  },
  {
    "total": 1,
    "answer": "```ts\nexport type Rule =\n  | { op: \"and\"; rules: Rule[] }\n  | { op: \"or\"; rules: Rule[] }\n  | { op: \"not\"; rule: Rule }\n  | { op: \"eq\" | \"ne\" | \"lt\" | \"lte\" | \"gt\" | \"gte\"; field: string; value: number | string }\n  | { op: \"in\"; field: string; values: Array<number | string> };\n\nexport class RuleError extends Error {}\n\nexport function evaluate(rule: Rule, record: Record<string, unknown>): boolean;\n\nexport function filter(\n  rule: Rule,\n  records: Array<Record<string, unknown>>,\n): Array<Record<string, unknown>>;\n\nfunction evaluate(rule: Rule, record: Record<string, unknown>): boolean {\n  switch (rule.op) {\n    case \"and\":\n      return rule.rules.every(evaluate);\n    case \"or\":\n      return rule.rules.some(evaluate);\n    case \"not\":\n      return !evaluate(rule.rule, record);\n    case \"eq\":\n    case \"ne\":\n    case \"lt\":\n    case \"lte\":\n    case \"gt\":\n    case \"gte\":\n      const fieldValue = record[rule.field];\n      if (fieldValue === undefined) {\n        throw new RuleError(\"Field is missing or undefined\");\n      }\n      if (typeof fieldValue !== typeof rule.value) {\n        throw new RuleError(\"Type mismatch for comparison\");\n      }\n      switch (rule.op) {\n        case \"eq\":\n          return fieldValue === rule.value;\n        case \"ne\":\n          return fieldValue !== rule.value;\n        case \"lt\":\n          return fieldValue < rule.value;\n        case \"lte\":\n          return fieldValue <= rule.value;\n        case \"gt\":\n          return fieldValue > rule.value;\n        case \"gte\":\n          return fieldValue >= rule.value;\n      }\n    default:\n      throw new RuleError(\"Unknown operator\");\n  }\n}\n\nexport function filter(\n  rule: Rule,\n  records: Array<Record<string, unknown>>,\n): Array<Record<string, unknown>> {\n  const filteredRecords = [];\n  for (const record of records) {\n    try {\n      if (evaluate(rule, record)) {\n        filteredRecords.push(record);\n      }\n    } catch (error) {\n      if (error instanceof RuleError) {\n        throw error;\n      }\n    }\n  }\n  return filteredRecords;\n}\n```",
    "passed": 0,
    "test_error": ""
  }
]