@aglyn/tenant-feature-instance 1.0.0-beta.143

package/src/lib/hooks/host-collection-queries.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { documentId, limit, orderBy, query } from "firebase/firestore";
+/**
+ * ONE ordering decision for the console lists a plugin renders (AGL-2501).
+ *
+ * ## What an unordered `limit()` actually answers
+ *
+ * Firestore answers a capped query with no `orderBy` in DOCUMENT-ID order, and
+ * every collection these cards read is keyed by a generated `createResourceUid`
+ * or by `add()`. So `limit(100)` is not "the first hundred variables" — it is a
+ * pseudo-random hundred, and the rows past it are not merely unrendered, they
+ * are UNREACHABLE, because nothing shows them and nothing asks for more. A
+ * client `.sort()` over that sample is what hides it: the rows on screen run in
+ * a believable order, they are simply the wrong rows, and the ones missing
+ * leave no gap to notice.
+ *
+ * The console's site-artifact lists reached this answer first
+ * (`hostArtifactQuery`) and could not share it: an app cannot be imported from
+ * a library, so every plugin card faced the same question alone and eleven of
+ * them answered it by not ordering at all. This is that decision, where a
+ * plugin can ask for it.
+ *
+ * ## Why the walk orders on the document ID, and not on a field
+ *
+ * The obvious fix is `orderBy` on the field the list is sorted by — `name` for
+ * most of these. It cannot be used. `orderBy` matches only documents that HAVE
+ * the field, so ordering on one that any writer omits does not mis-order the
+ * list, it HIDES rows from it: a worse failure than the one being fixed, and a
+ * silent one.
+ *
+ * Every collection these cards read has such a writer:
+ *
+ *  * `/api/hosts/resources` stores an ALLOW-LIST of fields and validates none
+ *    of them for presence, so a create that sends no name produces a document
+ *    with no `name` at all.
+ *  * `/api/hosts/import` copies only the keys a bundle actually carries through
+ *    `IMPORTABLE_FIELDS` — `variables`, `functions`, `workflows` and `actions`
+ *    are all in it — so a restored document carries a name only if the exported
+ *    one had it.
+ *  * `createdAt`/`updatedAt` are no better: the resources route stamps them
+ *    server-side and an import's `cleanDoc` stamps `updatedAt` only.
+ *
+ * A document's NAME is not a field and cannot be absent, so ordering on it
+ * drops nothing and the walk is TOTAL: every row is reachable by paging, which
+ * is the property the old queries lacked. It is not insertion order — the ids
+ * are random — so no list built on it may claim to be in one. What it is is
+ * stable, complete, and the same on every load.
+ *
+ * ## Callers must not re-sort the page
+ *
+ * Re-sorting a window of an id-ordered walk by name is the same lie the old
+ * code told: rows would run in one order within a page and another across
+ * pages, and the first page would still not be the alphabetical first page. A
+ * caller that holds a whole CEILING may sort — see `ceilingedWindow` — because
+ * it is sorting the entire collection rather than a slice of it.
+ *
+ * ## Why a `Query` is accepted and not only a `CollectionReference`
+ *
+ * A list is often a FILTERED collection — one kind of conversion, one channel
+ * — and a caller holding equality predicates could not reach this ordering
+ * without rebuilding it, which is how a second, unordered `limit()` comes to
+ * be written beside the one this module exists to replace. `query()` composes
+ * onto either, and a `CollectionReference` IS a `Query`, so widening the
+ * parameter adds no behavior: the walk is still ordered on the document name
+ * and is still total over the matching documents.
+ *
+ * Equality predicates only. A range filter or a second ordering would fight
+ * the `orderBy(documentId())` applied here — Firestore requires the range
+ * field to be ordered first — and such a query fails loudly at the listener
+ * rather than quietly returning the wrong rows.
+ */ export function collectionPage(ref, pageLimit) {
+    return query(ref, orderBy(documentId()), limit(pageLimit));
+}
+/**
+ * The same ordering, for a list that is BOUNDED rather than paged.
+ *
+ * Asks for one document more than the ceiling, which is what turns "there is
+ * more than this" into a fact. Pair it with `ceilingedWindow` to drop the probe
+ * row before rendering.
+ */ export function collectionCeiling(ref, ceiling) {
+    return query(ref, orderBy(documentId()), limit(ceiling + 1));
+}
+/**
+ * A read that is bounded but not paged, and can say when it is short.
+ *
+ * Some lists cannot be windowed by document and must still be bounded: a
+ * hierarchy sliced by row separates a child from its parent, a bundle
+ * straddling a page renders twice and partial each time, a precedence list
+ * paged by ten cannot swap its tenth row with its eleventh, and a table
+ * assembled from two collections cannot dedupe across a page boundary.
+ *
+ * A bare ceiling is silent, which is the half that matters. Every consequence
+ * on those surfaces is computed from what was read, so a collection above the
+ * ceiling is drawn as a whole one with nothing to distinguish "there is no such
+ * row" from "this card did not read it".
+ *
+ * Asking for ONE document more than the ceiling turns that into a fact for the
+ * price of a single read. The probe is never handed on: a caller that rendered
+ * `ceiling + 1` rows would be describing a window it did not draw.
+ *
+ * `hasMore` in `usePagedCollection` is the same trick for a paged list, and for
+ * the same reason — a comparison against the cap is wrong exactly when the
+ * count is an even multiple of it.
+ */ export function ceilingedWindow(read, ceiling) {
+    const rows = read != null ? read : [];
+    return {
+        rows: rows.slice(0, ceiling),
+        truncated: rows.length > ceiling
+    };
+}
+
+//# sourceMappingURL=host-collection-queries.js.map

