@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/checks/families/filter/filter-alias-matches-canonical.js

@@ -0,0 +1,60 @@
+import { defineCheck } from "../../core/define.js";
+import { canWriteFilterOp, filterTerm } from "../../../../spec/conventions/filter.js";
+import { fieldAllows } from "../../../../spec/query/field-ops.js";
+import { isFilterOp } from "../../../../spec/query/ops.js";
+import { ASSERTED } from "../../../finding.js";
+import { when } from "../../core/plan.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { asTermValue, conv, filterable, FOUNDATIONS, MOVING_COLLECTION, resolvedCaps, } from "../../query/capabilities.js";
+import { readSettled, sameSet, setOf } from "../../sets/compare.js";
+export const filterAliasMatchesCanonical = defineCheck({
+    plan: (ctx) => when(Object.keys(resolvedCaps(ctx).aliases).length > 0 && filterable(ctx)),
+    dependsOn: ["query.filter-selects-from-whole-set", ...FOUNDATIONS, "filter.equality-selects-exactly-one"],
+    id: "filter.alias-matches-canonical",
+    lists: true,
+    needs: "a declared filter operator alias",
+    subjects: subjectsOf.list,
+    async run(ctx) {
+        const caps = resolvedCaps(ctx);
+        const conventions = conv(ctx);
+        for (const [alias, target] of Object.entries(caps.aliases)) {
+            if (!isFilterOp(alias) || target === undefined)
+                continue;
+            const field = resolvedCaps(ctx).filterable.find((item) => fieldAllows(item, target, caps));
+            if (field === undefined || !canWriteFilterOp(conventions, alias))
+                continue;
+            const sample = ctx.records.find((row) => row[field.field] != null);
+            if (sample === undefined)
+                continue;
+            const value = asTermValue(sample[field.field]);
+            const aliasTerm = filterTerm(conventions, { field: field.field, op: alias, value });
+            const targetTerm = filterTerm(conventions, { field: field.field, op: target, value });
+            if (aliasTerm === null || targetTerm === null)
+                continue;
+            const agree = (pair) => {
+                const [a, b] = pair;
+                return sameSet(setOf(a.items, ctx.identity), setOf(b.items, ctx.identity));
+            };
+            const reads = await readSettled(ctx, [aliasTerm, targetTerm], agree);
+            if (reads === "rejected") {
+                return ctx.findings.unresolved(this.id, ctx.entityName, `alias ${alias} or ${target} was rejected`);
+            }
+            if (reads === "incomplete") {
+                return ctx.findings.unresolved(this.id, ctx.entityName, "the collection is larger than the walk covers");
+            }
+            if (reads === "moving")
+                return ctx.findings.unresolved(this.id, ctx.entityName, MOVING_COLLECTION);
+            /* One read per term, in the order the terms were given. */
+            const [left, right] = reads;
+            if (!agree(reads)) {
+                return ctx.findings.backend(this.id, ctx.entityName, {
+                    summary: `alias ${alias} does not select the same set as ${target}`,
+                    detail: `${field.field}.${alias} and ${field.field}.${target} disagreed on membership.`,
+                    evidence: [left.last.exchange, right.last.exchange],
+                });
+            }
+        }
+        return ASSERTED;
+    },
+});
+//# sourceMappingURL=filter-alias-matches-canonical.js.map

package/dist/api/runtime/checks/families/filter/filter-and-composes-as-intersection.d.ts

@@ -0,0 +1,10 @@
+import type { Check } from "../../core/check.ts";
+import { type Compound } from "./compound.ts";
+/**
+ * Every filter check above uses a single predicate. Real filters compose them: `and(a,b)`,
+ * `or(a,b)`, and nested combinations of both. This is the first of two checks giving that
+ * combinator its own set-algebra property, needing no ground truth just like the rest: a
+ * conjunction of two predicates must select exactly the intersection of what each selects alone.
+ */
+export declare const filterAndComposesAsIntersection: Check<Compound>;
+//# sourceMappingURL=filter-and-composes-as-intersection.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-and-composes-as-intersection.js

