@sumaris-net/ngx-components 18.12.0 → 18.12.1

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

@@ -1,659 +0,0 @@
-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'];
-  }
-}