package/src/lib/hooks/host-collection-queries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/tenant/feature/instance/src/lib/hooks/host-collection-queries.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  documentId,\n  limit,\n  orderBy,\n  query,\n  type CollectionReference,\n  type Query,\n} from 'firebase/firestore'\n\n/**\n * ONE ordering decision for the console lists a plugin renders (AGL-2501).\n *\n * ## What an unordered `limit()` actually answers\n *\n * Firestore answers a capped query with no `orderBy` in DOCUMENT-ID order, and\n * every collection these cards read is keyed by a generated `createResourceUid`\n * or by `add()`. So `limit(100)` is not \"the first hundred variables\" — it is a\n * pseudo-random hundred, and the rows past it are not merely unrendered, they\n * are UNREACHABLE, because nothing shows them and nothing asks for more. A\n * client `.sort()` over that sample is what hides it: the rows on screen run in\n * a believable order, they are simply the wrong rows, and the ones missing\n * leave no gap to notice.\n *\n * The console's site-artifact lists reached this answer first\n * (`hostArtifactQuery`) and could not share it: an app cannot be imported from\n * a library, so every plugin card faced the same question alone and eleven of\n * them answered it by not ordering at all. This is that decision, where a\n * plugin can ask for it.\n *\n * ## Why the walk orders on the document ID, and not on a field\n *\n * The obvious fix is `orderBy` on the field the list is sorted by — `name` for\n * most of these. It cannot be used. `orderBy` matches only documents that HAVE\n * the field, so ordering on one that any writer omits does not mis-order the\n * list, it HIDES rows from it: a worse failure than the one being fixed, and a\n * silent one.\n *\n * Every collection these cards read has such a writer:\n *\n *  * `/api/hosts/resources` stores an ALLOW-LIST of fields and validates none\n *    of them for presence, so a create that sends no name produces a document\n *    with no `name` at all.\n *  * `/api/hosts/import` copies only the keys a bundle actually carries through\n *    `IMPORTABLE_FIELDS` — `variables`, `functions`, `workflows` and `actions`\n *    are all in it — so a restored document carries a name only if the exported\n *    one had it.\n *  * `createdAt`/`updatedAt` are no better: the resources route stamps them\n *    server-side and an import's `cleanDoc` stamps `updatedAt` only.\n *\n * A document's NAME is not a field and cannot be absent, so ordering on it\n * drops nothing and the walk is TOTAL: every row is reachable by paging, which\n * is the property the old queries lacked. It is not insertion order — the ids\n * are random — so no list built on it may claim to be in one. What it is is\n * stable, complete, and the same on every load.\n *\n * ## Callers must not re-sort the page\n *\n * Re-sorting a window of an id-ordered walk by name is the same lie the old\n * code told: rows would run in one order within a page and another across\n * pages, and the first page would still not be the alphabetical first page. A\n * caller that holds a whole CEILING may sort — see `ceilingedWindow` — because\n * it is sorting the entire collection rather than a slice of it.\n *\n * ## Why a `Query` is accepted and not only a `CollectionReference`\n *\n * A list is often a FILTERED collection — one kind of conversion, one channel\n * — and a caller holding equality predicates could not reach this ordering\n * without rebuilding it, which is how a second, unordered `limit()` comes to\n * be written beside the one this module exists to replace. `query()` composes\n * onto either, and a `CollectionReference` IS a `Query`, so widening the\n * parameter adds no behavior: the walk is still ordered on the document name\n * and is still total over the matching documents.\n *\n * Equality predicates only. A range filter or a second ordering would fight\n * the `orderBy(documentId())` applied here — Firestore requires the range\n * field to be ordered first — and such a query fails loudly at the listener\n * rather than quietly returning the wrong rows.\n */\nexport function collectionPage(\n  ref: CollectionReference | Query,\n  pageLimit: number,\n): Query {\n  return query(ref, orderBy(documentId()), limit(pageLimit))\n}\n\n/**\n * The same ordering, for a list that is BOUNDED rather than paged.\n *\n * Asks for one document more than the ceiling, which is what turns \"there is\n * more than this\" into a fact. Pair it with `ceilingedWindow` to drop the probe\n * row before rendering.\n */\nexport function collectionCeiling(\n  ref: CollectionReference | Query,\n  ceiling: number,\n): Query {\n  return query(ref, orderBy(documentId()), limit(ceiling + 1))\n}\n\n/** A ceilinged read, and whether the ceiling actually bit. */\nexport interface CeilingedWindow<T> {\n  /** At most `ceiling` rows — the probe is never among them. */\n  rows: T[]\n  /** The collection holds MORE than the ceiling. A fact, not an estimate. */\n  truncated: boolean\n}\n\n/**\n * A read that is bounded but not paged, and can say when it is short.\n *\n * Some lists cannot be windowed by document and must still be bounded: a\n * hierarchy sliced by row separates a child from its parent, a bundle\n * straddling a page renders twice and partial each time, a precedence list\n * paged by ten cannot swap its tenth row with its eleventh, and a table\n * assembled from two collections cannot dedupe across a page boundary.\n *\n * A bare ceiling is silent, which is the half that matters. Every consequence\n * on those surfaces is computed from what was read, so a collection above the\n * ceiling is drawn as a whole one with nothing to distinguish \"there is no such\n * row\" from \"this card did not read it\".\n *\n * Asking for ONE document more than the ceiling turns that into a fact for the\n * price of a single read. The probe is never handed on: a caller that rendered\n * `ceiling + 1` rows would be describing a window it did not draw.\n *\n * `hasMore` in `usePagedCollection` is the same trick for a paged list, and for\n * the same reason — a comparison against the cap is wrong exactly when the\n * count is an even multiple of it.\n */\nexport function ceilingedWindow<T>(\n  read: readonly T[] | undefined,\n  ceiling: number,\n): CeilingedWindow<T> {\n  const rows = read ?? []\n  return { rows: rows.slice(0, ceiling), truncated: rows.length > ceiling }\n}\n"],"names":["documentId","limit","orderBy","query","collectionPage","ref","pageLimit","collectionCeiling","ceiling","ceilingedWindow","read","rows","slice","truncated","length"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SACEA,UAAU,EACVC,KAAK,EACLC,OAAO,EACPC,KAAK,QAGA,qBAAoB;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEC,GACD,OAAO,SAASC,eACdC,GAAgC,EAChCC,SAAiB;IAEjB,OAAOH,MAAME,KAAKH,QAAQF,eAAeC,MAAMK;AACjD;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,kBACdF,GAAgC,EAChCG,OAAe;IAEf,OAAOL,MAAME,KAAKH,QAAQF,eAAeC,MAAMO,UAAU;AAC3D;AAUA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASC,gBACdC,IAA8B,EAC9BF,OAAe;IAEf,MAAMG,OAAOD,eAAAA,OAAQ,EAAE;IACvB,OAAO;QAAEC,MAAMA,KAAKC,KAAK,CAAC,GAAGJ;QAAUK,WAAWF,KAAKG,MAAM,GAAGN;IAAQ;AAC1E"}

