@sumaris-net/ngx-components 2.6.4-alpha3 → 2.6.4-alpha5

package/src/app/core/services/auth-guard.service.ts

@@ -0,0 +1,70 @@
+import {Inject, Injectable} from '@angular/core';
+import {ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot, UrlTree} from '@angular/router';
+import {Observable} from 'rxjs';
+import {ModalController} from '@ionic/angular';
+import {AccountService} from './account.service';
+import {ENVIRONMENT} from '../../../environments/environment.class';
+import {AppAuthModal} from '../auth/auth.modal';
+
+@Injectable({providedIn: 'root'})
+export class AuthGuardService implements CanActivate {
+
+  private readonly _debug: boolean;
+
+  constructor(private accountService: AccountService,
+              private modalCtrl: ModalController,
+              private router: Router,
+              @Inject(ENVIRONMENT) protected environment
+  ) {
+    this._debug = !environment.production;
+  }
+
+  canActivate(
+    next: ActivatedRouteSnapshot,
+    state: RouterStateSnapshot
+  ): Observable<boolean> | Promise<boolean | UrlTree> | boolean | UrlTree {
+
+    // If account not started: loop after started
+    if (!this.accountService.started) {
+      return this.accountService.ready()
+        // Iterate
+        .then(() => this.canActivate(next, state) as Promise<boolean | UrlTree>);
+    }
+
+    // Force login
+    if (!this.accountService.isLogin()) {
+      if (this._debug) console.debug('[auth-guard] Need authentication for page /' + next.url.join('/'));
+      return this.login(next)
+        .then(res => {
+          if (!res) {
+            if (this._debug) console.debug('[auth-guard] Authentication cancelled. Could not access to /' + next.url.join('/'));
+            return this.router.parseUrl('/home');
+          }
+          // Iterate
+          return this.canActivate(next, state) as Promise<boolean | UrlTree>;
+        });
+    }
+
+    if (next.data && next.data.profile && !this.accountService.hasMinProfile(next.data.profile)) {
+      if (this._debug) console.debug('[auth-guard] Not authorized access to /' + next.url.join('/') + '. Missing required profile: ' + next.data.profile);
+      return false;
+    }
+    if (this._debug) console.debug('[auth-guard] Authorized access to /' + next.url.join('/'));
+    return true;
+  }
+
+  login(next?: ActivatedRouteSnapshot): Promise<boolean> {
+    return new Promise<boolean>(async (resolve) => {
+      const modal = await this.modalCtrl.create({component: AppAuthModal, componentProps: {next}});
+      modal.onDidDismiss()
+        .then(() => {
+          if (this.accountService.isLogin()) {
+            resolve(true);
+            return;
+          }
+          resolve(false);
+        });
+      return modal.present();
+    });
+  }
+}

package/src/app/core/services/base-entity-service.class.ts