@@ -0,0 +1,54 @@
+import { defineCheck } from "../../core/define.js";
+import { andTerm } from "../../../../spec/conventions/filter.js";
+import { ASSERTED } from "../../../finding.js";
+import { cannot } from "../../core/plan.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { filterable, MOVING_COLLECTION } from "../../query/capabilities.js";
+import { compoundPlan, readComposed } from "./compound.js";
+/**
+ * Every filter check above uses a single predicate. Real filters compose them: `and(a,b)`,
+ * `or(a,b)`, and nested combinations of both. This is the first of two checks giving that
+ * combinator its own set-algebra property, needing no ground truth just like the rest: a
+ * conjunction of two predicates must select exactly the intersection of what each selects alone.
+ */
+export const filterAndComposesAsIntersection = defineCheck({
+    plan: (ctx) => (filterable(ctx) && (ctx.query?.filterable.length ?? 0) > 1 ? compoundPlan(ctx, andTerm) : cannot()),
+    dependsOn: [
+        "query.filter-selects-from-whole-set",
+        "list.read-after-write",
+        "create.persists-submitted-fields",
+        "filter.equality-selects-exactly-one",
+        /* Both sides are gathered across pages, so a walk that skips or repeats records changes
+         * the membership being compared for reasons unrelated to composition. */
+        "pagination.page-walk-covers-set",
+    ],
+    id: "filter.and-composes-as-intersection",
+    lists: true,
+    needs: "two filterable fields and a filter parameter or grammar supporting eq",
+    subjects: subjectsOf.list,
+    async run(ctx, { combined, fieldA, fieldB, termA, termB, valueA, valueB }) {
+        const composed = await readComposed(ctx, { combined, termA, termB }, (a, b) => new Set([...a].filter((id) => b.has(id))));
+        if (composed === "rejected") {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "one of the three listings needed for the intersection was rejected");
+        }
+        if (composed === "incomplete") {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the collection is larger than the walk covers, so the intersection cannot be verified");
+        }
+        if (composed === "moving")
+            return ctx.findings.unresolved(this.id, ctx.entityName, MOVING_COLLECTION);
+        const { expected, extra, got, missing, onlyA, onlyB, setA, setB } = composed;
+        if (missing.length === 0 && extra.length === 0)
+            return ASSERTED;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "and() does not compose as the intersection of its terms",
+            detail: `and(${fieldA}.eq.${valueA},${fieldB}.eq.${valueB}) returned ${got.size} record(s); ` +
+                `${fieldA}.eq.${valueA} alone returned ${setA.size}, ${fieldB}.eq.${valueB} alone returned ` +
+                `${setB.size}, whose intersection is ${expected.size}. ` +
+                (missing.length > 0 ? `Missing from the combined result: ${missing.slice(0, 3).join(", ")}. ` : "") +
+                (extra.length > 0 ? `Present but should not match both terms: ${extra.slice(0, 3).join(", ")}. ` : "") +
+                "A conjunction must select exactly the records both terms match individually.",
+            evidence: [onlyA.last.exchange, onlyB.last.exchange, composed.combined.last.exchange],
+        });
+    },
+});
+//# sourceMappingURL=filter-and-composes-as-intersection.js.map

package/dist/api/runtime/checks/families/filter/filter-condition-cap-rejected.d.ts

@@ -0,0 +1,7 @@
+import type { Check } from "../../core/check.ts";
+import type { FilterQuery } from "../../../../spec/render/filter-types.ts";
+export declare const filterConditionCapRejected: Check<{
+    max: number;
+    overCap: FilterQuery;
+}>;
+//# sourceMappingURL=filter-condition-cap-rejected.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-condition-cap-rejected.js