package/src/lib/hooks/list-filter-constraints.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type QueryConstraint } from 'firebase/firestore';
+import type { ListFilterField, ListFilterRequest } from '@aglyn/shared-ui-jsx/const/list-filter';
+export interface ListFilterConstraintOptions {
+    /**
+     * The list's own sort field, when the caller owns it. Set it and the
+     * translator adds predicates WITHOUT an `orderBy` of its own, refusing any
+     * that would need a different one — see the server twin's `fixedOrderBy`.
+     */
+    fixedOrderBy?: string;
+    /** Sort field for a `contains`, which cannot order by its token array. */
+    containsOrderBy?: string;
+}
+/**
+ * Constraints for one declared filter, or `null` when this list cannot serve
+ * the ask.
+ *
+ * `null` means "not filtered", and the caller queries unfiltered. That is
+ * deliberate and it is the whole point: an operator the console cannot serve
+ * must not read as "no such record", which is what an empty page would say.
+ */
+export declare function listFilterConstraints(fields: readonly ListFilterField[], input: ListFilterRequest | null, options?: ListFilterConstraintOptions): QueryConstraint[] | null;
+/** How a list applies several clauses at once — see {@link listFilterPlan}. */
+export interface ListFilterPlan {
+    /** The one clause the query carries, or none. */
+    served: ListFilterRequest | null;
+    /** Its constraints, or `null` when nothing was servable. */
+    constraints: QueryConstraint[] | null;
+    /** Every other clause, matched over the rows the query returns. */
+    window: ListFilterRequest[];
+}
+/**
+ * Several clauses, split into the ONE the query serves and the rest the
+ * list matches in memory (AGL-2617).
+ *
+ * A saved view carries a list of clauses and Firestore composes predicates
+ * only through indexes nobody built for every pair of columns — and takes
+ * one array clause per query, which the scope predicate already is. So the
+ * first clause the translator can serve goes to the query, where it reaches
+ * the whole collection, and every other clause narrows the bounded window
+ * that query returns. The list says which is which in its caption: a clause
+ * that narrows only the window must not read as one that searched
+ * everything.
+ *
+ * First SERVABLE, not first listed: a reader who adds an owner clause (a
+ * facet field no query reaches) and then a name prefix should have the
+ * name searched, not the owner "served" as nothing.
+ */
+export declare function listFilterPlan(fields: readonly ListFilterField[], clauses: readonly ListFilterRequest[], options?: ListFilterConstraintOptions): ListFilterPlan;

