@theseam/ui-common 1.0.0-beta.9 → 1.0.1-beta.7

package/fesm2022/theseam-ui-common-graphql.mjs

@@ -1,16 +1,78 @@
+import { ApolloLink, NetworkStatus, Observable as Observable$1 } from '@apollo/client/core';
+import { print, visit as visit$1, parse, BREAK as BREAK$1, parseValue, graphqlSync, buildSchema } from 'graphql';
+import { hasProperty, notNullOrUndefined, isNullOrUndefined, withoutProperty, wrapIntoObservable, withoutProperties } from '@theseam/ui-common/utils';
 import { visit, BREAK } from 'graphql/language';
 import * as i0 from '@angular/core';
 import { isDevMode, InjectionToken, Optional, Inject, Injectable, EventEmitter } from '@angular/core';
-import { hasProperty, notNullOrUndefined, isNullOrUndefined, wrapIntoObservable, subscriberCount, withoutProperty } from '@theseam/ui-common/utils';
-import { visit as visit$1, parse, BREAK as BREAK$1, graphqlSync, print, parseValue, buildSchema } from 'graphql';
-import { Observable, EMPTY, from, of, ReplaySubject, combineLatest, BehaviorSubject, defer, Subject, isObservable } from 'rxjs';
-import { switchMap, tap, take, concatMap, filter, toArray, map, shareReplay, startWith, distinctUntilChanged, skip, auditTime, finalize } from 'rxjs/operators';
-import { NetworkStatus, ApolloLink, Observable as Observable$1 } from '@apollo/client/core';
+import { Observable, EMPTY, merge, from, defer, of, combineLatest, Subscription, Subject, BehaviorSubject, isObservable } from 'rxjs';
+import { switchMap, auditTime, map, tap, take, concatMap, filter, toArray, distinctUntilChanged, finalize, catchError, shareReplay, startWith, skip } from 'rxjs/operators';
 import * as i1 from 'apollo-angular';
-import { gql, APOLLO_OPTIONS } from 'apollo-angular';
+import { gql, provideApollo } from 'apollo-angular';
 import { THESEAM_COLUMNS_DATA_FILTER_DATE_TEXT_SEARCH_TYPES, getFormattedDateForComparison, THESEAM_COLUMNS_DATA_FILTER_DATE_RANGE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_TEXT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_RANGE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_TEXT_TEXT_SEARCH_TYPES } from '@theseam/ui-common/datatable';
 import { concat, InMemoryCache } from '@apollo/client';
 