@@ -0,0 +1,39 @@
+import { defineCheck } from "../../core/define.js";
+import { filterSpec } from "../../../../spec/conventions/filter.js";
+import { renderAnd } from "../../../../spec/render/filter-combine.js";
+import { canGroupAnd } from "../../../../spec/render/filter-term.js";
+import { cannot, ready } from "../../core/plan.js";
+import { asProbe, judgeRefusal } from "../../planning/refusal.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { conv, filterIdentity, FOUNDATIONS, identityIsFilterable, q, resolvedCaps } from "../../query/capabilities.js";
+import { list } from "../../sets/list.js";
+export const filterConditionCapRejected = defineCheck({
+    plan: (ctx) => {
+        const max = resolvedCaps(ctx).maxFilterConditions;
+        const conventions = conv(ctx);
+        if (max === undefined || conventions.filter === undefined)
+            return cannot();
+        if (!canGroupAnd(filterSpec(conventions)) || !identityIsFilterable(ctx))
+            return cannot();
+        const term = { field: filterIdentity(ctx), op: "eq", value: "testing-cap" };
+        const overCap = renderAnd(filterSpec(conventions), conventions.filter, Array.from({ length: max + 1 }, () => term));
+        return overCap === null ? cannot() : ready({ max, overCap });
+    },
+    dependsOn: [...FOUNDATIONS, "error.malformed-filter-not-5xx"],
+    id: "filter.condition-cap-rejected",
+    lists: true,
+    needs: "`maxFilterConditions` declared and a grammar that can group eq terms",
+    subjects: subjectsOf.list,
+    async run(ctx, { max, overCap }) {
+        const result = await list(asProbe(ctx), { ...q(ctx, { limit: 5 }), ...overCap });
+        const refused = judgeRefusal(ctx, this.id, ["validation"], result.exchange);
+        if (refused !== null)
+            return refused;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "an over-limit filter expression was accepted",
+            detail: `maxFilterConditions=${max} but ${max + 1} eq terms returned ${result.exchange.status}.`,
+            evidence: [result.exchange],
+        });
+    },
+});
+//# sourceMappingURL=filter-condition-cap-rejected.js.map

package/dist/api/runtime/checks/families/filter/filter-contains-membership.d.ts

@@ -0,0 +1,8 @@
+import type { Check } from "../../core/check.ts";
+import type { EffectiveFilterField } from "../../../../spec/query/effective.ts";
+export declare const filterContainsMembership: Check<{
+    field: EffectiveFilterField;
+    element: string;
+    term: Record<string, string>;
+}>;
+//# sourceMappingURL=filter-contains-membership.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-contains-membership.js

@@ -0,0 +1,66 @@
+import { defineCheck } from "../../core/define.js";
+import { canWriteFilterOp, filterTerm } from "../../../../spec/conventions/filter.js";
+import { fieldAllows } from "../../../../spec/query/field-ops.js";
+import { ASSERTED } from "../../../finding.js";
+import { idOf } from "../../../world/records.js";
+import { cannot, ready } from "../../core/plan.js";
+import { storedFieldsUnknown } from "../../planning/stand-down.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { asTermValue, conv, FOUNDATIONS, pageSize, resolvedCaps, schemaType } from "../../query/capabilities.js";
+import { collectSet, sameSet } from "../../sets/compare.js";
+import { knownHits } from "./fields.js";
+/** An array field membership can be asked of, with a known element — one rule for both phases. */
+function containsField(ctx) {
+    return resolvedCaps(ctx).filterable.find((field) => (field.type === "array" ||
+        schemaType(ctx, field.field) === "array" ||
+        fieldAllows(field, "contains", resolvedCaps(ctx))) &&
+        canWriteFilterOp(conv(ctx), "contains") &&
+        ctx.records.some((row) => Array.isArray(row[field.field]) && row[field.field].length > 0));
+}
+export const filterContainsMembership = defineCheck({
+    plan: (ctx) => {
+        const unverified = storedFieldsUnknown(ctx);
+        if (unverified !== undefined)
+            return unverified;
+        const field = containsField(ctx);
+        if (field === undefined)
+            return cannot();
+        /* The most telling element is one that also occurs inside another element's text: an
+         * implementation matching the serialized array instead of its members over-selects there. */
+        const elements = [
+            ...new Set(ctx.records.flatMap((row) => (Array.isArray(row[field.field]) ? row[field.field] : []))),
+        ].map(String);
+        /* `containsField` found a record holding an element, so there is a first one. */
+        const element = elements.find((candidate) => elements.some((other) => other !== candidate && other.includes(candidate))) ??
+            elements[0];
+        const term = filterTerm(conv(ctx), { field: field.field, op: "contains", value: asTermValue(element) });
+        return term === null ? cannot("a filter grammar with a contains operator") : ready({ element, field, term });
+    },
+    dependsOn: [...FOUNDATIONS, "query.filter-selects-from-whole-set"],
+    id: "filter.contains-membership",
+    lists: true,
+    needs: "an array field that allows `contains` and a known element",
+    subjects: subjectsOf.list,
+    async run(ctx, { element, field, term }) {
+        const result = await collectSet(ctx, pageSize(ctx), term);
+        if (result === null) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "contains probe was rejected");
+        }
+        if (!result.complete) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the collection is larger than the walk covers");
+        }
+        const expected = new Set(ctx.records
+            .filter((row) => Array.isArray(row[field.field]) &&
+            row[field.field].some((item) => String(item) === String(element)))
+            .flatMap((row) => idOf(row, ctx.identity) ?? []));
+        const got = knownHits(result.items, ctx);
+        if (sameSet(expected, got))
+            return ASSERTED;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "contains does not select membership of the given element",
+            detail: `${field.field}.contains.${String(element)} returned ${got.size}; ${expected.size} records hold that element.`,
+            evidence: [result.last.exchange],
+        });
+    },
+});
+//# sourceMappingURL=filter-contains-membership.js.map

