@sumaris-net/ngx-components 18.11.0 → 18.12.0

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

@@ -0,0 +1,659 @@
+import { Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ErrorCodes } from './errors';
+
+import {
+  ApolloCache,
+  FetchPolicy,
+  InternalRefetchQueriesInclude,
+  MutationUpdaterFn,
+  MutationUpdaterFunction,
+  WatchQueryFetchPolicy,
+} 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, isNotEmptyArray, 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>;
+
+  equals?: (e1: T, e2: T) => boolean;
+
+  /**
+   * @deprecated Use 'equals' instead
+   */
+  equalsFn?: (e1: T, e2: T) => boolean;
+
+  isNew?: (e: T) => boolean;
+
+  /**
+   * @deprecated Use 'isNew' instead
+   */
+  isNewFn?: (e: T) => boolean;
+  defaultSortBy?: keyof T;
+  defaultSortDirection?: SortDirection;
+  watchQueriesUpdatePolicy?: MutableWatchQueriesUpdatePolicy;
+}
+
+export interface EntitySaveOptions<T = any, V = any> {
+  refetchQueries?: ((result: FetchResult<{ data: T }>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+  awaitRefetchQueries?: boolean;
+  update?: MutationUpdaterFn<{ data: any }> | MutationUpdaterFunction<{ data: any }, V, any, ApolloCache<{ 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<T>,
+    LO extends EntitiesServiceLoadOptions = EntitiesServiceLoadOptions<T>,
+    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;
+
+  get defaultFetchPolicy(): WatchQueryFetchPolicy {
+    return this.graphql.defaultFetchPolicy;
+  }
+
+  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.equals || options.equalsFn;
+    this._isNewFn = options.isNew || options.isNewFn;
+    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: 'ERROR.LOAD_DATA_ERROR' },
+      })
+      .pipe(map(({ data }) => this.fromObject(data, opts)));
+  }
+
+  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: 'ERROR.LOAD_DATA_ERROR' },
+    });
+
+    // Convert to entity
+    return this.fromObject(data, opts);
+  }
+
+  watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, dataFilter?: F, opts?: WO): Observable<LoadResult<T>> {
+    dataFilter = this.asFilter(dataFilter);
+
+    const variables: any = {
+      ...(opts?.variables || {}),
+      offset: offset || 0,
+      size: size || 100,
+      sortBy: sortBy || this.defaultSortBy,
+      sortDirection: sortDirection || this.defaultSortDirection,
+      filter: dataFilter && dataFilter.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: dataFilter && dataFilter.asFilterFn(),
+      error: { code: ErrorCodes.LOAD_DATA_ERROR, message: 'ERROR.LOAD_DATA_ERROR' },
+      fetchPolicy: (opts && opts.fetchPolicy) || undefined,
+    }).pipe(
+      map(({ data, total }) => {
+        // Convert to entities (if need)
+        const entities = this.fromObjects(data, opts);
+
+        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?: keyof T | 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 = this.fromObjects(data, opts);
+    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)));
+    }
+
+    const newEntities: T[] = [];
+    const json = entities.map((entity) => {
+      if (this.isNew(entity)) newEntities.push(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<{ data: T[] }>({
+      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: (cache, { data }, { context, variables }) => {
+        const savedEntities = data?.data as T[];
+        if (savedEntities) {
+          // Update entities (id and update date)
+          entities.forEach((entity) => {
+            const savedEntity = savedEntities.find((e) => this.equals(entity, e));
+            this.copyIdAndUpdateDate(savedEntity, entity);
+          });
+
+          // Update the cache, with new entities
+          if (isNotEmptyArray(newEntities) && this.watchQueriesUpdatePolicy === 'update-cache') {
+            this.insertIntoMutableCachedQueries(cache, {
+              queries: this.getLoadQueries(),
+              data: newEntities,
+            });
+          }
+        }
+
+        if (opts?.update) {
+          opts.update(cache, { data }, { context, variables });
+        }
+
+        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];
+    }
+
+    const isNewEntity = this.isNew(entity);
+
+    // Fill default properties
+    this.fillDefaultProperties(entity);
+
+    // Transform into json
+    const json = this.asObject(entity);
+
+    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 }, { context, variables }) => {
+        // Update entity
+        const savedEntity = data && data.data;
+        this.copyIdAndUpdateDate(savedEntity, entity);
+
+        // Insert into the cache
+        if (isNewEntity && this.watchQueriesUpdatePolicy === 'update-cache') {
+          this.insertIntoMutableCachedQueries(cache, {
+            queries: this.getLoadQueries(),
+            data: savedEntity,
+          });
+        }
+
+        if (opts?.update) {
+          opts.update(cache, { data }, { context, variables });
+        }
+
+        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<T>): 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?.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 }) => {
+          // Convert to entity (if need)
+          const entity = this.fromObject(data, opts);
+          //if (entity && this._debug) console.debug(this._logPrefix + `[WS] Received changes on ${this._logTypeName} {${id}}`, entity);
+
+          if (!entity) console.warn(this._logPrefix + `[WS] Received empty data on ${this._logTypeName} {${id}} - Check if entity has been deleted`);
+
+          return entity;
+        })
+      );
+  }
+
+  copyIdAndUpdateDate(source: T, target: T) {
+    if (!source) return;
+
+    // Update (id and updateDate)
+    EntityUtils.copyIdAndUpdateDate(source, target);
+  }
+
+  fromObject(
+    source: any,
+    opts?: {
+      toEntity?: boolean | ((source: any, opts?: any) => T);
+      [key: string]: any;
+    }
+  ): T {
+    // Simple cast (skip conversion)
+    if (!source || opts?.toEntity === false) return source as T;
+
+    // User defined function
+    if (typeof opts?.toEntity === 'function') {
+      return opts.toEntity(source, opts);
+    }
+
+    // Entity conversion
+    const target = new this.dataType();
+    target.fromObject(source, opts);
+    return target;
+  }
+
+  asFilter(source: any): F {
+    return EntityFilterUtils.fromObject(source, this.filterType);
+  }
+
+  equals(d1: T, d2: T): boolean {
+    if (this._equalsFn) return this._equalsFn(d1, d2);
+    return d1 && d1.equals ? d1.equals(d2) : EntityUtils.equals(d1, d2, 'id');
+  }
+
+  isNew(data: T) {
+    if (this._isNewFn) return this._isNewFn(data);
+    return EntityUtils.isEmpty(data, 'id');
+  }
+
+  /**
+   * @deprecated Use equals() instead
+   */
+  equalsFn(d1: T, d2: T) {
+    return this.equals(d1, d2);
+  }
+
+  /**
+   * @deprecated Use isNew() instead
+   * @param data
+   */
+  isNewFn(data: T) {
+    return this.isNew(data);
+  }
+
+  /* -- 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 overridden by subclasses
+  }
+
+  protected fromObjects(
+    sources: any[],
+    opts?: {
+      toEntity?: boolean | ((source: any, opts?: any) => T);
+      [key: string]: any;
+    }
+  ): T[] {
+    return (sources || []).map((source) => this.fromObject(source, opts));
+  }
+
+  protected asObject(source: T, opts?: EntityAsObjectOptions): any {
+    // Can be overridden by subclasses
+    return source.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'];
+  }
+}