+/**
+ * Wraps an Apollo link and logs the operation state immediately before and
+ * after the wrapped link processes it.
+ *
+ * Useful for inspecting what `queryProcessingLink` does to a query:
+ *
+ * ```ts
+ * link: concat(
+ *   logQueryLink(queryProcessingLink),
+ *   httpLink,
+ * )
+ * ```
+ *
+ * The output uses `console.log` with optional CSS styles so each snapshot
+ * is easy to distinguish in the browser console. Tree-shaking will remove
+ * this from production builds when it is not imported.
+ */
+function logQueryLink(inner, options) {
+    const beforeStyles = options?.beforeStyles ?? 'color: cyan';
+    const afterStyles = options?.afterStyles ?? 'color: limegreen';
+    const beforeLink = new ApolloLink((operation, forward) => {
+        // eslint-disable-next-line no-console
+        console.log(`%c~~~BEFORE\n${print(operation.query)}\n${JSON.stringify(operation.variables, null, 2)}`, beforeStyles);
+        return forward(operation);
+    });
+    const afterLink = new ApolloLink((operation, forward) => {
+        // eslint-disable-next-line no-console
+        console.log(`%c~~~AFTER\n${print(operation.query)}\n${JSON.stringify(operation.variables, null, 2)}`, afterStyles);
+        return forward(operation);
+    });
+    return ApolloLink.from([beforeLink, inner, afterLink]);
+}
+
+class GQLDirection {
+    direction;
+    constructor(direction) {
+        this.direction = direction;
+    }
+    static ASC = new GQLDirection('ASC');
+    static DESC = new GQLDirection('DESC');
+}
+
+var HintsKind;
+(function (HintsKind) {
+    HintsKind["OperationDefinition"] = "OperationDefinition";
+    HintsKind["Field"] = "Field";
+    HintsKind["VariableDefinition"] = "VariableDefinition";
+    HintsKind["Variable"] = "Variable";
+    HintsKind["Argument"] = "Argument";
+})(HintsKind || (HintsKind = {}));
+
+const DEFAULT_TO_REMOVE_ON_UNDEFINED = ['where', 'order'];
+
+class GQLVariable {
+    name;
+    type;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+}
+
 function containsVariable(node, variableName) {
     let found = false;
     visit(node, {
@@ -101,35 +163,6 @@ function parseComments(ast) {
     return comments;
 }
 
-class GQLDirection {
-    direction;
-    constructor(direction) {
-        this.direction = direction;
-    }
-    static ASC = new GQLDirection('ASC');
-    static DESC = new GQLDirection('DESC');
-}
-
-var HintsKind;
-(function (HintsKind) {
-    HintsKind["OperationDefinition"] = "OperationDefinition";
-    HintsKind["Field"] = "Field";
-    HintsKind["VariableDefinition"] = "VariableDefinition";
-    HintsKind["Variable"] = "Variable";
-    HintsKind["Argument"] = "Argument";
-})(HintsKind || (HintsKind = {}));
-
-const DEFAULT_TO_REMOVE_ON_UNDEFINED = ['where', 'order'];
-
-class GQLVariable {
-    name;
-    type;
-    constructor(name, type) {
-        this.name = name;
-        this.type = type;
-    }
-}
-
 const HINT_PREFIX_REGEX = /^\s*@gql-hint:.+/;
 const HINT_NAMES_CAPTURE_REGEX = /^\s*@gql-hint:([a-zA-z-\d\s]+)$/;
 /**
@@ -294,6 +327,23 @@ function removeVariable(query, variableName) {
 // type-safe one, but that is becoming surprisingly harder to find than I
 // expected for GraphQL.
 function toGQL(json) {
+    // Handle primitive top-level values so callers can pass non-objects (e.g.
+    // when inlining a String or Int variable directly into a query argument).
+    if (json === null || json === undefined) {
+        return 'null';
+    }
+    if (typeof json === 'string') {
+        return `"${json}"`;
+    }
+    if (typeof json === 'number' || typeof json === 'boolean') {
+        return `${json}`;
+    }
+    if (json instanceof GQLDirection) {
+        return `${json.direction}`;
+    }
+    if (Array.isArray(json)) {
+        return `[${json.map((v) => toGQL(v)).join(',')}]`;
+    }
     const props = Object.keys(json).map((prop) => {
         const value = json[prop];
         let resultValue;
@@ -329,6 +379,215 @@ function hintsTokensContainingHint(hintsTokens, hint) {
     return hintsTokens.filter((r) => r.hints.indexOf(hint) !== -1);
 }
 
+/**
+ * Inlines the variable's current value directly into the query AST and removes
+ * the variable definition from the parameter list. The variable is also
+ * removed from the operation's variables map so it is not sent to the server.
+ *
+ * Applies to VariableDefinition (comment above the `$var` in the parameter
+ * list) or Variable (inline comment beside a `$var` usage in the query body).
+ */
+const inlineVariableTransformer = (operation, hintsToken) => {
+    let varName = null;
+    if (hintsToken.kind === HintsKind.VariableDefinition) {
+        varName = hintsToken.node.variable.name.value;
+    }
+    else if (hintsToken.kind === HintsKind.Variable) {
+        varName = hintsToken.node.name.value;
+    }
+    if (varName === null) {
+        return operation;
+    }
+    const varValue = operation.variables[varName];
+    const newVariables = withoutProperty(operation.variables, varName);
+    let query = removeVariableDefinition(operation.query, varName);
+    query = inlineVariable(query, varName, parseValue(toGQL(varValue)));
+    return { query, variables: newVariables };
+};
+
+/**
+ * Removes every variable from the query that is null or undefined in the
+ * operation's variables map. Both the variable definition (from the parameter
+ * list) and any argument usages in the query body are removed so the resulting
+ * document remains valid.
+ */
+const removeNotDefinedTransformer = (operation, hintsToken) => {
+    const operationNode = hintsToken.node;
+    const undefinedVarNames = (operationNode.variableDefinitions ?? [])
+        .filter((varDef) => isNullOrUndefined(operation.variables[varDef.variable.name.value]))
+        .map((varDef) => varDef.variable.name.value);
+    let query = operation.query;
+    for (const varName of undefinedVarNames) {
+        query = removeVariable(query, varName);
+    }
+    return { query, variables: operation.variables };
+};
+
+/**
+ * Maps variable value to gql and inlines it into the query.
+ */
+const inlineVariableHintDef = {
+    name: 'inline-variable',
+    appliesTo: [HintsKind.Variable, HintsKind.VariableDefinition],
+    transformer: inlineVariableTransformer,
+};
+
+/**
+ * Remove the variable from the query if it is not defined in the operation
+ * variables.
+ */
+const removeNotDefinedHintDef = {
+    name: 'remove-not-defined',
+    appliesTo: [HintsKind.OperationDefinition],
+    transformer: removeNotDefinedTransformer,
+};
+
+// /**
+//  * Remove the variable from the query if it is not defined in the operation
+//  * variables.
+//  *
+//  * Applies to: OperationDefinition
+//  */
+// export const GQL_HINT_REMOVE_NOT_DEFINED = 'remove-not-defined'
+// /**
+//  * Maps variable value to gql and inlines it into the query.
+//  *
+//  * Applies to: Variable, VariableDefinition
+//  */
+// export const GQL_HINT_INLINE_VARIABLE = 'inline-variable'
+// /**
+//  * Remove variable definition from the query if it is not used by the operation.
+//  *
+//  * Applies to: VariableDefinition
+//  */
+// // export const GQL_HINT_REMOVE_IF_NOT_USED = 'remove-if-not-used'
+// export const GQL_HINTS = [
+//   // GQL_HINT_REMOVE_IF_NOT_USED,
+//   GQL_HINT_REMOVE_NOT_DEFINED,
+//   GQL_HINT_INLINE_VARIABLE
+// ]
+
+/**
+ * Apollo link that transforms GraphQL operations before they are sent.
+ *
+ * Two mechanisms are supported and can be combined freely:
+ *
+ * **Hint-based** — place `# @gql-hint: <name>` comments directly in the query.
+ * Supported hints:
+ * - `remove-not-defined` on the operation definition: removes every variable
+ *   whose value is null/undefined (definition + argument usage).
+ * - `inline-variable` on a variable definition or usage: substitutes the
+ *   variable's current value directly into the query AST and removes it from
+ *   the variables map.
+ *
+ * **Config-based** — pass a `QueryProcessingConfig` via Apollo context under
+ * the key `queryProcessingConfig`. Supported options:
+ * - `variables.removeIfNotDefined`: remove named variables when null/undefined.
+ * - `variables.removeIfNotUsed`: remove named variable definitions when the
+ *   variable is not referenced anywhere in the (possibly already-transformed)
+ *   query body.
+ * - `variables.inline`: inline named variables into the query AST.
+ *
+ * Hints are applied first, then config-based processing.
+ */
+const queryProcessingLink = new ApolloLink((operation, forward) => {
+    const context = operation.getContext();
+    const queryProcessingConfig = context.queryProcessingConfig ?? {};
+    // Reparse to ensure token/comment info is present for hint parsing.
+    let _ast = parseAst(operation.query);
+    const rules = parseHints(_ast);
+    // ---- Hint: remove-not-defined ----------------------------------------
+    for (const hintsToken of hintsTokensContainingHint(rules, removeNotDefinedHintDef.name)) {
+        const result = removeNotDefinedHintDef.transformer({ query: _ast, variables: operation.variables }, hintsToken);
+        _ast = result.query;
+        operation.variables = result.variables;
+    }
+    // ---- Hint: inline-variable --------------------------------------------
+    for (const hintsToken of hintsTokensContainingHint(rules, inlineVariableHintDef.name)) {
+        const result = inlineVariableHintDef.transformer({ query: _ast, variables: operation.variables }, hintsToken);
+        _ast = result.query;
+        operation.variables = result.variables;
+    }
+    // ---- Config: removeIfNotDefined ---------------------------------------
+    for (const varName of queryProcessingConfig?.variables?.removeIfNotDefined ??
+        []) {
+        if (isNullOrUndefined(operation.variables[varName])) {
+            _ast = removeVariable(_ast, varName);
+        }
+    }
+    // ---- Config: removeIfNotUsed -----------------------------------------
+    // Intentionally runs after removeIfNotDefined so that variables which were
+    // only referenced inside another (now-removed) variable can be cleaned up.
+    for (const varName of queryProcessingConfig?.variables?.removeIfNotUsed ??
+        []) {
+        if (!containsVariable(_ast, varName)) {
+            _ast = removeVariable(_ast, varName);
+        }
+    }
+    // ---- Config: inline --------------------------------------------------
+    for (const varName of queryProcessingConfig?.variables?.inline ?? []) {
+        const varValue = operation.variables[varName];
+        operation.variables = withoutProperty(operation.variables, varName);
+        _ast = removeVariableDefinition(_ast, varName);
+        _ast = inlineVariable(_ast, varName, parseValue(toGQL(varValue)));
+    }
+    operation.query = _ast;
+    return forward(operation);
+});
+
+/**
+ * Creates a {@link SortsMapper} from a declarative field-name map.
+ *
+ * Each key must correspond to a datatable column `prop` value. The value
+ * controls how that column's sort is translated to a GQL sort object:
+ *
+ * - `string`   – emits `{ [gqlField]: 'ASC' | 'DESC' }`
+ * - `null`     – column is not sortable; the sort item is dropped
+ * - `function` – called with `(prop, context)` and may return a field
+ *                name or `null` to drop the item dynamically
+ *
+ * In dev mode an error is thrown when a sort item's `prop` is not present
+ * in the map. In production the item is silently dropped.
+ *
+ * @example
+ * // Simple static mapping
+ * const mapSorts = createSortsMapper<'id' | 'name'>({
+ *   id: 'id',
+ *   name: 'name',
+ * })
+ *
+ * @example
+ * // Dynamic mapping with context access
+ * const mapSorts = createSortsMapper<'id' | 'name' | 'computed'>({
+ *   id: 'id',
+ *   name: 'name',
+ *   computed: (prop, context) =>
+ *     context.extraVariables.useAlt ? 'altField' : prop,
+ * })
+ */
+function createSortsMapper(fieldMap) {
+    return (sorts, context) => {
+        const result = [];
+        for (const s of sorts) {
+            const prop = s?.prop;
+            if (!(prop in fieldMap)) {
+                if (isDevMode()) {
+                    throw new Error(`createSortsMapper: no mapping found for column prop "${prop}". ` +
+                        `Add an entry to the field map or set the value to null to ignore it.`);
+                }
+                continue;
+            }
+            const entry = fieldMap[prop];
+            const dir = s?.dir?.toUpperCase();
+            const gqlField = typeof entry === 'function' ? entry(prop, context) : entry;
+            if (gqlField === null)
+                continue;
+            result.push({ [gqlField]: dir });
+        }
+        return result;
+    };
+}
+
 const DEFAULT_PAGE_SIZE = 20;
 function getPageInfo(datatable, defaultPageSize = DEFAULT_PAGE_SIZE) {
     return {
@@ -357,7 +616,10 @@ function createPageInfoObservable(datatable$, defaultPageSize = 20) {
                 return EMPTY;
             }
             handlePageInfo(getPageInfo(dt, defaultPageSize));
-            return dt.page.pipe(tap((p) => handlePageInfo(p)));
+            // `page` does not emit when the page size changes (e.g. on
+            // window resize). Merging the `resize` event is a workaround.
+            const resize$ = dt.resize.pipe(auditTime(100), map(() => dt.pageInfo));
+            return merge(dt.page, resize$).pipe(tap((p) => handlePageInfo(p)));
         }))
             .subscribe();
         return () => {
@@ -387,8 +649,12 @@ function resolveMapper(filterState, filterStateMappers, context) {
 function resolveMappers(filterStates, filterStateMappers, context) {
     return from(filterStates).pipe(concatMap((filterState) => resolveMapper(filterState, filterStateMappers, context)), filter(notNullOrUndefined), toArray());
 }
+/**
+ * Combines multiple active filter results with AND so that all conditions must
+ * be satisfied simultaneously (e.g. a search filter AND a status filter).
+ */
 function mergeFilters(filters) {
-    return { or: filters };
+    return { and: filters };
 }
 /**
  * Merges variable objects.
@@ -452,180 +718,123 @@ function mapPageInfo(pageInfo) {
 }
 
 function observeRowsWithGqlInputsHandling(queryRef, rows, datatable, extraVariables, sortsMapper, filterStateMappers) {
-    return new Observable((subscriber) => {
-        const datatable$ = wrapIntoObservable(datatable);
-        const extraVariables$ = wrapIntoObservable(extraVariables);
-        const context$ = extraVariables$.pipe(map((_extraVariables) => {
-            const context = {
-                extraVariables: _extraVariables,
-            };
-            return context;
-        }), shareReplay({ bufferSize: 1, refCount: true }));
-        const datatableMappers = {
-            pageInfo: mapPageInfo,
-            sorts: sortsMapper,
-            filters: filterStateMappers,
-        };
-        const datatableResults$ = _createDatatableResultsObservable(datatable$, datatableMappers, context$);
-        const queryVariablesChanged$ = datatableResults$.pipe(tap((results) => {
-            queryRef.setVariables({
-                ...(results.context || {}),
-                ...results.pageInfo,
-                ...(results.sorts.length > 0 ? { order: results.sorts } : {}),
-                ...(results.filter?.variables || {}),
-                ...(results.filter?.filter ? { where: results.filter.filter } : {}),
-            });
-        }));
-        // const _emitSubject = new Subject<void>()
-        // const queryVarsChangedSub = queryVariablesChanged$.pipe(
-        //   switchMap(() => subscriberCount(rows, 'rows'))
-        // ).subscribe(subscriber)
-        const queryVarsChangedSub = queryVariablesChanged$.subscribe();
-        const _sub = subscriberCount(rows, 'rows').subscribe(subscriber);
-        return () => {
-            queryVarsChangedSub.unsubscribe();
-            _sub.unsubscribe();
-        };
+    const datatable$ = wrapIntoObservable(datatable);
+    const extraVariables$ = wrapIntoObservable(extraVariables);
+    // Only emit page changes past the first when paging is enabled. When paging
+    // is disabled, all data is already in the buffer so there is no need to
+    // re-query on page changes.
+    const pageInfo$ = defer(() => {
+        let firstEmit = true;
+        return createPageInfoObservable(datatable$).pipe(switchMap((pageInfo) => {
+            if (!firstEmit && _isPagingDisabled(queryRef)) {
+                return EMPTY;
+            }
+            firstEmit = false;
+            return of(pageInfo);
+        }), map(mapPageInfo));
     });
-    // const context$ = extraVariables$.pipe(
-    //   map(_extraVariables => {
-    //     const context: MapperContext = {
-    //       extraVariables: _extraVariables
-    //     }
-    //     return context
-    //   })
-    // )
-    // const datatableMappers: DatatableMappers = {
-    //   pageInfo: mapPageInfo,
-    //   sorts: sortsMapper,
-    //   filters: filterStateMappers,
-    // }
-    // const datatableResults$ = _createDatatableResultsObservable(
-    //   datatable$,
-    //   datatableMappers,
-    //   context$,
-    // )
-    // const queryVariablesChanged$ = datatableResults$.pipe(
-    //   tap(results => {
-    //     queryRef.setVariables({
-    //       ...(results.extraVariables || {}),
-    //       ...results.pageInfo,
-    //       ...(results.sorts.length > 0 ? { order: results.sorts } : {}),
-    //       ...(results.filterInfo?.variables || {}),
-    //       ...(results.filterInfo?.filter ? { where: results.filterInfo.filter } : {})
-    //     } as any)
-    //   })
-    // )
-    // const handleQueryInputs =  combineLatest([ extraVariables$, pageInfo$ ]).pipe(
-    //   switchMap(([ _extraVariables, pageInfo ]) => {
-    //     // console.log('_extraVariables, pageInfo', _extraVariables, pageInfo)
-    //     const context: MapperContext = {
-    //       extraVariables: _extraVariables
-    //     }
-    //     return combineLatest([ sorts$, filterInfo$ ]).pipe(
-    //       // map(([ sorts, filterInfo ]) => ({ extraVariables: _extraVariables, pageInfo, sorts, filterInfo }))
-    //       map(([ sorts, filterInfo ]) => {
-    //         // console.log('sorts, filterInfo', sorts, filterInfo)
-    //         return { extraVariables: _extraVariables, pageInfo, sorts, filterInfo }
-    //       })
-    //     )
-    //   }),
-    //   tap(v => {
-    //     // console.log('~~~', v)
-    //     queryRef.setVariables({
-    //       ...(v.extraVariables || {}),
-    //       ...v.pageInfo,
-    //       ...(v.sorts.length > 0 ? { order: v.sorts } : {}),
-    //       ...(v.filterInfo?.variables || {}),
-    //       ...(v.filterInfo?.filter ? { where: v.filterInfo.filter } : {})
-    //     } as any)
-    //   })
-    // )
-    // return defer(() => {
-    //   const _emitted = new Subject<void>()
-    //   const handlerSub = handleQueryInputs.pipe(
-    //     // skip(1)
-    //   // ).subscribe(() => _emitted.next())
-    //   ).subscribe(() => {
-    //     _emitted.next()
-    //   })
-    //   return _emitted.pipe(
-    //     // tap(v => {
-    //     //   console.log('emitted', v)
-    //     // }),
-    //     distinctUntilChanged(),
-    //     switchMap(() => subscriberCount(rows, 'rows')),
-    //     // tap(v => {
-    //     //   console.log('emitting rows', v)
-    //     // }),
-    //     finalize(() => handlerSub.unsubscribe())
-    //   )
-    // }).pipe(
-    //   // tap(v => {
-    //   //   console.log('rows', v)
-    //   // }),
-    //   catchError(err => {
-    //     console.error(err)
-    //     return of([] as TRow[])
-    //   }),
-    //   shareReplay({ bufferSize: 1, refCount: true })
-    // )
+    // Combines extraVariables and pageInfo, then derives sorts and filter state.
+    // auditTime(0) debounces rapid synchronous emissions (e.g. at startup) so
+    // only one setVariables call is made per event-loop turn.
+    const handleQueryInputs = combineLatest([extraVariables$, pageInfo$]).pipe(auditTime(0), switchMap(([_extraVariables, pageInfo]) => {
+        const context = { extraVariables: _extraVariables };
+        const sorts$ = _createSortsObservable(datatable$).pipe(switchMap((m) => wrapIntoObservable(sortsMapper(m, context))));
+        const filterInfo$ = _createFilterStatesObservable(datatable$).pipe(switchMap((x) => mapFilterStates(x, filterStateMappers, context)), 
+        // TODO: Remove when the datatable fixes the bug causing it to emit more than it should.
+        distinctUntilChanged((x, y) => JSON.stringify(x) === JSON.stringify(y)));
+        return combineLatest([sorts$, filterInfo$]).pipe(map(([sorts, filterInfo]) => ({
+            extraVariables: _extraVariables,
+            pageInfo,
+            sorts,
+            filterInfo,
+        })));
+    }), tap((v) => {
+        queryRef.setVariables({
+            ...(v.extraVariables || {}),
+            ...v.pageInfo,
+            ...(v.sorts.length > 0 ? { order: v.sorts } : {}),
+            ...(v.filterInfo?.variables || {}),
+            ...(v.filterInfo?.filter ? { where: v.filterInfo.filter } : {}),
+        });
+    }));
+    return defer(() => {
+        // Observe the optional refresh-button patch attached externally to the
+        // datatable instance. When the user triggers a refresh, refetch the data.
+        let refreshBtnSub = Subscription.EMPTY;
+        refreshBtnSub = datatable$
+            .pipe(switchMap((dt) => {
+            if (!dt || !dt.__refreshPatch) {
+                return EMPTY;
+            }
+            return dt.__refreshPatch.refreshTriggered.pipe(tap(() => queryRef.refetch(undefined, true)));
+        }))
+            .subscribe();
+        // Bridge query-input changes to row emissions via a Subject so that the
+        // rows observable is only subscribed once (on the first input change) and
+        // then continues to receive updates as the live query produces new data.
+        const _emitted = new Subject();
+        const handlerSub = handleQueryInputs.subscribe(() => _emitted.next(true));
+        return _emitted.pipe(distinctUntilChanged(), switchMap(() => rows), finalize(() => {
+            handlerSub.unsubscribe();
+            refreshBtnSub.unsubscribe();
+        }));
+    }).pipe(catchError((err) => {
+        // eslint-disable-next-line no-console
+        console.error(err);
+        return of([]);
+    }), shareReplay({ bufferSize: 1, refCount: true }));
 }
 function _createSortsObservable(datatable$) {
-    return datatable$.pipe(
-    // tap(v => console.log('sorts got dt', v)),
-    switchMap((dt) => dt
-        ? dt.sort.pipe(map((v) => v.sorts), startWith(dt.sorts)) // .pipe(tap(v => console.log('sorts 1', v)))
-        : of([])), shareReplay({ bufferSize: 1, refCount: true }));
+    // NOTE: There is a bug in our datatable wrapper that isn't propagating
+    // external sorting changes to the wrapped datatable component, which we observe
+    // sort events from. This workaround observes our wrapper's internal column
+    // change events, which emit all changes to columns that our datatable tracks,
+    // and reads sorts from our wrapper when externalSorting is enabled.
+    const _observeSortsWorkaround = (dt) => {
+        if (!dt._columnsAlterationsManager) {
+            // Fallback for environments (e.g. tests) where the internal manager
+            // is not present.
+            return dt.sort.pipe(map((v) => v.sorts), startWith(dt.sorts));
+        }
+        return dt._columnsAlterationsManager.changes.pipe(map(() => (dt.externalSorting ? dt._sorts : dt.sorts)), startWith(dt.externalSorting ? dt._sorts : dt.sorts));
+    };
+    return datatable$.pipe(switchMap((dt) => (dt ? _observeSortsWorkaround(dt) : of([]))), shareReplay({ bufferSize: 1, refCount: true }));
 }
 function _createFilterStatesObservable(datatable$) {
-    return datatable$.pipe(
-    // tap(v => console.log('filters got dt', v)),
-    switchMap((dt) => dt
-        ? dt.filterStates // .pipe(tap(v => console.log('filterStates 1', v)))
-        : of([])), 
-    // TODO: Remove when the datatable fixes the bug causing it to emit more than it should.
-    distinctUntilChanged((x, y) => JSON.stringify(x) === JSON.stringify(y)));
+    return datatable$.pipe(switchMap((dt) => (dt ? dt.filterStates : of([]))));
 }
-function _createDatatableResultsObservable(datatable$, mappers, context$) {
-    return new Observable((subscriber) => {
-        const datatableSubject = new ReplaySubject();
-        const dtSub = datatable$.subscribe((dt) => datatableSubject.next(dt), (err) => datatableSubject.error(err), () => datatableSubject.complete());
-        const ctxSub = context$
-            .pipe(switchMap((context) => {
-            // TODO: Decide if the disabled paging feature will be reimplemented in a way
-            // that it should be considered here. `_isPagingDisabled(queryRef)`
-            const pageInfo$ = createPageInfoObservable(datatable$).pipe(map((info) => mappers.pageInfo(info)));
-            const sorts$ = _createSortsObservable(datatable$).pipe(switchMap((m) => wrapIntoObservable(mappers.sorts(m, context))));
-            const filterInfo$ = _createFilterStatesObservable(datatable$).pipe(switchMap((x) => mapFilterStates(x, mappers.filters, context)));
-            return combineLatest([pageInfo$, sorts$, filterInfo$]).pipe(map(([pageInfo, sorts, filterInfo]) => ({
-                pageInfo,
-                sorts,
-                filter: filterInfo,
-                context,
-            })));
-        }))
-            .subscribe(subscriber);
-        return () => {
-            dtSub.unsubscribe();
-            ctxSub.unsubscribe();
-        };
-    });
+function _isPagingDisabled(queryRef) {
+    return queryRef.getQueryProcessingConfig()?.disablePaging ?? false;
 }
-// function _isPagingDisabled<TData, TVariables, TRow>(queryRef: DatatableGraphQLQueryRef<TData, TVariables, TRow>): boolean {
-//   return queryRef.getQueryProcessingConfig()?.disablePaging ?? false
-// }
 
+// `isNetworkRequestInFlight` is only exported from the ES module subpath
+// `@apollo/client/core/networkStatus`, which can't be loaded by Jest's CJS
+// transform. Reimplementing it here keeps the logic accessible in tests.
+function isNetworkRequestInFlight(networkStatus) {
+    return networkStatus ? networkStatus < NetworkStatus.ready : false;
+}
 /**
- * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.
- *
- * TODO: Decide how to handle/display errors.
+ * Maximum number of error recovery attempts before throwing.
+ */
+const MAX_ERROR_RECOVERY_ATTEMPTS = 10;
+/**
+ * Partially wraps ApolloClient's QueryRef with datatable paging, loading
+ * state, error handling, and debounced variable updates.
  */
 class DatatableGraphQLQueryRef {
     _queryRef;
     _updatesPollDelay;
+    _defaultErrorHandler;
     _variablesSubject = new BehaviorSubject({});
     _observingChangesSubject = new BehaviorSubject(false);
+    _errorSubject = new Subject();
+    /**
+     * Used to manually trigger a pending/loading state when we know a request is
+     * coming but Apollo hasn't started it yet (e.g. after setVariables resolves to
+     * a non-paging variable change while a request is already in-flight).
+     */
+    _manualPendingSubject = new BehaviorSubject(false);
+    _needToRequerySubject = new Subject();
     /**
      * Temporary way of tracking total count when paging is disabled.
      */
@@ -639,6 +848,18 @@ class DatatableGraphQLQueryRef {
     _variablesUpdatePending = false;
     _valueChanges;
     loading$;
+    /**
+     * Emits whenever the query variables change.
+     */
+    variables$ = this._variablesSubject.asObservable();
+    /**
+     * Emits when a GraphQL error occurs.
+     *
+     * If nothing is subscribed to this, the `_defaultErrorHandler` is used
+     * (if provided). Once subscribed, the subscriber is responsible for
+     * handling the error.
+     */
+    error$ = this._errorSubject.asObservable();
     get updatesPollDelay() {
         return this._updatesPollDelay;
     }
@@ -649,107 +870,167 @@ class DatatableGraphQLQueryRef {
     /** Original ApolloClient's QueryRef. */
     _queryRef, 
     /**
-     * How long to wait before refetching from an update to the query or variables.
+     * How long to wait (ms) before applying variable changes and refetching.
+     */
+    _updatesPollDelay = 500, 
+    /**
+     * Default error handler used when no subscriber is listening to `error$`.
      */
-    _updatesPollDelay = 500) {
+    _defaultErrorHandler) {
         this._queryRef = _queryRef;
         this._updatesPollDelay = _updatesPollDelay;
+        this._defaultErrorHandler = _defaultErrorHandler;
         this._variablesSubject.next(this._queryRef.obsQuery.options.variables || {});
-        // this._getValueChanges().subscribe(v => this._logNetworkStatus(v.networkStatus))
+        // Tracks whether the loading overlay should be held open until we know
+        // whether the first response will trigger a follow-up requery (e.g. when
+        // disablePaging is on and we first probe for totalCount). This prevents the
+        // loading overlay from flickering off and back on.
+        let hasEmittedTriggered = false;
+        const hasEmittedSubject = new BehaviorSubject(false);
+        const setHasEmitted = () => {
+            if (hasEmittedTriggered) {
+                return;
+            }
+            hasEmittedTriggered = true;
+            const sub = this._needToRequerySubject.pipe(take(1)).subscribe(() => {
+                hasEmittedSubject.next(true);
+                sub.unsubscribe();
+            });
+        };
         this._valueChanges = defer(() => {
-            // console.log('Observing value changes')
+            let prev;
             const varChangesSub = this._variablesSubject
                 .pipe(skip(1), tap(() => {
                 this._variablesUpdatePending = true;
             }), auditTime(this._updatesPollDelay), finalize(() => {
-                // If the query stopped being observed before setting the pending
-                // variables, set them now.
+                // If the query stopped being observed before the debounce fired,
+                // apply the pending variables now.
                 if (this._variablesUpdatePending) {
                     this.refetch();
                     this._variablesUpdatePending = false;
                 }
             }))
                 .subscribe((variables) => {
-                // console.log('set vars', variables)
                 this._setVariablesImmediate(variables);
-                // this.refetch()
+                const current = withoutProperties(this.getVariables(), [
+                    'skip',
+                    'take',
+                ]);
+                const isVarsChanged = prev === undefined ||
+                    JSON.stringify(prev) !== JSON.stringify(current);
+                prev = current;
                 this._variablesUpdatePending = false;
+                // When the non-paging variables change while Apollo is already
+                // in setVariables state, manually signal a pending load so the
+                // loading overlay doesn't disappear until the response arrives.
+                if (isVarsChanged &&
+                    this._queryRef.getCurrentResult().networkStatus ===
+                        NetworkStatus.setVariables) {
+                    this._manualPendingSubject.next(true);
+                }
             });
+            let repeatedErrors = 0;
             this._observingChanges = true;
             return this._queryRef.valueChanges.pipe(
-            // tap(v => {
-            //   console.log('v', v)
-            // }),
-            filter((v) => v.networkStatus === NetworkStatus.ready), finalize(() => {
-                // console.log('Done observing value changes')
+            // Once a response lands (not in-flight), begin tracking whether the
+            // initial load has truly completed (accounting for disablePaging requery).
+            tap((v) => !isNetworkRequestInFlight(v.networkStatus)
+                ? setHasEmitted()
+                : undefined), 
+            // Guard against infinite error loops when polling / retrying.
+            tap((v) => {
+                if (v.networkStatus === NetworkStatus.error) {
+                    repeatedErrors++;
+                    if (repeatedErrors >= MAX_ERROR_RECOVERY_ATTEMPTS) {
+                        throw Error('Max error recovery attempts reached.');
+                    }
+                }
+                else if (v.networkStatus === NetworkStatus.ready) {
+                    repeatedErrors = 0;
+                }
+            }), finalize(() => {
                 varChangesSub.unsubscribe();
                 this._observingChanges = false;
             }));
-        }).pipe(
-        // share()
-        shareReplay({ bufferSize: 1, refCount: true }));
+        }).pipe(shareReplay({ bufferSize: 1, refCount: true }));
         this.loading$ = this._observingChangesSubject.pipe(switchMap((observingChanges) => {
             if (!observingChanges) {
                 return of(false);
             }
-            return this._valueChanges.pipe(map((result) => result.loading), startWith(this._queryRef.getCurrentResult().loading), auditTime(0), shareReplay({ bufferSize: 1, refCount: true }));
-        }));
+            return this._valueChanges.pipe(map((result) => result.loading), startWith(this._queryRef.getCurrentResult().loading), tap((loading) => {
+                if (!loading) {
+                    this._manualPendingSubject.next(false);
+                }
+            }), 
+            // Swap the actual loading flag for the manual pending flag so that
+            // we can hold the loading state open when needed.
+            switchMap(() => this._manualPendingSubject), auditTime(0), shareReplay({ bufferSize: 1, refCount: true }));
+        }), 
+        // Keep loading=true until we've confirmed the first full load cycle
+        // (including any disablePaging requery).
+        switchMap((v) => hasEmittedSubject.pipe(map((hasEmitted) => (hasEmitted ? v : true)))));
     }
     rows(mapper) {
         return this._rowsObservable(mapper);
     }
     _rowsObservable(mapper) {
         return new Observable((subscriber) => {
-            // const rowsBufferSubject = new BehaviorSubject<TRow[]>([])
-            // console.log('obs _rowsObservable')
-            let rowsBuffer = [];
-            // const rowsBufferSubject = new ReplaySubject<TRow[]>()
-            const rowsBufferSubject = new Subject();
+            const rowsBufferSubject = new BehaviorSubject([]);
             const querySub = this._valueChanges
-                .pipe(switchMap((result) => {
+                .pipe(filter((result) => !isNetworkRequestInFlight(result.networkStatus)), switchMap((result) => {
                 if (result.data === undefined) {
-                    return of([]);
+                    return of();
                 }
-                return this._resolveRowMapper(mapper(result.data)).pipe(tap((mapperResult) => {
-                    // console.log('mapperResult', mapperResult)
-                    if (this._needsToRequeryWithAllRecords(mapperResult)) {
+                // Capture the skip offset *before* any variable changes that the
+                // mapper might trigger (e.g. patchVariables for disablePaging).
+                const querySkip = this._getVariablesFromQueryRef().skip;
+                const _result = this._handleResult(result);
+                return this._resolveRowMapper(mapper(_result.data)).pipe(tap((mapperResult) => {
+                    const needsToRequery = this._needsToRequeryWithAllRecords(mapperResult);
+                    if (needsToRequery) {
                         this.patchVariables({ take: mapperResult.totalCount });
                     }
+                    this._needToRequerySubject.next(needsToRequery);
                     if (hasProperty(mapperResult, 'totalCount')) {
                         this._totalCount = mapperResult.totalCount;
                     }
-                    // let rows = rowsBufferSubject.value || []
-                    let rows = rowsBuffer || [];
+                    let rows = rowsBufferSubject.value || [];
                     const hasTotalCount = mapperResult.totalCount !== undefined &&
                         mapperResult.totalCount !== null;
-                    // If the rows buffer is not the same size as the totalCount, create a
-                    // new buffer.
-                    //
-                    // TODO: Find out if this is resetting the buffer too eagerly.
-                    // ApolloClient may have a better solution.
+                    // If the rows buffer is not the same size as totalCount, create
+                    // a fresh buffer (sparse array — unfilled slots are undefined,
+                    // which is what checkRecordsHaveValue expects).
                     if (hasTotalCount) {
                         if (mapperResult.totalCount !== rows.length) {
                             rows = new Array(mapperResult.totalCount || 0);
                         }
-                        let startIndex = this.getVariables().skip ?? 0;
+                        let startIndex = querySkip ?? 0;
                         if (this.getQueryProcessingConfig()?.disablePaging) {
                             startIndex = 0;
                         }
-                        // Insert rows into buffer location.
-                        rows.splice(startIndex, mapperResult.rows.length, ...mapperResult.rows);
+                        // Insert rows into the correct buffer positions.
+                        for (let i = 0; i < mapperResult.rows.length; i++) {
+                            rows[startIndex + i] = mapperResult.rows[i];
+                        }
                         rows = [...rows];
                     }
                     else {
                         rows = [...mapperResult.rows];
                     }
-                    rowsBuffer = rows;
+                    // ngx-datatable does row lookups in a WeakMap and my assumption
+                    // is that the pre-allocated empty objects seem to be getting
+                    // recognized as the same object, so to avoid that, we add a
+                    // unique property to each row.
+                    rows = rows.map((v, i) => ({
+                        ...v,
+                        __dt_id: `row-${i}`,
+                    }));
                     rowsBufferSubject.next(rows);
                 }));
             }))
                 .subscribe();
             const rowsSub = rowsBufferSubject.subscribe(subscriber);
             return () => {
-                // console.log('unsub')
                 querySub.unsubscribe();
                 rowsSub.unsubscribe();
                 rowsBufferSubject.next([]);
@@ -757,6 +1038,28 @@ class DatatableGraphQLQueryRef {
             };
         });
     }
+    /**
+     * Reads the result and returns it unchanged if no errors.
+     *
+     * On errors: emits them via `error$` and replaces any `null` data properties
+     * with an empty collection shape `{ items: [], totalCount: 0 }` so mapper
+     * functions can run safely without special-casing the error path.
+     */
+    _handleResult(result) {
+        if (!result.errors || result.errors.length === 0)
+            return result;
+        this._emitError(result.errors);
+        const defaultDataPropValue = { items: [], totalCount: 0 };
+        const data = Object.keys(result.data).reduce((acc, key) => {
+            ;
+            acc[key] =
+                result.data[key] === null
+                    ? defaultDataPropValue
+                    : result.data[key];
+            return acc;
+        }, {});
+        return { ...result, data };
+    }
     _needsToRequeryWithAllRecords(data) {
         if (!this.getQueryProcessingConfig()?.disablePaging) {
             return false;
@@ -774,9 +1077,6 @@ class DatatableGraphQLQueryRef {
         return from(Promise.resolve(mapperReturn));
     }
     getVariables() {
-        // The types aren't accurate or Apollo has a bug, so I had to use `any`.
-        // return (this._queryRef as any).obsQuery.options.variables || {}
-        // TODO: Look into debouncing our variable setting, while still depending on Apollo for managing them.
         return this._variablesSubject.value;
     }
     _setVariablesImmediate(variables) {
@@ -807,18 +1107,20 @@ class DatatableGraphQLQueryRef {
             this._setVariablesImmediate(_variables);
         }
     }
-    refetch(variables) {
+    refetch(variables, showLoading = false) {
         const _vars = this._withVariableOverrides(variables);
+        if (showLoading) {
+            this._manualPendingSubject.next(true);
+        }
+        // NOTE: There seems to be a bug causing Apollo to not emit changes unless
+        // getCurrentResult() is called. This setTimeout is a workaround.
+        setTimeout(() => this._queryRef.getCurrentResult());
         return this._queryRef.refetch(_vars);
     }
     setQuery(query, triggerRefetch = false) {
         this._queryRef.setOptions({ query });
         if (triggerRefetch) {
-            // TODO: Consider refactoring the refetch process. I can't call Apollo's
-            // refetch directly, because I want it to share the update triggered
-            // polling delay with the setting of variables.
-            // this._queryRef.refetch(this.getVariables())
-            // Fake variables update to trigger a refetch that shares it's refetch delay.
+            // Fake a variables update to share the debounce delay with setVariables.
             this.setVariables(this.getVariables());
         }
     }
@@ -828,6 +1130,15 @@ class DatatableGraphQLQueryRef {
     getQueryProcessingConfig() {
         return this.getOptions()?.context?.queryProcessingConfig;
     }
+    /**
+     * Returns the variables that were actually sent with the last request, read
+     * directly from Apollo's observable query. This is more accurate than
+     * `_variablesSubject.value` when variables can change between the debounce
+     * firing and the response arriving.
+     */
+    _getVariablesFromQueryRef() {
+        return this._queryRef.obsQuery.variables;
+    }
     _withVariableOverrides(variables) {
         if (!notNullOrUndefined(variables) &&
             !this.getQueryProcessingConfig()?.disablePaging) {
@@ -839,6 +1150,12 @@ class DatatableGraphQLQueryRef {
         }
         return _vars;
     }
+    _emitError(error) {
+        this._errorSubject.next(error);
+        if (this._defaultErrorHandler && !this._errorSubject.observed) {
+            this._defaultErrorHandler(error);
+        }
+    }
 }
 
 const DATATABLE_GRAPHQL_SERVICE_CONFIG = new InjectionToken('DATATABLE_GRAPHQL_SERVICE_CONFIG');
@@ -874,10 +1191,10 @@ class DatatableGraphqlService {
         const queryRef = this._apollo.watchQuery(_options);
         return new DatatableGraphQLQueryRef(queryRef);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: DatatableGraphqlService, deps: [{ token: i1.Apollo }, { token: DATATABLE_GRAPHQL_SERVICE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: DatatableGraphqlService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DatatableGraphqlService, deps: [{ token: i1.Apollo }, { token: DATATABLE_GRAPHQL_SERVICE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DatatableGraphqlService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: DatatableGraphqlService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DatatableGraphqlService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1176,68 +1493,6 @@ const mapSearchTextColumnsDataFilterStateToGql = (filterState, context) => {
     return filter;
 };
 
-const inlineVariableTransformer = (operation, hintsToken) => {
-    const query = operation.query;
-    const variables = operation.variables;
-    return {
-        query,
-        variables,
-    };
-};
-
-const removeNotDefinedTransformer = (operation, hintsToken) => {
-    const query = operation.query;
-    const variables = operation.variables;
-    return {
-        query,
-        variables,
-    };
-};
-
-/**
- * Maps variable value to gql and inlines it into the query.
- */
-const inlineVariableHintDef = {
-    name: 'inline-variable',
-    appliesTo: [HintsKind.Variable, HintsKind.VariableDefinition],
-    transformer: inlineVariableTransformer,
-};
-
-/**
- * Remove the variable from the query if it is not defined in the operation
- * variables.
- */
-const removeNotDefinedHintDef = {
-    name: 'remove-not-defined',
-    appliesTo: [HintsKind.OperationDefinition],
-    transformer: removeNotDefinedTransformer,
-};
-
-// /**
-//  * Remove the variable from the query if it is not defined in the operation
-//  * variables.
-//  *
-//  * Applies to: OperationDefinition
-//  */
-// export const GQL_HINT_REMOVE_NOT_DEFINED = 'remove-not-defined'
-// /**
-//  * Maps variable value to gql and inlines it into the query.
-//  *
-//  * Applies to: Variable, VariableDefinition
-//  */
-// export const GQL_HINT_INLINE_VARIABLE = 'inline-variable'
-// /**
-//  * Remove variable definition from the query if it is not used by the operation.
-//  *
-//  * Applies to: VariableDefinition
-//  */
-// // export const GQL_HINT_REMOVE_IF_NOT_USED = 'remove-if-not-used'
-// export const GQL_HINTS = [
-//   // GQL_HINT_REMOVE_IF_NOT_USED,
-//   GQL_HINT_REMOVE_NOT_DEFINED,
-//   GQL_HINT_INLINE_VARIABLE
-// ]
-
 const baseSchemaFragment = gql `
   input ComparableInt32OperationFilterInput {
     eq: Int
@@ -1347,65 +1602,150 @@ const baseSchemaFragment = gql `
   }
 `;
 
-const _whereItemCollectionKinds = ['and', 'or'];
-function _createWhereFieldFn(fieldName) {
-    return (obj) => obj[fieldName];
-}
-function _resolveWhereField(obj, f) {
-    if (f instanceof Function) {
-        return f(obj);
+/**
+ * The set of leaf-level operator keys used by HotChocolate filter inputs
+ * (e.g. StringOperationFilterInput, ComparableInt32OperationFilterInput).
+ * Any key not in this set is treated as a field name, causing the evaluator
+ * to recurse into `value[key]`.
+ */
+const OPERATOR_KEYS = new Set([
+    'eq',
+    'neq',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'ngt',
+    'ngte',
+    'nlt',
+    'nlte',
+    'in',
+    'nin',
+    'contains',
+    'ncontains',
+    'startsWith',
+    'nstartsWith',
+    'endsWith',
+    'nendsWith',
+    'objectContains',
+]);
+function applyOperator(operator, value, operand) {
+    switch (operator) {
+        case 'eq':
+            return value === operand;
+        case 'neq':
+            return value !== operand;
+        case 'gt':
+            return value > operand;
+        case 'gte':
+            return value >= operand;
+        case 'lt':
+            return value < operand;
+        case 'lte':
+            return value <= operand;
+        // Negated comparisons — logical complements of the above
+        case 'ngt':
+            return !(value > operand); // equivalent to lte
+        case 'ngte':
+            return !(value >= operand); // equivalent to lt
+        case 'nlt':
+            return !(value < operand); // equivalent to gte
+        case 'nlte':
+            return !(value <= operand); // equivalent to gt
+        case 'in':
+            return Array.isArray(operand) && operand.includes(value);
+        case 'nin':
+            return Array.isArray(operand) && !operand.includes(value);
+        case 'contains':
+            return (typeof value === 'string' &&
+                typeof operand === 'string' &&
+                value.includes(operand));
+        case 'ncontains':
+            return (typeof value === 'string' &&
+                typeof operand === 'string' &&
+                !value.includes(operand));
+        case 'startsWith':
+            return (typeof value === 'string' &&
+                typeof operand === 'string' &&
+                value.startsWith(operand));
+        case 'nstartsWith':
+            return (typeof value === 'string' &&
+                typeof operand === 'string' &&
+                !value.startsWith(operand));
+        case 'endsWith':
+            return (typeof value === 'string' &&
+                typeof operand === 'string' &&
+                value.endsWith(operand));
+        case 'nendsWith':
+            return (typeof value === 'string' &&
+                typeof operand === 'string' &&
+                !value.endsWith(operand));
+        case 'objectContains': {
+            // Custom Seam/HotChocolate operator: convert the field value to a string
+            // and check if it contains the operand (case-insensitive, matching search UX).
+            const strValue = value == null ? '' : String(value);
+            const strOperand = operand == null ? '' : String(operand);
+            return strValue.toLowerCase().includes(strOperand.toLowerCase());
+        }
+        default:
+            throw new Error(`Unknown filter operator: "${operator}"`);
     }
-    return f;
 }
-const _eqConditionOp = (field1, field2) => (obj) => _resolveWhereField(obj, field1) === _resolveWhereField(obj, field2);
-const _neqConditionOp = (field1, field2) => (obj) => _resolveWhereField(obj, field1) !== _resolveWhereField(obj, field2);
-const _conditions = {
-    eq: _eqConditionOp,
-    neq: _neqConditionOp,
-};
-const _conditionKinds = ['eq', 'neq'];
-function _getWhereCondition(x) {
-    for (const k of _conditionKinds) {
-        // if (hasProperty(x, k)) {
-        if (x[k] !== undefined) {
-            return { condition: _conditions[k], value: x[k] };
+/**
+ * Recursively evaluates a HotChocolate-style filter against a value.
+ *
+ * Rules:
+ * - `and` array: all sub-filters must pass (AND logic)
+ * - `or` array: at least one sub-filter must pass (OR logic)
+ * - Known operator keys (`eq`, `contains`, `gt`, ...): apply the operator to
+ *   the current `value`
+ * - Any other key: treat as a field name; recurse with `value[key]` and the
+ *   nested filter
+ * - All non-`and`/`or` conditions are implicitly ANDed together
+ */
+function evaluateCondition(value, filter) {
+    if (filter === null || filter === undefined) {
+        return true;
+    }
+    if (Array.isArray(filter.and)) {
+        if (!filter.and.every((f) => evaluateCondition(value, f))) {
+            return false;
         }
     }
-    return null;
-}
-function _parseWhereItems(where) {
-    const conditions = [];
-    const keys = Object.keys(where);
-    if (keys.find((k) => _whereItemCollectionKinds.find((k2) => k === k2) !== undefined) !== undefined) {
-        // TODO: Implement
-    }
-    else {
-        for (const k of keys) {
-            const c = _getWhereCondition(where[k]);
-            if (c === null) {
-                throw Error(`Unexpected where item.`);
+    if (Array.isArray(filter.or)) {
+        if (!filter.or.some((f) => evaluateCondition(value, f))) {
+            return false;
+        }
+    }
+    for (const key of Object.keys(filter)) {
+        if (key === 'and' || key === 'or') {
+            continue;
+        }
+        if (OPERATOR_KEYS.has(key)) {
+            if (!applyOperator(key, value, filter[key])) {
+                return false;
+            }
+        }
+        else {
+            if (!evaluateCondition(value?.[key], filter[key])) {
+                return false;
             }
-            conditions.push(c.condition(_createWhereFieldFn(`${k}`), c.value));
         }
     }
-    return conditions;
+    return true;
 }
+/**
+ * Filters an array using a HotChocolate-style where clause.
+ *
+ * Top-level field conditions are implicitly ANDed. Use `and`/`or` arrays for
+ * explicit logical grouping.
+ *
+ * @example
+ * filterWhere(records, { name: { contains: 'foo' }, id: { gt: 5 } })
+ * filterWhere(records, { or: [{ name: { eq: 'a' } }, { name: { eq: 'b' } }] })
+ */
 function filterWhere(data, where) {
-    const items = _parseWhereItems(where);
-    const filteredClaims = data.filter((c) => {
-        // const idx = items.indexOf(itm => itm(c))
-        // return idx !== -1
-        let found = false;
-        for (const itm of items) {
-            const b = itm(c);
-            if (b) {
-                found = b;
-                break;
-            }
-        }
-        return found;
-    });
-    return filteredClaims;
+    return data.filter((item) => evaluateCondition(item, where));
 }
 
 function skipAndTake(data, skip, take) {
@@ -1416,18 +1756,76 @@ function skipAndTake(data, skip, take) {
     //   throw Error(`Invalid 'take' value: ${take}`)
     // }
     const tmp = [];
-    for (let i = skip; i < take + skip && i < data.length - 1; i++) {
+    for (let i = skip; i < take + skip && i < data.length; i++) {
         tmp.push(data[i]);
     }
     return tmp;
 }
 
+/**
+ * Sorts an array by a HotChocolate-style `order` argument.
+ *
+ * Earlier entries in the array take higher sort precedence. When two records
+ * are equal on all sort clauses they retain their original relative order
+ * (stable sort).
+ *
+ * Handles strings (locale-aware), numbers/dates, booleans, and null/undefined
+ * values (nulls sort last for both ASC and DESC).
+ *
+ * @example
+ * sortItems(records, [{ name: 'ASC' }, { id: 'DESC' }])
+ */
+function sortItems(items, order) {
+    if (!order || order.length === 0) {
+        return items;
+    }
+    return [...items].sort((a, b) => {
+        for (const clause of order) {
+            const entries = Object.entries(clause);
+            if (entries.length === 0) {
+                continue;
+            }
+            const [field, direction] = entries[0];
+            const aVal = a[field];
+            const bVal = b[field];
+            // Nulls always sort last regardless of direction — check before inverting.
+            const aNull = aVal == null;
+            const bNull = bVal == null;
+            if (aNull && bNull)
+                continue;
+            if (aNull)
+                return 1;
+            if (bNull)
+                return -1;
+            const comparison = _compareNonNullValues(aVal, bVal);
+            if (comparison !== 0) {
+                return direction === 'DESC' ? -comparison : comparison;
+            }
+        }
+        return 0;
+    });
+}
+function _compareNonNullValues(a, b) {
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.localeCompare(b);
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+
 function filteredResults(items, args) {
     let _items = items;
     const where = args?.where;
     if (where !== undefined) {
         _items = filterWhere(_items, where);
     }
+    const order = args?.order;
+    if (order !== undefined) {
+        _items = sortItems(_items, order);
+    }
     const totalCount = _items.length;
     const skip = args?.skip ?? 0;
     const take = args?.take ?? _items.length;
@@ -1454,6 +1852,8 @@ class MockDatatable {
     _bodyHeight = 500;
     _scrolledPosV = 0;
     page = new EventEmitter();
+    resize = new EventEmitter();
+    externalSorting = false;
     sort = new EventEmitter();
     get sorts() {
         return this._sorts;
@@ -1461,6 +1861,9 @@ class MockDatatable {
     set sorts(value) {
         this._sorts = value;
     }
+    get pageInfo() {
+        return this.ngxDatatable;
+    }
     filterStates = this._filterStatesSubject.asObservable();
     static pageDefaults(dt, defaultPageSize = 20) {
         return {
@@ -1573,7 +1976,10 @@ function checkRecordsHaveValue(arr, indices, testValueCheckProp = 'name', onlyCh
         }
         else {
             if (!onlyCheckProvidedIndices) {
-                if (notNullOrUndefined(arr[i])) {
+                const isItemDefined = notNullOrUndefined(testValueCheckProp)
+                    ? notNullOrUndefined(item?.[testValueCheckProp])
+                    : notNullOrUndefined(item);
+                if (isItemDefined) {
                     throw Error(`Record at index '${i}' should not be defined.`);
                 }
             }
@@ -1603,133 +2009,61 @@ function graphQLLink(options) {
     return new ApolloLink((operation, forward) => {
         return new Observable$1((subscriber) => {
             // console.log('graphQLLink', operation.variables)
-            const response = graphqlSync({
-                schema: options.schema,
-                source: print(operation.query),
-                rootValue: options.rootValue,
-                contextValue: operation.getContext(),
-                variableValues: operation.variables,
-                operationName: operation.operationName,
-                // fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
-                // typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
-            });
-            // console.log('graphQLLink response', response)
-            operation.setContext({ response });
-            subscriber.next(response);
-            subscriber.complete();
+            const execute = () => {
+                const response = graphqlSync({
+                    schema: options.schema,
+                    source: print(operation.query),
+                    rootValue: options.rootValue,
+                    contextValue: operation.getContext(),
+                    variableValues: operation.variables,
+                    operationName: operation.operationName,
+                    // fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+                    // typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+                });
+                // console.log('graphQLLink response', response)
+                operation.setContext({ response });
+                subscriber.next(response);
+                subscriber.complete();
+            };
+            if (options.delay && options.delay > 0) {
+                const timeoutId = setTimeout(execute, options.delay);
+                return () => clearTimeout(timeoutId);
+            }
+            execute();
             return () => { };
         });
     });
 }
 
-const queryProcessingLink = new ApolloLink((operation, forward) => {
-    // console.log('~link operation', operation)
-    const context = operation.getContext();
-    const queryProcessingConfig = context.queryProcessingConfig || {};
-    // console.log(operation.query)
-    // const rules = parseHints(operation.query)
-    let _ast = parseAst(operation.query);
-    const rules = parseHints(_ast);
-    // console.log('rules', rules)
-    operation.query = _ast;
-    const removeNotDefined = hintsTokensContainingHint(rules, removeNotDefinedHintDef.name);
-    // console.log('removeNotDefined', removeNotDefined)
-    for (const rulesToken of removeNotDefined) {
-        // _ast = removeVariableDefinitionsNotDefined(_ast, rulesToken.node as OperationDefinitionNode, operation.variables)
-        if (!removeNotDefinedHintDef.transformer) {
-            continue;
-        }
-        const result = removeNotDefinedHintDef.transformer({
-            query: operation.query,
-            variables: operation.variables,
-        }, rulesToken);
-        operation.query = result.query;
-        operation.variables = result.variables;
-    }
-    const inlineVariableRulesTokens = hintsTokensContainingHint(rules, inlineVariableHintDef.name);
-    // console.log('inlineVariableRulesTokens', inlineVariableRulesTokens)
-    for (const rulesToken of inlineVariableRulesTokens) {
-        let varName = null;
-        let varDefaultValue;
-        if (rulesToken.kind === HintsKind.VariableDefinition) {
-            varName = rulesToken.node.variable.name.value;
-            varDefaultValue = rulesToken.node.defaultValue;
-        }
-        else if (rulesToken.kind === HintsKind.Variable) {
-            varName = rulesToken.node.name.value;
-        }
-        if (varName === null) {
-            // TODO: Throw error here?
-            continue;
-        }
-        const varValue = operation.variables[varName];
-        operation.variables = withoutProperty(operation.variables, varName);
-        _ast = removeVariableDefinition(_ast, varName);
-        const varValueNode = (_ast = inlineVariable(_ast, varName, parseValue(toGQL(varValue))));
-    }
-    // const removeIfNotDefined = hintsTokensContainingHint(rules, GQL_HINT_REMOVE_IF_NOT_USED)
-    // console.log('removeIfNotDefined', removeIfNotDefined)
-    // const _operation = operation
-    // const removeIdNotDefined = (queryProcessingConfig?.variables?.removeIfNotDefined || [])
-    // for (const varName of removeIdNotDefined) {
-    //   if (isNullOrUndefined(operation.variables[varName])) {
-    //     _operation.query = removeVariable(_operation.query, varName)
-    //   }
-    // }
-    // const removeIfNotUsed = (queryProcessingConfig?.variables?.removeIfNotUsed || [])
-    // for (const varName of removeIfNotUsed) {
-    //   if (!containsVariable(_operation.query, varName)) {
-    //     _operation.query = removeVariable(_operation.query, varName)
-    //   }
-    // }
-    // const inlineVariables = (queryProcessingConfig?.variables?.inline || [])
-    // for (const varName of inlineVariables) {
-    //   const varValue = _operation.variables[varName]
-    //   _operation.variables = withoutProperty(_operation.variables, varName)
-    //   _operation.query = removeVariableDefinition(_operation.query, varName)
-    //   _operation.query = inlineVariable(_operation.query, varName, parseValue(toGQL(varValue)))
-    // }
-    operation.query = _ast;
-    return forward(operation);
-});
-
 /**
- * Creates an `APOLLO_OPTIONS` provider configured like our apps, except with
- * the Apollo HttpLink replaced with a custom GraphQL link that queries from the
- * schema and root provided. The responses to GQL queries should be the same as
- * responses from our api, but the query features are limited to common features
- * necessary for tests. Since we use a C# GraphQL api, it would be a lot of
- * overhead to use that implementation in this project's tests, but you can
- * check our `graphQLLink` to find what features have been implemented to
- * hopefully match the result our api would return.
+ * Creates Apollo providers configured like our apps, except with the Apollo
+ * HttpLink replaced with a custom GraphQL link that queries from the schema
+ * and root value provided. Responses match what our real API returns, but
+ * query features are limited to what `graphQLLink` implements.
  *
  * NOTE: This was created because `ApolloTestingModule` is very limited. We
  * mostly use queries intended to emit more than once, but `ApolloTestingModule`
  * can only emit a query response once.
  */
-function createApolloTestingProvider(schema, rootValue) {
-    return {
-        provide: APOLLO_OPTIONS,
-        useFactory: () => {
-            return {
-                cache: new InMemoryCache(),
-                link: concat(queryProcessingLink, graphQLLink({
-                    schema,
-                    rootValue,
-                })),
-                defaultOptions: {
-                    watchQuery: {
-                        fetchPolicy: 'cache-and-network',
-                        errorPolicy: 'ignore',
-                    },
-                    query: {
-                        fetchPolicy: 'network-only',
-                        errorPolicy: 'all',
-                    },
-                },
-            };
+function createApolloTestingProvider(schema, rootValue, delay) {
+    return provideApollo(() => ({
+        cache: new InMemoryCache(),
+        link: concat(queryProcessingLink, graphQLLink({
+            schema,
+            rootValue,
+            delay,
+        })),
+        defaultOptions: {
+            watchQuery: {
+                fetchPolicy: 'cache-and-network',
+                errorPolicy: 'ignore',
+            },
+            query: {
+                fetchPolicy: 'network-only',
+                errorPolicy: 'all',
+            },
         },
-    };
+    }));
 }
 
 function createSimpleGqlTestRecord(num) {
@@ -1756,6 +2090,11 @@ const simpleGqlTestSchema = buildSchema(print(gql `
       name: StringOperationFilterInput
     }
 
+    input SimpleGqlTestRecordSortInput {
+      id: SortEnumType
+      name: SortEnumType
+    }
+
     type SimpleGqlTestRecord {
       id: Int
       name: String
@@ -1765,6 +2104,7 @@ const simpleGqlTestSchema = buildSchema(print(gql `
       simpleGqlTestRecords(
         skip: Int
         take: Int
+        order: [SimpleGqlTestRecordSortInput!]
         where: SimpleGqlTestRecordFilterInput
       ): SimpleGqlTestRecordCollectionSegment
     }
@@ -1782,9 +2122,42 @@ const SIMPLE_GQL_TEST_QUERY = gql `
   query ExampleQuery(
     $skip: Int
     $take: Int
+    $order: [SimpleGqlTestRecordSortInput!]
+    $where: SimpleGqlTestRecordFilterInput
+  ) {
+    simpleGqlTestRecords(
+      skip: $skip
+      take: $take
+      order: $order
+      where: $where
+    ) {
+      items {
+        id
+        name
+      }
+      totalCount
+    }
+  }
+`;
+/**
+ * Like {@link SIMPLE_GQL_TEST_QUERY} but includes `$search: String` for use
+ * with search filters that inline a `gqlVar('search')` reference via
+ * `queryProcessingConfig.variables.inline`.
+ */
+const SIMPLE_GQL_TEST_SEARCH_QUERY = gql `
+  query ExampleQuery(
+    $skip: Int
+    $take: Int
+    $order: [SimpleGqlTestRecordSortInput!]
     $where: SimpleGqlTestRecordFilterInput
+    $search: String
   ) {
-    simpleGqlTestRecords(skip: $skip, take: $take, where: $where) {
+    simpleGqlTestRecords(
+      skip: $skip
+      take: $take
+      order: $order
+      where: $where
+    ) {
       items {
         id
         name
@@ -1798,5 +2171,5 @@ const SIMPLE_GQL_TEST_QUERY = gql `
  * Generated bundle index. Do not edit.
  */
 
-export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DEFAULT_TO_REMOVE_ON_UNDEFINED, DatatableGraphQLQueryRef, DatatableGraphqlService, GQLDirection, GQLVariable, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, HintsKind, MockDatatable, SIMPLE_GQL_TEST_QUERY, baseSchemaFragment, checkRecordsHaveValue, containsVariable, createApolloTestingProvider, createHintsToken, createSimpleGqlTestRecord, createSimpleGqlTestRoot, filterWhere, filteredResults, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, inlineVariableHintDef, inlineVariableTransformer, isCommentToken, isHintToken, isInlineComment, mapFilterStates, mapSearchDateColumnsDataFilterStateToGql, mapSearchNumericColumnsDataFilterStateToGql, mapSearchTextColumnsDataFilterStateToGql, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, removeNotDefinedHintDef, removeNotDefinedTransformer, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, simpleGqlTestSchema, skipAndTake, toGQL };
+export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DEFAULT_TO_REMOVE_ON_UNDEFINED, DatatableGraphQLQueryRef, DatatableGraphqlService, GQLDirection, GQLVariable, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, HintsKind, MAX_ERROR_RECOVERY_ATTEMPTS, MockDatatable, SIMPLE_GQL_TEST_QUERY, SIMPLE_GQL_TEST_SEARCH_QUERY, baseSchemaFragment, checkRecordsHaveValue, containsVariable, createApolloTestingProvider, createHintsToken, createSimpleGqlTestRecord, createSimpleGqlTestRoot, createSortsMapper, filterWhere, filteredResults, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, inlineVariableHintDef, inlineVariableTransformer, isCommentToken, isHintToken, isInlineComment, logQueryLink, mapFilterStates, mapSearchDateColumnsDataFilterStateToGql, mapSearchNumericColumnsDataFilterStateToGql, mapSearchTextColumnsDataFilterStateToGql, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, queryProcessingLink, removeNotDefinedHintDef, removeNotDefinedTransformer, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, simpleGqlTestSchema, skipAndTake, sortItems, toGQL };
 //# sourceMappingURL=theseam-ui-common-graphql.mjs.map