package/dist/api/runtime/checks/families/filter/filter-empty-in.d.ts

@@ -0,0 +1,8 @@
+import type { Check } from "../../core/check.ts";
+import type { EffectiveQueryCapabilities } from "../../../../spec/query/effective.ts";
+export declare const filterEmptyIn: Check<{
+    field: string;
+    policy: NonNullable<EffectiveQueryCapabilities["emptyIn"]>;
+    term: Record<string, string>;
+}>;
+//# sourceMappingURL=filter-empty-in.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-empty-in.js

@@ -0,0 +1,54 @@
+import { defineCheck } from "../../core/define.js";
+import { filterTerm } from "../../../../spec/conventions/filter.js";
+import { ASSERTED } from "../../../finding.js";
+import { cannot, ready } from "../../core/plan.js";
+import { judgeRefusal } from "../../planning/refusal.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { conv, FOUNDATIONS, pageSize, q, resolvedCaps } from "../../query/capabilities.js";
+import { ids, list } from "../../sets/list.js";
+import { pickFieldForOp } from "./fields.js";
+export const filterEmptyIn = defineCheck({
+    plan: (ctx) => {
+        const picked = pickFieldForOp(ctx, "in", 1);
+        const policy = resolvedCaps(ctx).emptyIn;
+        if (picked === null || policy === undefined)
+            return cannot();
+        const term = filterTerm(conv(ctx), { field: picked.field.field, op: "in", value: [] });
+        return term === null
+            ? cannot("a filter grammar that can express an empty in()")
+            : ready({ field: picked.field.field, policy, term });
+    },
+    dependsOn: ["query.filter-selects-from-whole-set", ...FOUNDATIONS, "filter.in-is-union-of-eq"],
+    id: "filter.empty-in",
+    lists: true,
+    needs: "`emptyIn` declared and a field that allows `in`",
+    subjects: subjectsOf.list,
+    async run(ctx, { field, policy, term }) {
+        const baseline = await list(ctx, q(ctx, { limit: pageSize(ctx) }));
+        const result = await list(ctx, { ...q(ctx, { limit: pageSize(ctx) }), ...term });
+        if (policy === "reject") {
+            const refused = judgeRefusal(ctx, this.id, ["validation"], result.exchange);
+            if (refused !== null)
+                return refused;
+            return ctx.findings.backend(this.id, ctx.entityName, {
+                summary: "empty in() was not rejected",
+                detail: `emptyIn=reject but ${field}.in.() returned ${result.exchange.status}.`,
+                evidence: [result.exchange],
+            });
+        }
+        if (result.exchange.status >= 400) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "empty in() was rejected under match-none");
+        }
+        if (result.items.length === 0)
+            return ASSERTED;
+        const same = ids(result.items, ctx.identity).join(",") === ids(baseline.items, ctx.identity).join(",");
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "empty in() did not match none",
+            detail: `emptyIn=match-none but ${field}.in.() returned ${result.items.length} record(s)` +
+                (same ? " — the unfiltered set, so the filter was ignored" : "") +
+                ".",
+            evidence: [baseline.exchange, result.exchange],
+        });
+    },
+});
+//# sourceMappingURL=filter-empty-in.js.map