@@ -0,0 +1,598 @@
+import { Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ErrorCodes } from './errors';
+
+import { FetchPolicy, InternalRefetchQueriesInclude, MutationUpdaterFn } from '@apollo/client/core';
+import { SortDirection } from '@angular/material/sort';
+
+import { BaseGraphqlService } from './base-graphql-service.class';
+import { EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, EntityServiceListenChangesOptions, IEntitiesService, IEntityService, LoadResult } from '../../shared/services/entity-service.class';
+import { GraphqlService } from '../graphql/graphql.service';
+import { PlatformService } from './platform.service';
+import { environment } from '../../../environments/environment';
+import { Entity, EntityAsObjectOptions, EntityUtils } from './model/entity.model';
+import { chainPromises } from '../../shared/observables';
+import { isEmptyArray, isNil, isNotNil, removeEnd, toNumber } from '../../shared/functions';
+import { Directive } from '@angular/core';
+import { FetchResult } from '@apollo/client/link/core';
+import { EntityFilter, EntityFilterUtils } from './model/filter.model';
+import { DocumentNode } from 'graphql';
+
+export type MutableWatchQueriesUpdatePolicy = 'update-cache' | 'refetch-queries';
+
+export interface BaseEntityGraphqlQueries {
+  load?: any;
+  loadAll: any;
+  loadAllWithTotal?: any;
+  countAll?: any;
+}
+export interface BaseEntityGraphqlMutations {
+  save?: any;
+  delete?: any;
+  saveAll?: any;
+  deleteAll?: any;
+}
+
+export interface BaseEntityGraphqlSubscriptions {
+  listenChanges?: any;
+}
+export interface BaseEntityServiceOptions<
+  T extends Entity<any, ID>,
+  ID = number,
+  Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries,
+  M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations,
+  S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions> {
+  queries: Q;
+  mutations?: Partial<M>;
+  subscriptions?: Partial<S>;
+  equalsFn?: (e1: T, e2: T) => boolean;
+  isNewFn?: (e: T) => boolean;
+  defaultSortBy?: keyof T;
+  defaultSortDirection?: SortDirection;
+  watchQueriesUpdatePolicy?: MutableWatchQueriesUpdatePolicy;
+}
+
+export interface EntitySaveOptions {
+  refetchQueries?: ((result: FetchResult<{data: any}>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+  awaitRefetchQueries?: boolean;
+  update?: MutationUpdaterFn<{ data: any; }>;
+}
+
+
+// @dynamic
+@Directive()
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export abstract class BaseEntityService<
+  T extends Entity<T, ID>,
+  F extends EntityFilter<F, T, ID>,
+  ID = number,
+  WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions,
+  LO extends EntitiesServiceLoadOptions = EntitiesServiceLoadOptions,
+  Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries,
+  M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations,
+  S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions>
+  extends BaseGraphqlService<T, F, ID>
+  implements
+    IEntitiesService<T, F, WO>,
+    IEntityService<T, ID, LO> {
+
+  protected readonly _typename: string;
+  protected readonly _logTypeName: string;
+
+  protected readonly queries: Q;
+  protected readonly mutations: Partial<M>;
+  protected readonly subscriptions: Partial<S>;
+  protected readonly equalsFn: (e1: T, e2: T) => boolean;
+  protected readonly isNewFn: (e: T) => boolean;
+
+  protected readonly defaultSortBy: keyof T;
+  protected readonly defaultSortDirection: SortDirection;
+  protected readonly watchQueriesUpdatePolicy: MutableWatchQueriesUpdatePolicy;
+
+  protected constructor(
+    protected graphql: GraphqlService,
+    protected platform: PlatformService,
+    protected dataType: new() => T,
+    protected filterType: new() => F,
+    options: BaseEntityServiceOptions<T, ID, Q, M, S>
+  ) {
+    super(graphql, environment);
+    this.queries = options.queries;
+    this.mutations = options.mutations || <Partial<M>>{};
+    this.subscriptions = options.subscriptions || <Partial<S>>{};
+    this.equalsFn = options.equalsFn || ((e1, e2) => EntityUtils.equals(e1, e2, 'id'));
+    this.isNewFn = options.isNewFn || ((e) => EntityUtils.isNotEmpty(e, 'id'));
+    this.defaultSortBy = options.defaultSortBy || 'id';
+    this.defaultSortDirection = options.defaultSortDirection || 'asc';
+    this.watchQueriesUpdatePolicy = options.watchQueriesUpdatePolicy || 'update-cache';
+
+    const obj = new dataType();
+    this._typename = obj.__typename || 'UnknownVO';
+    this._logTypeName = removeEnd(this._typename, 'VO');
+
+    // For DEV only
+    this._debug = !environment.production;
+  }
+
+  watch(id: number, opts?: WO): Observable<T> {
+
+    if (this._debug) console.debug(this._logPrefix + `Watching ${this._logTypeName} {${id}}...`);
+
+    const variables: any = opts?.variables || { id };
+
+    const query = opts && opts.query || this.queries.load;
+    return this.graphql.watchQuery<{data: any}>({
+      query,
+      variables,
+      fetchPolicy: opts && (opts.fetchPolicy as FetchPolicy) || undefined,
+      error: {code: ErrorCodes.LOAD_DATA_ERROR, message: 'REFERENTIAL.ERROR.LOAD_DATA_ERROR'}
+    })
+      .pipe(
+        map(({data}) => (!opts || opts.toEntity !== false)
+            ? (data && this.fromObject(data))
+            : (data as T))
+      );
+  }
+
+  async load(id: ID, opts?: LO ): Promise<T> {
+
+    if (this._debug) console.debug(this._logPrefix + `Loading ${this._logTypeName} {${id}}...`);
+
+    const variables: any = opts?.variables || { id };
+
+    const query = opts?.query || this.queries.load;
+    const { data } = await this.graphql.query<{data: any}>({
+      query,
+      variables,
+      fetchPolicy: opts && (opts.fetchPolicy as FetchPolicy) || undefined,
+      error: {code: ErrorCodes.LOAD_DATA_ERROR, message: 'REFERENTIAL.ERROR.LOAD_DATA_ERROR'}
+    });
+
+    // Convert to entity
+    return (!opts || opts.toEntity !== false)
+      ? (data && this.fromObject(data))
+      : (data as T);
+  }
+
+  watchAll(offset: number,
+           size: number,
+           sortBy?: string,
+           sortDirection?: SortDirection,
+           filter?: F,
+           opts?: WO): Observable<LoadResult<T>> {
+
+    filter = this.asFilter(filter);
+
+    const variables: any = {
+      ...(opts?.variables || {}),
+      offset: offset || 0,
+      size: size || 100,
+      sortBy: sortBy || this.defaultSortBy,
+      sortDirection: sortDirection || this.defaultSortDirection,
+      filter: filter && filter.asPodObject()
+    };
+
+    let now = this._debug && Date.now();
+    if (this._debug) console.debug(this._logPrefix + `Watching ${this._logTypeName}...`, variables);
+
+    const withTotal = (!opts || opts.withTotal !== false) && this.queries.loadAllWithTotal && true;
+    const query = (opts && opts.query) // use given query
+      // Or get loadAll or loadAllWithTotal query
+      || (withTotal ? this.queries.loadAllWithTotal  : this.queries.loadAll);
+    return this.mutableWatchQuery<LoadResult<any>>({
+      query,
+      variables,
+      // Force cached mutable query
+      queryName: withTotal ? 'LoadAllWithTotal' : 'LoadAll',
+      arrayFieldName: 'data',
+      totalFieldName: withTotal ? 'total' : undefined,
+      insertFilterFn: filter && filter.asFilterFn(),
+      error: {code: ErrorCodes.LOAD_DATA_ERROR, message: 'REFERENTIAL.ERROR.LOAD_DATA_ERROR'},
+      fetchPolicy: opts && opts.fetchPolicy || undefined
+    })
+      .pipe(
+        map(({data, total}) => {
+          // Convert to entity (if need)
+          const entities = (!opts || opts.toEntity !== false)
+            ? (data || []).map(json => this.fromObject(json))
+            : (data || []) as T[];
+
+          if (now) {
+            console.debug(this._logPrefix + `${this._logTypeName} loaded in ${Date.now() - now}ms`, entities);
+            now = null;
+          }
+          return {data: entities, total};
+        })
+      );
+  }
+
+  async loadAll(offset: number,
+                size: number,
+                sortBy?: string,
+                sortDirection?: SortDirection,
+                filter?: Partial<F>,
+                opts?: LO & {
+                  debug?: boolean;
+                }
+  ): Promise<LoadResult<T>> {
+
+    const debug = this._debug && (!opts || opts.debug !== false);
+
+    filter = this.asFilter(filter);
+
+    const variables: any = {
+      ...(opts?.variables || {}),
+      offset: offset || 0,
+      size: size || 100,
+      sortBy: sortBy || 'id',
+      sortDirection: sortDirection || 'asc',
+      filter: filter && filter.asPodObject()
+    };
+
+    const now = Date.now();
+    if (debug) console.debug(this._logPrefix + `Loading ${this._logTypeName}...`, variables);
+
+    const withTotal = (!opts || opts.withTotal !== false) && this.queries.loadAllWithTotal && true;
+    // use given query
+    const query = opts?.query
+      // Or get loadAll or loadAllWithTotal query
+      || (withTotal ? this.queries.loadAllWithTotal  : this.queries.loadAll);
+    const {data, total} = await this.graphql.query<LoadResult<any>>({
+      query,
+      variables,
+      error: {code: ErrorCodes.LOAD_DATA_ERROR, message: 'ERROR.LOAD_DATA_ERROR'},
+      fetchPolicy: opts && opts.fetchPolicy || 'network-only'
+    });
+
+    const entities = (!opts || opts.toEntity !== false) ?
+      (data || []).map(json => this.fromObject(json)) :
+      (data || []) as T[];
+    if (debug) console.debug(this._logPrefix + `${this._logTypeName} items loaded in ${Date.now() - now}ms`);
+
+    const result: LoadResult<T> = {
+      data: entities,
+      total: total || entities.length
+    };
+
+    // Add fetch more capability, if total was fetched
+    if (withTotal) {
+      const nextOffset = (offset || 0) + entities.length;
+      if (nextOffset < result.total) {
+        result.fetchMore = () => this.loadAll(nextOffset, size, sortBy, sortDirection, filter, opts);
+      }
+    }
+
+    return result;
+  }
+
+  async countAll(filter?: Partial<F>, opts?: LO) {
+    // If no countAll query
+    if (!this.queries.countAll && !opts?.query) {
+      // Fail if no loadAll (cannot count)
+      if (!this.queries.loadAllWithTotal) throw new Error('Not implemented');
+
+      // Use loadAll query, with size = 0;
+      return (await this.loadAll(0, 1, null, null, filter,
+        <LO & { withTotal: boolean; }>{withTotal: true}))?.total || 0;
+    }
+
+
+    filter = this.asFilter(filter);
+
+    const variables: any = {
+      ...(opts?.variables || {}),
+      filter: filter && filter.asPodObject()
+    }
+
+    const query = opts?.query || this.queries.countAll;
+    const res = await this.graphql.query<{ total: number;}>({
+      query,
+      variables,
+      error: {code: ErrorCodes.LOAD_DATA_ERROR, message: 'ERROR.COUNT_DATA_ERROR'},
+      fetchPolicy: opts && opts.fetchPolicy || 'network-only'
+    });
+    return res.total;
+  }
+
+  canUserWrite(data: T, opts?: any): boolean {
+    return !!data;
+  }
+
+  async saveAll(entities: T[], opts?: EntitySaveOptions): Promise<T[]> {
+    if (isEmptyArray(entities)) return entities; // Nothing to save: skip
+
+    if (!this.mutations.saveAll) {
+      if (!this.mutations.save) throw new Error('Not implemented');
+      // Save one by one
+      return chainPromises((entities || [])
+        .map(entity => (() => this.save(entity, opts))));
+    }
+
+    let hasNewEntities = false;
+    const json = entities.map(entity => {
+      hasNewEntities = hasNewEntities || this.isNewFn(entity);
+      this.fillDefaultProperties(entity);
+      return this.asObject(entity);
+    });
+
+    const now = Date.now();
+    if (this._debug) console.debug(this._logPrefix + `Saving all ${this._logTypeName}...`, json);
+
+    await this.graphql.mutate<LoadResult<any>>({
+      mutation: this.mutations.saveAll,
+      refetchQueries: this.getRefetchQueriesForMutation(opts),
+      awaitRefetchQueries: opts && opts.awaitRefetchQueries,
+      variables: {
+        data: json
+      },
+      error: {code: ErrorCodes.SAVE_DATA_ERROR, message: 'ERROR.SAVE_DATA_ERROR'},
+      update: (proxy, {data}) => {
+        const savedEntities = data && data.data;
+        if (savedEntities) {
+          // Update entities (id and update date)
+          entities.forEach(entity => {
+            const savedEntity = savedEntities.find(e => this.equalsFn(e, entity));
+            this.copyIdAndUpdateDate(savedEntity, entity);
+          });
+
+          if (hasNewEntities && this.watchQueriesUpdatePolicy === 'update-cache') {
+            // Update the cache
+            this.insertIntoMutableCachedQueries(proxy, {
+              queries: this.getLoadQueries(),
+              data: savedEntities
+            });
+          }
+        }
+
+        if (opts && opts.update) {
+          opts.update(proxy, {data});
+        }
+
+        if (this._debug) console.debug(`${this._logTypeName} saved in ${Date.now() - now}ms`, entities);
+
+      }
+    });
+
+    return entities;
+  }
+
+  /**
+   * Save a referential entity
+   *
+   * @param entity
+   * @param opts
+   */
+  async save(entity: T, opts?: EntitySaveOptions): Promise<T> {
+    if (!this.mutations.save) {
+      if (!this.mutations.saveAll) throw new Error('Not implemented');
+      const data = await this.saveAll([entity], opts);
+      return data && data[0];
+    }
+
+    // Fill default properties
+    this.fillDefaultProperties(entity);
+
+    // Transform into json
+    const json = this.asObject(entity);
+
+    const isNew = this.isNewFn(json);
+
+    const now = Date.now();
+    if (this._debug) console.debug(this._logPrefix + `Saving ${this._logTypeName}...`, json);
+
+    await this.graphql.mutate<{data: any}>({
+      mutation: this.mutations.save,
+      refetchQueries: this.getRefetchQueriesForMutation(opts),
+      awaitRefetchQueries: opts && opts.awaitRefetchQueries,
+      variables: {
+        data: json
+      },
+      error: {code: ErrorCodes.SAVE_DATA_ERROR, message: 'ERROR.SAVE_DATA_ERROR'},
+      update: (cache, {data}) => {
+        // Update entity
+        const savedEntity = data && data.data;
+        this.copyIdAndUpdateDate(savedEntity, entity);
+
+        // Insert into the cache
+        if (isNew && this.watchQueriesUpdatePolicy === 'update-cache') {
+          this.insertIntoMutableCachedQueries(cache, {
+            queries: this.getLoadQueries(),
+            data: savedEntity
+          });
+        }
+
+        if (opts && opts.update) {
+          opts.update(cache, {data});
+        }
+
+        if (this._debug) console.debug(this._logPrefix + `${entity.__typename} saved in ${Date.now() - now}ms`, entity);
+      }
+    });
+
+    return entity;
+  }
+
+  /**
+   * Delete referential entities
+   */
+  async deleteAll(entities: T[], opts?: Partial<{
+    update: MutationUpdaterFn<any>;
+  }> | any): Promise<any> {
+    if (!this.mutations.deleteAll) {
+      if (!this.mutations.delete) throw new Error('Not implemented');
+      // Delete one by one
+      return chainPromises((entities || [])
+        .map(entity => (() => this.delete(entity, opts))));
+    }
+
+    // Filter saved entities
+    entities = entities && entities.filter(e => isNotNil(e.id));
+
+    // Nothing to save: skip
+    if (isEmptyArray(entities)) return;
+
+    const ids = entities.map(t => t.id);
+    const now = Date.now();
+    if (this._debug) console.debug(this._logPrefix + `Deleting ${this._logTypeName}...`, ids);
+
+    await this.graphql.mutate<any>({
+      mutation: this.mutations.deleteAll,
+      refetchQueries: this.getRefetchQueriesForMutation(opts),
+      awaitRefetchQueries: opts && opts.awaitRefetchQueries,
+      variables: { ids },
+      error: {code: ErrorCodes.DELETE_DATA_ERROR, message: 'ERROR.DELETE_DATA_ERROR'},
+      update: (cache, res) => {
+
+        // Remove from cache
+        if (this.watchQueriesUpdatePolicy === 'update-cache') {
+          this.removeFromMutableCachedQueriesByIds(cache, {
+            queries: this.getLoadQueries(),
+            ids
+          });
+        }
+
+        if (opts && opts.update) {
+          opts.update(cache, res);
+        }
+
+        if (this._debug) console.debug(this._logPrefix + `${this._logTypeName} deleted in ${Date.now() - now}ms`);
+      }
+    });
+  }
+
+  /**
+   * Delete a referential entity
+   */
+  async delete(entity: T, opts?: EntitySaveOptions | any): Promise<any> {
+    if (!this.mutations.delete) {
+      if (!this.mutations.deleteAll) throw new Error('Not implemented');
+      const data = await this.deleteAll([entity], opts);
+      return data && data[0];
+    }
+
+    // Nothing to save: skip
+    if (!entity || isNil(entity.id)) return;
+
+    const id = entity.id;
+    const now = new Date();
+    if (this._debug) console.debug(this._logPrefix + `Deleting ${this._logTypeName} {${id}}...`);
+
+    await this.graphql.mutate<any>({
+      mutation: this.mutations.delete,
+      refetchQueries: this.getRefetchQueriesForMutation(opts),
+      awaitRefetchQueries: opts && opts.awaitRefetchQueries,
+      variables: { id },
+      error: {code: ErrorCodes.DELETE_DATA_ERROR, message: 'ERROR.DELETE_DATA_ERROR'},
+      update: (proxy, res) => {
+
+        // Remove from cache
+        if (this.watchQueriesUpdatePolicy === 'update-cache') {
+          this.removeFromMutableCachedQueriesByIds(proxy, {
+            queries: this.getLoadQueries(),
+            ids: [id]
+          });
+        }
+
+        if (opts && opts.update) {
+          opts.update(proxy, res);
+        }
+
+        if (this._debug) console.debug(this._logPrefix + `${this._logTypeName} deleted in ${new Date().getTime() - now.getTime()}ms`);
+      }
+    });
+  }
+
+  listenChanges(id: ID, opts?: EntityServiceListenChangesOptions): Observable<T> {
+    if (isNil(id)) throw Error('Missing argument \'id\' ');
+    if (!this.subscriptions.listenChanges) {
+      console.warn(`${this.constructor.name}.listenChanges() not implemented yet. Will empty observable`);
+      return of();
+    }
+
+    const variables = opts?.variables || {
+      id,
+      interval: toNumber(opts && opts.interval, 0) // no timer by default
+    };
+    if (this._debug) console.debug(this._logPrefix + `[WS] Listening for changes on ${this._logTypeName} {${id}}...`);
+
+    return this.graphql.subscribe<{data: any}>({
+      query: opts?.query || this.subscriptions.listenChanges,
+      fetchPolicy: opts?.fetchPolicy || 'no-cache',
+      variables,
+      error: {
+        code: ErrorCodes.SUBSCRIBE_DATA_ERROR,
+        message: 'ERROR.SUBSCRIBE_DATA_ERROR'
+      }
+    })
+      .pipe(
+        map(({data}) => {
+          const entity = (!opts || opts.toEntity !== false) ? data && this.fromObject(data) : data;
+          //if (entity && this._debug) console.debug(this._logPrefix + `[WS] Received changes on ${this._logTypeName} {${id}}`, entity);
+
+          // TODO: missing = deleted ?
+          if (!entity) console.warn(this._logPrefix + `[WS] Received deletion on ${this._logTypeName} {${id}} - TODO check implementation`);
+
+          return entity;
+        })
+      );
+  }
+
+  copyIdAndUpdateDate(source: T, target: T) {
+    if (!source) return;
+
+    // Update (id and updateDate)
+    EntityUtils.copyIdAndUpdateDate(source, target);
+  }
+
+
+  fromObject(source: any): T {
+    if (!source) return source;
+    const target = new this.dataType();
+    target.fromObject(source);
+    return target;
+  }
+
+  asFilter(source: any): F {
+    return EntityFilterUtils.fromObject(source, this.filterType);
+  }
+
+  /* -- protected functions -- */
+
+  protected async ngOnStart() {
+    // No limit for updatable watch queries, if desktop
+    if (!this.platform.mobile) {
+      this._mutableWatchQueriesMaxCount = -1;
+    }
+  }
+
+  protected fillDefaultProperties(source: T) {
+    // Can be override by subclasses
+  }
+
+  protected asObject(entity: T, opts?: EntityAsObjectOptions): any {
+    // Can be override by subclasses
+    return entity.asObject(opts);
+  }
+
+  protected getRefetchQueriesForMutation(opts?: EntitySaveOptions): ((result: FetchResult<{data: any}>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude {
+    if (opts && opts.refetchQueries) return opts.refetchQueries;
+
+    // Skip if update policy not used refecth queries
+    if (this.watchQueriesUpdatePolicy !== 'refetch-queries') return undefined;
+
+    const queries = this.getLoadQueries();
+    if (!queries.length) return undefined; // Skip if empty
+
+    // Find the refetch queries definition
+    return this.findRefetchQueries({queries});
+  }
+
+  protected getLoadQueries(): DocumentNode[] {
+    return [this.queries.loadAll, this.queries.loadAllWithTotal].filter(isNotNil);
+  }
+
+  protected getLoadQueryNames(): string[] {
+    return ['LoadAll', 'LoadAllWithTotal'];
+  }
+
+}