@theseam/ui-common 0.2.12 → 0.2.13

package/fesm2015/theseam-ui-common-graphql.js

@@ -1,7 +1,14 @@
 import { visit, BREAK } from 'graphql/language';
-import { isDevMode } from '@angular/core';
-import { hasProperty, notNullOrUndefined, isNullOrUndefined } from '@theseam/ui-common/utils';
+import * as i0 from '@angular/core';
+import { isDevMode, InjectionToken, Injectable, Optional, Inject } from '@angular/core';
+import { hasProperty, notNullOrUndefined, isNullOrUndefined, wrapIntoObservable, subscriberCount } from '@theseam/ui-common/utils';
 import { visit as visit$1, parse, BREAK as BREAK$1 } from 'graphql';
+import { Observable, EMPTY, from, ReplaySubject, of, 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 { __awaiter } from 'tslib';
+import * as i1 from 'apollo-angular';
+import { Apollo } from 'apollo-angular';
+import { NetworkStatus } from '@apollo/client/core';
 
 function containsVariable(node, variableName) {
     let found = false;
@@ -175,7 +182,7 @@ function createHintsToken(token, node, kind) {
     };
 }
 function getHintsToken(token, ast) {
-    console.log('getHintsToken', token);
+    // console.log('getHintsToken', token)
     const appliesTo = getTokenAppliesTo(token);
     if (appliesTo === null) {
         return null;
@@ -222,7 +229,7 @@ function getHintsToken(token, ast) {
 }
 function parseHints(ast) {
     const _ast = parseAst(ast);
-    console.log('_ast', _ast);
+    // console.log('_ast', _ast)
     return parseComments(_ast)
         .filter(isHintToken)
         .map(r => getHintsToken(r, _ast))
@@ -323,9 +330,552 @@ function hintsTokensContainingHint(hintsTokens, hint) {
     return hintsTokens.filter(r => r.hints.indexOf(hint) !== -1);
 }
 
+const DEFAULT_PAGE_SIZE = 20;
+function getPageInfo(datatable, defaultPageSize = DEFAULT_PAGE_SIZE) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return {
+        offset: (_b = (_a = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0,
+        pageSize: (_d = (_c = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _c === void 0 ? void 0 : _c.pageSize) !== null && _d !== void 0 ? _d : defaultPageSize,
+        limit: (_e = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _e === void 0 ? void 0 : _e.limit,
+        count: (_g = (_f = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _f === void 0 ? void 0 : _f.count) !== null && _g !== void 0 ? _g : 0
+    };
+}
+
+function createPageInfoObservable(datatable$, defaultPageSize = 20) {
+    return new Observable((subscriber) => {
+        let prev = null;
+        const handlePageInfo = (pageInfo) => {
+            if (!_isPageInfoSame(prev, pageInfo)) {
+                if (pageInfo !== null) {
+                    subscriber.next(pageInfo);
+                }
+                prev = pageInfo;
+            }
+        };
+        const dtSub = datatable$.pipe(switchMap(dt => {
+            if (!notNullOrUndefined(dt)) {
+                handlePageInfo(null);
+                return EMPTY;
+            }
+            handlePageInfo(getPageInfo(dt, defaultPageSize));
+            return dt.page.pipe(tap(p => handlePageInfo(p)));
+        })).subscribe();
+        return () => {
+            dtSub.unsubscribe();
+        };
+    });
+}
+function _isPageInfoSame(prev, curr) {
+    if ((prev === null || prev === void 0 ? void 0 : prev.offset) === (curr === null || curr === void 0 ? void 0 : curr.offset) &&
+        (prev === null || prev === void 0 ? void 0 : prev.pageSize) === (curr === null || curr === void 0 ? void 0 : curr.pageSize) &&
+        (prev === null || prev === void 0 ? void 0 : prev.limit) === (curr === null || curr === void 0 ? void 0 : curr.limit) &&
+        (prev === null || prev === void 0 ? void 0 : prev.count) === (curr === null || curr === void 0 ? void 0 : curr.count)) {
+        return true;
+    }
+    return false;
+}
+
+function resolveMapper(filterState, filterStateMappers, context) {
+    const mapper = filterStateMappers[filterState.name];
+    if (!notNullOrUndefined(mapper)) {
+        throw Error(`Mapper for filter '${filterState.name}' not found.`);
+    }
+    return wrapIntoObservable(mapper(filterState, context)).pipe(
+    // Require each mapper to complete.
+    take(1));
+}
+function resolveMappers(filterStates, filterStateMappers, context) {
+    return from(filterStates).pipe(concatMap(filterState => resolveMapper(filterState, filterStateMappers, context)), filter(notNullOrUndefined), toArray());
+}
+function mergeFilters(filters) {
+    return { or: filters };
+}
+/**
+ * Merges variable objects.
+ *
+ * NOTE: This does not try to deep merge, so if two objects define the same
+ * variable then the last object's value will be in the merged object. *In
+ * devMode an error will be thrown.*
+ */
+function mergeVariables(variableObjects) {
+    const variables = {};
+    for (const v of variableObjects) {
+        const props = Object.keys(v);
+        if (isDevMode()) {
+            for (const p of props) {
+                if (notNullOrUndefined(variables[p]) && variables[p] !== v[p]) {
+                    console.warn(`Multiple filters adding the same variable with a different result. This could cause unexpected results.`);
+                    break;
+                }
+            }
+        }
+        for (const p of props) {
+            variables[p] = v[p];
+        }
+    }
+    return variables;
+}
+function mapFilterStates(filterStates, filterStateMappers, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield resolveMappers(filterStates, filterStateMappers, context).toPromise();
+        if (results.length === 0) {
+            return null;
+        }
+        const filters = results
+            .map(r => r.filter)
+            .filter(notNullOrUndefined);
+        const variableObjs = results
+            .map(r => r.variables)
+            .filter(notNullOrUndefined);
+        return {
+            filter: mergeFilters(filters),
+            variables: mergeVariables(variableObjs)
+        };
+    });
+}
+
+/**
+ * Maps to a range that fetches the page before the current page, the current
+ * page, and the page after the current page.
+ */
+function mapPageInfo(pageInfo) {
+    const _skip = pageInfo.offset * pageInfo.pageSize;
+    const skipWithWindowOffset = _skip - pageInfo.pageSize;
+    const takeOffset = skipWithWindowOffset < 0 ? skipWithWindowOffset : 0;
+    return {
+        skip: Math.max(skipWithWindowOffset, 0),
+        take: Math.max((pageInfo.pageSize * 3) + takeOffset, 0)
+    };
+}
+
+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 => {
+            var _a, _b;
+            queryRef.setVariables(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (results.context || {})), results.pageInfo), (results.sorts.length > 0 ? { order: results.sorts } : {})), (((_a = results.filter) === null || _a === void 0 ? void 0 : _a.variables) || {})), (((_b = results.filter) === null || _b === void 0 ? void 0 : _b.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 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 })
+    // )
+}
+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([]) // .pipe(tap(v => console.log('sorts 2', v)))
+    ), 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([]) // .pipe(tap(v => console.log('filterStates 2', v)))
+    ), 
+    // 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)));
+}
+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: context
+            })));
+        })).subscribe(subscriber);
+        return () => {
+            dtSub.unsubscribe();
+            ctxSub.unsubscribe();
+        };
+    });
+}
+// function _isPagingDisabled<TData, TVariables, TRow>(queryRef: DatatableGraphQLQueryRef<TData, TVariables, TRow>): boolean {
+//   return queryRef.getQueryProcessingConfig()?.disablePaging ?? false
+// }
+
+/**
+ * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.
+ *
+ * TODO: Decide how to handle/display errors.
+ */
+class DatatableGraphQLQueryRef {
+    constructor(
+    /** Original ApolloClient's QueryRef. */
+    _queryRef, 
+    /**
+     * How long to wait before refetching from an update to the query or variables.
+     */
+    _updatesPollDelay = 500) {
+        this._queryRef = _queryRef;
+        this._updatesPollDelay = _updatesPollDelay;
+        this._variablesSubject = new BehaviorSubject({});
+        this._observingChangesSubject = new BehaviorSubject(false);
+        /**
+         * Temporary way of tracking total count when paging is disabled.
+         */
+        this._totalCount = DEFAULT_PAGE_SIZE;
+        this._variablesUpdatePending = false;
+        this._variablesSubject.next(this._queryRef.obsQuery.options.variables || {});
+        // this._getValueChanges().subscribe(v => this._logNetworkStatus(v.networkStatus))
+        this._valueChanges = defer(() => {
+            // console.log('Observing value changes')
+            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 (this._variablesUpdatePending) {
+                    this.refetch();
+                    this._variablesUpdatePending = false;
+                }
+            })).subscribe(variables => {
+                // console.log('set vars', variables)
+                this._setVariablesImmediate(variables);
+                // this.refetch()
+                this._variablesUpdatePending = false;
+            });
+            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')
+                varChangesSub.unsubscribe();
+                this._observingChanges = false;
+            }));
+        }).pipe(
+        // share()
+        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 }));
+        }));
+    }
+    get _observingChanges() { return this._observingChangesSubject.value; }
+    set _observingChanges(value) { this._observingChangesSubject.next(value); }
+    get updatesPollDelay() { return this._updatesPollDelay; }
+    get variablesUpdatePending() { return this._variablesUpdatePending; }
+    _logNetworkStatus(status) {
+        switch (status) {
+            case NetworkStatus.loading:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Loading');
+                break;
+            case NetworkStatus.setVariables:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'SetVariables');
+                break;
+            case NetworkStatus.fetchMore:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'FetchMore');
+                break;
+            case NetworkStatus.refetch:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Refetch');
+                break;
+            case NetworkStatus.poll:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Poll');
+                break;
+            case NetworkStatus.ready:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Ready');
+                break;
+            case NetworkStatus.error:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Error');
+                break;
+            default: console.log('%cNetworkStatus: ', 'color:red', 'Unknown');
+        }
+    }
+    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 querySub = this._valueChanges.pipe(switchMap(result => {
+                if (result.data === undefined) {
+                    return of([]);
+                }
+                return this._resolveRowMapper(mapper(result.data)).pipe(tap(mapperResult => {
+                    var _a, _b;
+                    // console.log('mapperResult', mapperResult)
+                    if (this._needsToRequeryWithAllRecords(mapperResult)) {
+                        this.patchVariables({ take: mapperResult.totalCount });
+                    }
+                    if (hasProperty(mapperResult, 'totalCount')) {
+                        this._totalCount = mapperResult.totalCount;
+                    }
+                    // let rows = rowsBufferSubject.value || []
+                    let rows = rowsBuffer || [];
+                    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 (hasTotalCount) {
+                        if (mapperResult.totalCount !== rows.length) {
+                            rows = new Array(mapperResult.totalCount || 0);
+                        }
+                        let startIndex = (_a = this.getVariables().skip) !== null && _a !== void 0 ? _a : 0;
+                        if ((_b = this.getQueryProcessingConfig()) === null || _b === void 0 ? void 0 : _b.disablePaging) {
+                            startIndex = 0;
+                        }
+                        // Insert rows into buffer location.
+                        rows.splice(startIndex, mapperResult.rows.length, ...mapperResult.rows);
+                        rows = [...rows];
+                    }
+                    else {
+                        rows = [...mapperResult.rows];
+                    }
+                    rowsBuffer = rows;
+                    rowsBufferSubject.next(rows);
+                }));
+            })).subscribe();
+            const rowsSub = rowsBufferSubject.subscribe(subscriber);
+            return () => {
+                // console.log('unsub')
+                querySub.unsubscribe();
+                rowsSub.unsubscribe();
+                rowsBufferSubject.next([]);
+                rowsBufferSubject.complete();
+            };
+        });
+    }
+    _needsToRequeryWithAllRecords(data) {
+        var _a;
+        if (!((_a = this.getQueryProcessingConfig()) === null || _a === void 0 ? void 0 : _a.disablePaging)) {
+            return false;
+        }
+        return hasProperty(data, 'totalCount') &&
+            hasProperty(data, 'rows') &&
+            Array.isArray(data.rows) &&
+            data.totalCount > data.rows.length &&
+            this._totalCount !== data.totalCount;
+    }
+    _resolveRowMapper(mapperReturn) {
+        if (isObservable(mapperReturn)) {
+            return mapperReturn.pipe(take(1));
+        }
+        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) {
+        const _vars = this._withVariableOverrides(variables);
+        return this._queryRef.setVariables(_vars || {});
+    }
+    _patchVariablesImmediate(variables) {
+        const _variables = Object.assign(Object.assign({}, this.getVariables()), variables);
+        const _vars = this._withVariableOverrides(_variables);
+        return this._queryRef.setVariables(_vars || {});
+    }
+    setVariables(variables) {
+        this._variablesSubject.next(variables);
+        if (!this._observingChanges) {
+            this._setVariablesImmediate(variables);
+        }
+    }
+    patchVariables(variables) {
+        const _variables = Object.assign(Object.assign({}, this.getVariables()), variables);
+        this._variablesSubject.next(_variables);
+        if (!this._observingChanges) {
+            this._setVariablesImmediate(_variables);
+        }
+    }
+    refetch(variables) {
+        const _vars = this._withVariableOverrides(variables);
+        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.
+            this.setVariables(this.getVariables());
+        }
+    }
+    getOptions() {
+        return this._queryRef.obsQuery.options;
+    }
+    getQueryProcessingConfig() {
+        var _a, _b;
+        return (_b = (_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.context) === null || _b === void 0 ? void 0 : _b.queryProcessingConfig;
+    }
+    _withVariableOverrides(variables) {
+        var _a, _b;
+        if (!notNullOrUndefined(variables) && !((_a = this.getQueryProcessingConfig()) === null || _a === void 0 ? void 0 : _a.disablePaging)) {
+            return undefined;
+        }
+        const _vars = Object.assign({}, (variables || {}));
+        if ((_b = this.getQueryProcessingConfig()) === null || _b === void 0 ? void 0 : _b.disablePaging) {
+            _vars.take = this._totalCount;
+        }
+        return _vars;
+    }
+}
+
+const DATATABLE_GRAPHQL_SERVICE_CONFIG = new InjectionToken('DATATABLE_GRAPHQL_SERVICE_CONFIG');
+const _CONFIG_DEFAULTS = {
+    pollingIntervalTime: 1 * 60 * 1000
+};
+class DatatableGraphqlService {
+    constructor(_apollo, _config) {
+        this._apollo = _apollo;
+        this._config = Object.assign(Object.assign({}, _CONFIG_DEFAULTS), (_config || {}));
+    }
+    watchQuery(options, queryProcessingConfig) {
+        var _a;
+        const _options = Object.assign(Object.assign(Object.assign({ useInitialLoading: true }, _CONFIG_DEFAULTS), { pollInterval: this._config.pollingIntervalTime }), options);
+        if (queryProcessingConfig) {
+            _options.context = Object.assign(Object.assign({}, (_options.context || {})), { queryProcessingConfig: Object.assign(Object.assign({}, (((_a = _options.context) === null || _a === void 0 ? void 0 : _a.queryProcessingConfig) || {})), queryProcessingConfig) });
+        }
+        const queryRef = this._apollo.watchQuery(_options);
+        return new DatatableGraphQLQueryRef(queryRef);
+    }
+}
+DatatableGraphqlService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DatatableGraphqlService_Factory() { return new DatatableGraphqlService(i0.ɵɵinject(i1.Apollo), i0.ɵɵinject(DATATABLE_GRAPHQL_SERVICE_CONFIG, 8)); }, token: DatatableGraphqlService, providedIn: "root" });
+DatatableGraphqlService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+DatatableGraphqlService.ctorParameters = () => [
+    { type: Apollo },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DATATABLE_GRAPHQL_SERVICE_CONFIG,] }] }
+];
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, containsVariable, createHintsToken, getHintsToken, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, isCommentToken, isHintToken, isInlineComment, parseAst, parseComments, parseHints, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, toGQL };
+export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DatatableGraphQLQueryRef, DatatableGraphqlService, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, containsVariable, createHintsToken, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, isCommentToken, isHintToken, isInlineComment, mapFilterStates, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, toGQL };
 //# sourceMappingURL=theseam-ui-common-graphql.js.map