package/dist/api/runtime/checks/families/filter/filter-equality-selects-exactly-one.d.ts

@@ -0,0 +1,7 @@
+import type { Check } from "../../core/check.ts";
+export declare const equalityFilterSelectsOne: Check<{
+    id: string;
+    field: string;
+    term: Record<string, string>;
+}>;
+//# sourceMappingURL=filter-equality-selects-exactly-one.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-equality-selects-exactly-one.js

@@ -0,0 +1,45 @@
+import { defineCheck } from "../../core/define.js";
+import { filterTerm } from "../../../../spec/conventions/filter.js";
+import { ASSERTED } from "../../../finding.js";
+import { idOf } from "../../../world/records.js";
+import { cannot, ready } from "../../core/plan.js";
+import { NO_IDENTITY, subjectsOf } from "../../planning/subjects.js";
+import { conv, filterable, filterIdentity, identityIsFilterable, pageSize, q } from "../../query/capabilities.js";
+import { ids, list } from "../../sets/list.js";
+export const equalityFilterSelectsOne = defineCheck({
+    plan: (ctx) => {
+        const target = ctx.records[0];
+        if (!filterable(ctx) || !identityIsFilterable(ctx) || target === undefined)
+            return cannot();
+        const id = idOf(target, ctx.identity);
+        if (id === undefined)
+            return cannot(NO_IDENTITY);
+        const field = filterIdentity(ctx);
+        const term = filterTerm(conv(ctx), { field, op: "eq", value: id });
+        return term === null
+            ? cannot("a filter grammar that can express equality on the identity")
+            : ready({ field, id, term });
+    },
+    dependsOn: ["query.filter-selects-from-whole-set", "list.read-after-write"],
+    id: "filter.equality-selects-exactly-one",
+    lists: true,
+    needs: "a `filter` parameter that accepts the identity field",
+    subjects: subjectsOf.list,
+    async run(ctx, { field, id, term }) {
+        const result = await list(ctx, { ...q(ctx, { limit: pageSize(ctx) }), ...term });
+        /* A rejected filter is not a wrong answer. If the backend says this field is not
+         * filterable, that is a capability statement — the gap belongs to x-query, which is
+         * already reported, not here. Reading a 4xx as "returned zero records" invents a defect. */
+        if (result.exchange.status >= 400)
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the equality filter was rejected");
+        const got = ids(result.items, ctx.identity);
+        if (got.length === 1 && got[0] === id)
+            return ASSERTED;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "equality filter on the identity does not select exactly one record",
+            detail: `filter=${field}.eq.${id} returned ${got.length} records (${got.slice(0, 5).join(", ")})`,
+            evidence: [result.exchange],
+        });
+    },
+});
+//# sourceMappingURL=filter-equality-selects-exactly-one.js.map

package/dist/api/runtime/checks/families/filter/filter-gte-is-gt-or-eq.d.ts

@@ -0,0 +1,4 @@
+import type { Check } from "../../core/check.ts";
+import { type RangeProbe } from "./range.ts";
+export declare const filterGteIsGtOrEq: Check<RangeProbe>;
+//# sourceMappingURL=filter-gte-is-gt-or-eq.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-gte-is-gt-or-eq.js