package/src/lib/hooks/list-filter-constraints.js

@@ -0,0 +1,288 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { documentId, endAt, orderBy, startAt, Timestamp, where } from "firebase/firestore";
+/**
+ * The same filter contract, for a list that queries Firestore from the BROWSER
+ * (AGL-2501).
+ *
+ * The console's paged cards read their collections directly through
+ * `usePagedCollection` rather than through a route, so the server translator —
+ * which speaks firebase-admin — cannot serve them. This is its twin in the web
+ * SDK, reading the same `ListFilterField` declaration so a list cannot offer an
+ * operator its query will not answer.
+ *
+ * The reason it must exist at all is that these cards filtered the rows they
+ * had. A paged card holds ten; typing a name that is on page four answers "no
+ * such member", which reads as the record not existing rather than as the
+ * search not reaching it.
+ *
+ * ⚠️ A predicate here runs under SECURITY RULES, unlike the server twin. A
+ * field a rule does not permit reading is not a field this can filter on, and
+ * the failure arrives as a permission error rather than as an empty page.
+ */ /** Firestore caps `in` at 30 values. */ const IN_LIMIT = 30;
+/** A very high private-use codepoint — see the server twin for why. */ const HIGH = '\uf8ff';
+const csv = (raw)=>raw.split(',').map((entry)=>entry.trim()).filter(Boolean).slice(0, IN_LIMIT);
+const key = (value)=>value.trim().replace(/\s+/g, ' ').toLowerCase();
+/** Reverse by CODEPOINT — `split('')` tears surrogate pairs in half. */ const reversed = (value)=>[
+        ...key(value)
+    ].reverse().join('');
+const toDay = (value)=>{
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) return null;
+    const start = new Date(parsed);
+    start.setHours(0, 0, 0, 0);
+    const end = new Date(start);
+    end.setDate(end.getDate() + 1);
+    return {
+        start,
+        end
+    };
+};
+/**
+ * Constraints for one declared filter, or `null` when this list cannot serve
+ * the ask.
+ *
+ * `null` means "not filtered", and the caller queries unfiltered. That is
+ * deliberate and it is the whole point: an operator the console cannot serve
+ * must not read as "no such record", which is what an empty page would say.
+ */ export function listFilterConstraints(fields, input, options = {}) {
+    var _input_value;
+    if (!input) return null;
+    const field = fields.find((entry)=>entry.column === input.field);
+    if (!field) return null;
+    // A window-only field is matched over the loaded rows — see the flag.
+    if (field.windowOnly) return null;
+    const raw = ((_input_value = input.value) != null ? _input_value : '').trim();
+    const op = input.op;
+    const pinned = options.fixedOrderBy;
+    const sorted = (by)=>pinned ? [] : [
+            orderBy(by)
+        ];
+    const rangeAllowed = (path)=>!pinned || pinned === path;
+    if (op === 'isEmpty') {
+        // Only where writers store `null`; Firestore cannot find documents that
+        // simply LACK a field. See `presence` on the shared declaration.
+        if (field.presence !== 'nullable') return null;
+        return [
+            where(field.path, '==', null),
+            ...sorted(documentId())
+        ];
+    }
+    if (op === 'isNotEmpty') {
+        // `!=` also requires the field to EXIST, which is the meaning wanted.
+        if (field.presence === 'always') return null;
+        if (!rangeAllowed(field.path)) return null;
+        return [
+            where(field.path, '!=', null),
+            ...sorted(field.path)
+        ];
+    }
+    if (field.kind === 'boolean') {
+        if (raw !== 'true' && raw !== 'false') return null;
+        return [
+            where(field.path, '==', raw === 'true'),
+            ...sorted(documentId())
+        ];
+    }
+    if (!raw) return null;
+    const prefixRange = (path, prefix)=>prefix && rangeAllowed(path) ? [
+            orderBy(path),
+            startAt(prefix),
+            endAt(`${prefix}${HIGH}`)
+        ] : null;
+    if (field.kind === 'text') {
+        if (op === 'contains' && field.tokensPath) {
+            var _ref, _ref1, _field_containsOrderBy;
+            // An id array is matched as typed — see `verbatimTokens`.
+            const token = field.verbatimTokens ? raw : key(raw).split(' ')[0];
+            if (!token) return null;
+            const sortBy = (_ref = (_ref1 = (_field_containsOrderBy = field.containsOrderBy) != null ? _field_containsOrderBy : options.containsOrderBy) != null ? _ref1 : field.lowerPath) != null ? _ref : field.path;
+            return [
+                where(field.tokensPath, 'array-contains', token),
+                ...pinned ? [] : [
+                    orderBy(sortBy)
+                ]
+            ];
+        }
+        if (op === 'equals' && field.lowerPath) {
+            return [
+                where(field.lowerPath, '==', key(raw)),
+                ...sorted(documentId())
+            ];
+        }
+        if (op === 'startsWith' && field.lowerPath) {
+            return prefixRange(field.lowerPath, key(raw));
+        }
+        if (op === 'endsWith' && field.reversedPath) {
+            return prefixRange(field.reversedPath, reversed(raw));
+        }
+        return null;
+    }
+    if (field.kind === 'id') {
+        if (op === 'equals') {
+            return [
+                where(documentId(), '==', raw),
+                ...sorted(documentId())
+            ];
+        }
+        if (op === 'startsWith') {
+            if (pinned) return null;
+            return [
+                orderBy(documentId()),
+                startAt(raw),
+                endAt(`${raw}${HIGH}`)
+            ];
+        }
+        if (op === 'isAnyOf') {
+            const values = csv(raw);
+            return values.length ? [
+                where(documentId(), 'in', values),
+                ...sorted(documentId())
+            ] : null;
+        }
+        return null;
+    }
+    if (field.keysOf) {
+        // One key of a presence map, as the equality on its own path. A key is
+        // an identifier the writer chose; anything else could not be a path.
+        if (op !== 'equals' || !/^[A-Za-z0-9_]+$/.test(raw)) return null;
+        return [
+            where(`${field.path}.${raw}`, '==', true),
+            ...sorted(documentId())
+        ];
+    }
+    if (field.kind === 'exact') {
+        if (op === 'equals') {
+            return [
+                where(field.path, '==', raw),
+                ...sorted(documentId())
+            ];
+        }
+        if (op === 'isAnyOf') {
+            const values = csv(raw);
+            return values.length ? [
+                where(field.path, 'in', values),
+                ...sorted(documentId())
+            ] : null;
+        }
+        return null;
+    }
+    if (field.kind === 'number') {
+        const value = Number(raw);
+        if (!Number.isFinite(value)) return null;
+        if (op === '=') {
+            return [
+                where(field.path, '==', value),
+                ...sorted(documentId())
+            ];
+        }
+        const comparison = {
+            '!=': '!=',
+            '>': '>',
+            '>=': '>=',
+            '<': '<',
+            '<=': '<='
+        };
+        const operator = comparison[op];
+        if (!operator || !rangeAllowed(field.path)) return null;
+        return [
+            where(field.path, operator, value),
+            ...sorted(field.path)
+        ];
+    }
+    if (field.kind === 'date') {
+        const day = toDay(raw);
+        if (!day || !rangeAllowed(field.path)) return null;
+        const stamp = (date)=>Timestamp.fromDate(date);
+        /*
+     * `is` is a DAY, not an instant. A stored timestamp carries a time, so
+     * equality against midnight matches nothing — a date column filtered by
+     * `is` would answer "none" for every row, every time.
+     */ if (op === 'is') {
+            return [
+                ...pinned ? [] : [
+                    orderBy(field.path)
+                ],
+                startAt(stamp(day.start)),
+                endAt(stamp(day.end))
+            ];
+        }
+        const bound = {
+            after: [
+                '>=',
+                day.end
+            ],
+            onOrAfter: [
+                '>=',
+                day.start
+            ],
+            before: [
+                '<',
+                day.start
+            ],
+            onOrBefore: [
+                '<',
+                day.end
+            ]
+        };
+        const found = bound[op];
+        if (!found) return null;
+        return [
+            where(field.path, found[0], stamp(found[1])),
+            ...sorted(field.path)
+        ];
+    }
+    return null;
+}
+/**
+ * Several clauses, split into the ONE the query serves and the rest the
+ * list matches in memory (AGL-2617).
+ *
+ * A saved view carries a list of clauses and Firestore composes predicates
+ * only through indexes nobody built for every pair of columns — and takes
+ * one array clause per query, which the scope predicate already is. So the
+ * first clause the translator can serve goes to the query, where it reaches
+ * the whole collection, and every other clause narrows the bounded window
+ * that query returns. The list says which is which in its caption: a clause
+ * that narrows only the window must not read as one that searched
+ * everything.
+ *
+ * First SERVABLE, not first listed: a reader who adds an owner clause (a
+ * facet field no query reaches) and then a name prefix should have the
+ * name searched, not the owner "served" as nothing.
+ */ export function listFilterPlan(fields, clauses, options = {}) {
+    let served = null;
+    let constraints = null;
+    const window = [];
+    for (const clause of clauses){
+        if (!served) {
+            const built = listFilterConstraints(fields, clause, options);
+            if (built) {
+                served = clause;
+                constraints = built;
+                continue;
+            }
+        }
+        window.push(clause);
+    }
+    return {
+        served,
+        constraints,
+        window
+    };
+}
+
+//# sourceMappingURL=list-filter-constraints.js.map