@@ -0,0 +1,21 @@
+import { defineCheck } from "../../core/define.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { FOUNDATIONS } from "../../query/capabilities.js";
+import { assertRangeUnion, rangePlan } from "./range.js";
+export const filterGteIsGtOrEq = defineCheck({
+    plan: (ctx) => rangePlan(ctx, "gte", "gt"),
+    dependsOn: [
+        "query.filter-selects-from-whole-set",
+        ...FOUNDATIONS,
+        "filter.equality-selects-exactly-one",
+        "filter.numeric-comparison-is-numeric",
+    ],
+    id: "filter.gte-is-gt-or-eq",
+    lists: true,
+    needs: "an ordered field that allows `gte` and `gt`",
+    subjects: subjectsOf.list,
+    async run(ctx, probe) {
+        return assertRangeUnion(ctx, this.id, probe);
+    },
+});
+//# sourceMappingURL=filter-gte-is-gt-or-eq.js.map

package/dist/api/runtime/checks/families/filter/filter-ilike-is-case-insensitive.d.ts

@@ -0,0 +1,10 @@
+import type { Check } from "../../core/check.ts";
+import type { EffectiveFilterField } from "../../../../spec/query/effective.ts";
+export declare const filterIlikeIsCaseInsensitive: Check<{
+    field: EffectiveFilterField;
+    sample: string;
+    flipped: string;
+    likeTerm: Record<string, string>;
+    ilikeTerm: Record<string, string>;
+}>;
+//# sourceMappingURL=filter-ilike-is-case-insensitive.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-ilike-is-case-insensitive.js

@@ -0,0 +1,65 @@
+import { defineCheck } from "../../core/define.js";
+import { filterTerm } from "../../../../spec/conventions/filter.js";
+import { ASSERTED } from "../../../finding.js";
+import { idOf } from "../../../world/records.js";
+import { cannot, ready } from "../../core/plan.js";
+import { storedFieldsUnknown } from "../../planning/stand-down.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { canUseOp, conv, FOUNDATIONS, pageSize, q } from "../../query/capabilities.js";
+import { listAll } from "../../sets/compare.js";
+import { ids } from "../../sets/list.js";
+import { fieldsAllowing } from "./fields.js";
+export const filterIlikeIsCaseInsensitive = defineCheck({
+    plan: (ctx) => {
+        const unverified = storedFieldsUnknown(ctx);
+        if (unverified !== undefined)
+            return unverified;
+        const field = fieldsAllowing(ctx, "ilike").find((item) => canUseOp(ctx, item, "like"));
+        if (field === undefined)
+            return cannot();
+        const sample = ctx.records
+            .map((row) => row[field.field])
+            .find((value) => typeof value === "string" && /[A-Za-z]/.test(value));
+        if (sample === undefined)
+            return cannot(`a cohort value of "${field.field}" holding a letter to case-flip`);
+        const flipped = sample.replace(/[A-Za-z]/, (ch) => (ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase()));
+        const conventions = conv(ctx);
+        const likeTerm = filterTerm(conventions, { field: field.field, op: "like", value: flipped });
+        const ilikeTerm = filterTerm(conventions, { field: field.field, op: "ilike", value: flipped });
+        if (likeTerm === null || ilikeTerm === null)
+            return cannot("a filter grammar that can express like and ilike");
+        return ready({ field, flipped, ilikeTerm, likeTerm, sample });
+    },
+    dependsOn: ["query.filter-selects-from-whole-set", ...FOUNDATIONS, "filter.like-metacharacters-escaped"],
+    id: "filter.ilike-is-case-insensitive",
+    lists: true,
+    needs: "a field that allows both `ilike` and `like`, and a string with a letter",
+    subjects: subjectsOf.list,
+    async run(ctx, { field, flipped, ilikeTerm, likeTerm, sample }) {
+        const limit = pageSize(ctx);
+        const like = await listAll(ctx, { ...q(ctx, { limit }), ...likeTerm });
+        const ilike = await listAll(ctx, { ...q(ctx, { limit }), ...ilikeTerm });
+        if (like.exchange.status >= 400 || ilike.exchange.status >= 400) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "like/ilike probe was rejected");
+        }
+        if (!like.complete || !ilike.complete) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the sets are larger than a read covers");
+        }
+        const likeHits = ids(like.items, ctx.identity);
+        const ilikeHits = ids(ilike.items, ctx.identity);
+        const original = ctx.records
+            .filter((row) => row[field.field] === sample)
+            .flatMap((row) => idOf(row, ctx.identity) ?? []);
+        if (original.some((id) => ilikeHits.includes(id)) && !original.some((id) => likeHits.includes(id)))
+            return ASSERTED;
+        if (original.some((id) => ilikeHits.includes(id)) && original.some((id) => likeHits.includes(id))) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "like also matched the case-flipped value — the store may already be case-insensitive");
+        }
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "ilike is not case-insensitive relative to like",
+            detail: `ilike on ${JSON.stringify(flipped)} did not select the record whose ${field.field} is ${JSON.stringify(sample)}.`,
+            evidence: [like.exchange, ilike.exchange],
+        });
+    },
+});
+//# sourceMappingURL=filter-ilike-is-case-insensitive.js.map

package/dist/api/runtime/checks/families/filter/filter-illegal-op-rejected.d.ts

@@ -0,0 +1,17 @@
+import type { Check } from "../../core/check.ts";
+import type { EffectiveFilterField } from "../../../../spec/query/effective.ts";
+type IllegalOpProbe = {
+    field: EffectiveFilterField;
+    /** The operator as written: one outside the field's closed list, or a token the grammar lacks. */
+    op: string;
+    /** Whether the operator exists but the field's closed list leaves it out, or does not exist at all. */
+    kind: "closed" | "unknown";
+    term: Record<string, string>;
+    /** The same field under an operator it allows: the control that the field itself is accepted. */
+    control: Record<string, string>;
+};
+export declare const filterIllegalOpRejected: Check<{
+    probes: IllegalOpProbe[];
+}>;
+export {};
+//# sourceMappingURL=filter-illegal-op-rejected.d.ts.map

package/dist/api/runtime/checks/families/filter/filter-illegal-op-rejected.js

@@ -0,0 +1,103 @@
+import { defineCheck } from "../../core/define.js";
+import { canWriteFilterOp, filterSpec, filterTerm } from "../../../../spec/conventions/filter.js";
+import { renderUnknownOp } from "../../../../spec/render/filter-probe.js";
+import { opsAreClosed, opsForField } from "../../../../spec/query/field-ops.js";
+import { FILTER_OPS } from "../../../../spec/query/ops.js";
+import { cannot, ready } from "../../core/plan.js";
+import { judgeRefusal } from "../../planning/refusal.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { asTermValue, conv, pageSize, q, resolvedCaps } from "../../query/capabilities.js";
+import { ids, list } from "../../sets/list.js";
+function firstIllegalOp(ctx, field) {
+    const caps = resolvedCaps(ctx);
+    if (!opsAreClosed(field, caps))
+        return undefined;
+    const allowed = new Set(opsForField(field, caps));
+    /* An alias spells an allowed operator another way (`ne` for `neq`): it is not illegal. */
+    const permitted = (op) => {
+        const target = caps.aliases[op];
+        return allowed.has(op) || (target !== undefined && allowed.has(target));
+    };
+    return FILTER_OPS.find((op) => !permitted(op) && canWriteFilterOp(conv(ctx), op));
+}
+export const filterIllegalOpRejected = defineCheck({
+    plan: (ctx) => {
+        const probes = [];
+        for (const field of resolvedCaps(ctx).filterable) {
+            const op = firstIllegalOp(ctx, field);
+            if (op === undefined)
+                continue;
+            const sample = ctx.records.find((row) => row[field.field] != null);
+            const value = sample === undefined ? "testing-probe" : asTermValue(sample[field.field]);
+            const legal = opsForField(field, resolvedCaps(ctx)).find((allowed) => canWriteFilterOp(conv(ctx), allowed));
+            const term = filterTerm(conv(ctx), { field: field.field, op, value });
+            const control = legal === undefined
+                ? null
+                : filterTerm(conv(ctx), { field: field.field, op: legal, value });
+            if (term !== null && control !== null)
+                probes.push({ control, field, kind: "closed", op, term });
+        }
+        /* An operator token the grammar does not have at all — asked only of a declared grammar, where
+         * the token is unknown on purpose rather than because the API tester guessed the spelling. */
+        const conventions = conv(ctx);
+        if (conventions.grammarDeclared === true) {
+            for (const field of resolvedCaps(ctx).filterable) {
+                const sample = ctx.records.find((row) => row[field.field] != null);
+                const value = sample === undefined ? "testing-probe" : String(asTermValue(sample[field.field]));
+                const term = renderUnknownOp({ field: field.field, filterParam: conventions.filter, spec: filterSpec(conventions), value }, UNKNOWN_OP);
+                const control = filterTerm(conventions, { field: field.field, op: "eq", value });
+                if (term === null || control === null)
+                    continue;
+                probes.push({ control, field, kind: "unknown", op: UNKNOWN_OP, term });
+                break;
+            }
+        }
+        return probes.length === 0 ? cannot() : ready({ probes });
+    },
+    dependsOn: ["list.read-after-write", "filter.unknown-field-rejected", "error.malformed-filter-not-5xx"],
+    id: "filter.illegal-op-rejected",
+    lists: true,
+    needs: "a field with a closed operator list, or a declared filter grammar",
+    subjects: subjectsOf.list,
+    async run(ctx, { probes }) {
+        /* A refusal proves the operator is policed only when the field itself is accepted: a field
+         * the backend will not filter on at all refuses every operator, illegal or not. */
+        let picked;
+        for (const probe of probes) {
+            const control = await list(ctx, { ...q(ctx, { limit: pageSize(ctx) }), ...probe.control });
+            if (control.exchange.status < 400) {
+                picked = probe;
+                break;
+            }
+        }
+        if (picked === undefined) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "no field with a closed operator list accepted even an operator it allows");
+        }
+        const { field, kind, op, term } = picked;
+        const baseline = await list(ctx, q(ctx, { limit: pageSize(ctx) }));
+        const result = await list(ctx, { ...q(ctx, { limit: pageSize(ctx) }), ...term });
+        if (result.exchange.status >= 500) {
+            return ctx.findings.backend(this.id, ctx.entityName, {
+                summary: "an illegal filter operator produces a server error",
+                detail: `${field.field}.${op} returned ${result.exchange.status}; a rejected operator should be 4xx.`,
+                evidence: [result.exchange],
+            });
+        }
+        const refused = judgeRefusal(ctx, this.id, ["validation"], result.exchange);
+        if (refused !== null)
+            return refused;
+        const same = ids(result.items, ctx.identity).join(",") === ids(baseline.items, ctx.identity).join(",");
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "an illegal filter operator is accepted",
+            detail: `${field.field}.${op} returned ${result.exchange.status}` +
+                (same ? " with the unfiltered set, so the operator was ignored" : "") +
+                (kind === "closed"
+                    ? ". A closed operator list is a contract: anything outside it must be rejected."
+                    : ". The declared grammar has no such operator, so the term must be rejected, not dropped."),
+            evidence: [baseline.exchange, result.exchange],
+        });
+    },
+});
+/** An operator token no filter grammar has. */
+const UNKNOWN_OP = "zz";
+//# sourceMappingURL=filter-illegal-op-rejected.js.map

package/dist/api/runtime/checks/families/filter/filter-in-is-union-of-eq.d.ts

@@ -0,0 +1,10 @@
+import type { Check } from "../../core/check.ts";
+export declare const filterInIsUnionOfEq: Check<{
+    field: string;
+    a: unknown;
+    b: unknown;
+    inTerm: Record<string, string>;
+    eqA: Record<string, string>;
+    eqB: Record<string, string>;
+}>;
+//# sourceMappingURL=filter-in-is-union-of-eq.d.ts.map