package/src/lib/hooks/list-filter-constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/tenant/feature/instance/src/lib/hooks/list-filter-constraints.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  documentId,\n  endAt,\n  orderBy,\n  startAt,\n  Timestamp,\n  where,\n  type QueryConstraint,\n} from 'firebase/firestore'\nimport type {\n  ListFilterField,\n  ListFilterRequest,\n} from '@aglyn/shared-ui-jsx/const/list-filter'\n\n/**\n * The same filter contract, for a list that queries Firestore from the BROWSER\n * (AGL-2501).\n *\n * The console's paged cards read their collections directly through\n * `usePagedCollection` rather than through a route, so the server translator —\n * which speaks firebase-admin — cannot serve them. This is its twin in the web\n * SDK, reading the same `ListFilterField` declaration so a list cannot offer an\n * operator its query will not answer.\n *\n * The reason it must exist at all is that these cards filtered the rows they\n * had. A paged card holds ten; typing a name that is on page four answers \"no\n * such member\", which reads as the record not existing rather than as the\n * search not reaching it.\n *\n * ⚠️ A predicate here runs under SECURITY RULES, unlike the server twin. A\n * field a rule does not permit reading is not a field this can filter on, and\n * the failure arrives as a permission error rather than as an empty page.\n */\n\n/** Firestore caps `in` at 30 values. */\nconst IN_LIMIT = 30\n\n/** A very high private-use codepoint — see the server twin for why. */\nconst HIGH = '\\uf8ff'\n\nconst csv = (raw: string): string[] =>\n  raw\n    .split(',')\n    .map((entry) => entry.trim())\n    .filter(Boolean)\n    .slice(0, IN_LIMIT)\n\nconst key = (value: string): string =>\n  value.trim().replace(/\\s+/g, ' ').toLowerCase()\n\n/** Reverse by CODEPOINT — `split('')` tears surrogate pairs in half. */\nconst reversed = (value: string): string => [...key(value)].reverse().join('')\n\nconst toDay = (value: string): { start: Date; end: Date } | null => {\n  const parsed = new Date(value)\n  if (Number.isNaN(parsed.getTime())) return null\n  const start = new Date(parsed)\n  start.setHours(0, 0, 0, 0)\n  const end = new Date(start)\n  end.setDate(end.getDate() + 1)\n  return { start, end }\n}\n\nexport interface ListFilterConstraintOptions {\n  /**\n   * The list's own sort field, when the caller owns it. Set it and the\n   * translator adds predicates WITHOUT an `orderBy` of its own, refusing any\n   * that would need a different one — see the server twin's `fixedOrderBy`.\n   */\n  fixedOrderBy?: string\n  /** Sort field for a `contains`, which cannot order by its token array. */\n  containsOrderBy?: string\n}\n\n/**\n * Constraints for one declared filter, or `null` when this list cannot serve\n * the ask.\n *\n * `null` means \"not filtered\", and the caller queries unfiltered. That is\n * deliberate and it is the whole point: an operator the console cannot serve\n * must not read as \"no such record\", which is what an empty page would say.\n */\nexport function listFilterConstraints(\n  fields: readonly ListFilterField[],\n  input: ListFilterRequest | null,\n  options: ListFilterConstraintOptions = {},\n): QueryConstraint[] | null {\n  if (!input) return null\n  const field = fields.find((entry) => entry.column === input.field)\n  if (!field) return null\n  // A window-only field is matched over the loaded rows — see the flag.\n  if (field.windowOnly) return null\n  const raw = (input.value ?? '').trim()\n  const op = input.op\n  const pinned = options.fixedOrderBy\n  const sorted = (by: string | ReturnType<typeof documentId>) =>\n    pinned ? [] : [orderBy(by as never)]\n  const rangeAllowed = (path: string) => !pinned || pinned === path\n\n  if (op === 'isEmpty') {\n    // Only where writers store `null`; Firestore cannot find documents that\n    // simply LACK a field. See `presence` on the shared declaration.\n    if (field.presence !== 'nullable') return null\n    return [where(field.path, '==', null), ...sorted(documentId())]\n  }\n  if (op === 'isNotEmpty') {\n    // `!=` also requires the field to EXIST, which is the meaning wanted.\n    if (field.presence === 'always') return null\n    if (!rangeAllowed(field.path)) return null\n    return [where(field.path, '!=', null), ...sorted(field.path)]\n  }\n\n  if (field.kind === 'boolean') {\n    if (raw !== 'true' && raw !== 'false') return null\n    return [where(field.path, '==', raw === 'true'), ...sorted(documentId())]\n  }\n\n  if (!raw) return null\n\n  const prefixRange = (path: string, prefix: string) =>\n    prefix && rangeAllowed(path)\n      ? [orderBy(path), startAt(prefix), endAt(`${prefix}${HIGH}`)]\n      : null\n\n  if (field.kind === 'text') {\n    if (op === 'contains' && field.tokensPath) {\n      // An id array is matched as typed — see `verbatimTokens`.\n      const token = field.verbatimTokens ? raw : key(raw).split(' ')[0]\n      if (!token) return null\n      const sortBy = field.containsOrderBy ?? options.containsOrderBy ?? field.lowerPath ?? field.path\n      return [\n        where(field.tokensPath, 'array-contains', token),\n        ...(pinned ? [] : [orderBy(sortBy)]),\n      ]\n    }\n    if (op === 'equals' && field.lowerPath) {\n      return [where(field.lowerPath, '==', key(raw)), ...sorted(documentId())]\n    }\n    if (op === 'startsWith' && field.lowerPath) {\n      return prefixRange(field.lowerPath, key(raw))\n    }\n    if (op === 'endsWith' && field.reversedPath) {\n      return prefixRange(field.reversedPath, reversed(raw))\n    }\n    return null\n  }\n\n  if (field.kind === 'id') {\n    if (op === 'equals') {\n      return [where(documentId(), '==', raw), ...sorted(documentId())]\n    }\n    if (op === 'startsWith') {\n      if (pinned) return null\n      return [orderBy(documentId()), startAt(raw), endAt(`${raw}${HIGH}`)]\n    }\n    if (op === 'isAnyOf') {\n      const values = csv(raw)\n      return values.length\n        ? [where(documentId(), 'in', values), ...sorted(documentId())]\n        : null\n    }\n    return null\n  }\n\n  if (field.keysOf) {\n    // One key of a presence map, as the equality on its own path. A key is\n    // an identifier the writer chose; anything else could not be a path.\n    if (op !== 'equals' || !/^[A-Za-z0-9_]+$/.test(raw)) return null\n    return [where(`${field.path}.${raw}`, '==', true), ...sorted(documentId())]\n  }\n\n  if (field.kind === 'exact') {\n    if (op === 'equals') {\n      return [where(field.path, '==', raw), ...sorted(documentId())]\n    }\n    if (op === 'isAnyOf') {\n      const values = csv(raw)\n      return values.length\n        ? [where(field.path, 'in', values), ...sorted(documentId())]\n        : null\n    }\n    return null\n  }\n\n  if (field.kind === 'number') {\n    const value = Number(raw)\n    if (!Number.isFinite(value)) return null\n    if (op === '=') {\n      return [where(field.path, '==', value), ...sorted(documentId())]\n    }\n    const comparison: Record<string, '!=' | '>' | '>=' | '<' | '<='> = {\n      '!=': '!=',\n      '>': '>',\n      '>=': '>=',\n      '<': '<',\n      '<=': '<=',\n    }\n    const operator = comparison[op]\n    if (!operator || !rangeAllowed(field.path)) return null\n    return [where(field.path, operator, value), ...sorted(field.path)]\n  }\n\n  if (field.kind === 'date') {\n    const day = toDay(raw)\n    if (!day || !rangeAllowed(field.path)) return null\n    const stamp = (date: Date) => Timestamp.fromDate(date)\n    /*\n     * `is` is a DAY, not an instant. A stored timestamp carries a time, so\n     * equality against midnight matches nothing — a date column filtered by\n     * `is` would answer \"none\" for every row, every time.\n     */\n    if (op === 'is') {\n      return [\n        ...(pinned ? [] : [orderBy(field.path)]),\n        startAt(stamp(day.start)),\n        endAt(stamp(day.end)),\n      ]\n    }\n    const bound: Record<string, ['>=' | '<', Date]> = {\n      after: ['>=', day.end],\n      onOrAfter: ['>=', day.start],\n      before: ['<', day.start],\n      onOrBefore: ['<', day.end],\n    }\n    const found = bound[op]\n    if (!found) return null\n    return [\n      where(field.path, found[0], stamp(found[1])),\n      ...sorted(field.path),\n    ]\n  }\n\n  return null\n}\n\n/** How a list applies several clauses at once — see {@link listFilterPlan}. */\nexport interface ListFilterPlan {\n  /** The one clause the query carries, or none. */\n  served: ListFilterRequest | null\n  /** Its constraints, or `null` when nothing was servable. */\n  constraints: QueryConstraint[] | null\n  /** Every other clause, matched over the rows the query returns. */\n  window: ListFilterRequest[]\n}\n\n/**\n * Several clauses, split into the ONE the query serves and the rest the\n * list matches in memory (AGL-2617).\n *\n * A saved view carries a list of clauses and Firestore composes predicates\n * only through indexes nobody built for every pair of columns — and takes\n * one array clause per query, which the scope predicate already is. So the\n * first clause the translator can serve goes to the query, where it reaches\n * the whole collection, and every other clause narrows the bounded window\n * that query returns. The list says which is which in its caption: a clause\n * that narrows only the window must not read as one that searched\n * everything.\n *\n * First SERVABLE, not first listed: a reader who adds an owner clause (a\n * facet field no query reaches) and then a name prefix should have the\n * name searched, not the owner \"served\" as nothing.\n */\nexport function listFilterPlan(\n  fields: readonly ListFilterField[],\n  clauses: readonly ListFilterRequest[],\n  options: ListFilterConstraintOptions = {},\n): ListFilterPlan {\n  let served: ListFilterRequest | null = null\n  let constraints: QueryConstraint[] | null = null\n  const window: ListFilterRequest[] = []\n  for (const clause of clauses) {\n    if (!served) {\n      const built = listFilterConstraints(fields, clause, options)\n      if (built) {\n        served = clause\n        constraints = built\n        continue\n      }\n    }\n    window.push(clause)\n  }\n  return { served, constraints, window }\n}\n"],"names":["documentId","endAt","orderBy","startAt","Timestamp","where","IN_LIMIT","HIGH","csv","raw","split","map","entry","trim","filter","Boolean","slice","key","value","replace","toLowerCase","reversed","reverse","join","toDay","parsed","Date","Number","isNaN","getTime","start","setHours","end","setDate","getDate","listFilterConstraints","fields","input","options","field","find","column","windowOnly","op","pinned","fixedOrderBy","sorted","by","rangeAllowed","path","presence","kind","prefixRange","prefix","tokensPath","token","verbatimTokens","sortBy","containsOrderBy","lowerPath","reversedPath","values","length","keysOf","test","isFinite","comparison","operator","day","stamp","date","fromDate","bound","after","onOrAfter","before","onOrBefore","found","listFilterPlan","clauses","served","constraints","window","clause","built","push"],"mappings":"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"}