@sumaris-net/ngx-components 1.2.8 → 1.2.14

package/esm2020/src/app/core/table/entities-async-table-datasource.class.mjs

@@ -0,0 +1,382 @@
+// noinspection DuplicatedCode
+import { AsyncTableDataSource } from '@e-is/ngx-material-table';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ErrorCodes } from '../services/errors';
+import { catchError, debounceTime, map, takeUntil } from 'rxjs/operators';
+import { Directive } from '@angular/core';
+import { firstFalsePromise } from '../../shared/observables';
+import { isEmptyArray, isNotEmptyArray, isNotNil, removeEnd, sleep } from '../../shared/functions';
+import { AppTableUtils } from './table.utils';
+import { environment } from '../../../environments/environment';
+import * as i0 from "@angular/core";
+// @dynamic
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class EntitiesAsyncTableDataSource extends AsyncTableDataSource {
+    /**
+     * Creates a new TableDataSource instance, that can be used as datasource of `@angular/cdk` data-table.
+     *
+     * @param dataService A service to load and save data
+     * @param dataType Type of data contained by the Table. If not specified, then `data` with at least one element must be specified.
+     * @param environment
+     * @param validatorService Service that create instances of the FormGroup used to validate row fields.
+     * @param config Additional configuration for table.
+     */
+    constructor(dataType, dataService, validatorService, options) {
+        super([], dataType, validatorService, {
+            keepOriginalDataAfterConfirm: false,
+            readOnly: false,
+            saveOnlyDirtyRows: false,
+            ...options
+        });
+        this.dataService = dataService;
+        this._debug = false;
+        this._creating = false;
+        this._saving = false;
+        this._fetchMoreFn = null;
+        this._stopWatchSubject = new Subject();
+        this.loadingSubject = new BehaviorSubject(undefined);
+        this._entityName = removeEnd((new dataType()).__typename || 'UnknownVO', 'VO');
+        this._debug = options?.suppressErrors === false && !environment.production;
+    }
+    get watchAllOptions() {
+        return this.config.watchAllOptions;
+    }
+    set watchAllOptions(value) {
+        this.config.watchAllOptions = value;
+    }
+    get saveAllOptions() {
+        return this.config.saveAllOptions;
+    }
+    set saveAllOptions(value) {
+        this.config.saveAllOptions = value;
+    }
+    get loaded() {
+        return this.loadingSubject.value === false; // Should be false when undefined (initial state)
+    }
+    get loading() {
+        return this.loadingSubject.value !== false; // Should be true when undefined (initial state)
+    }
+    ngOnDestroy() {
+        this.disconnect();
+    }
+    watchAll(offset, size, sortBy, sortDirection, filter) {
+        this._stopWatchSubject.next();
+        this._fetchMoreFn = null;
+        this.markAsLoading();
+        return this.dataService.watchAll(offset, size, sortBy, sortDirection, filter, this.watchAllOptions)
+            .pipe(catchError(err => this.handleError(err, 'ERROR.LOAD_DATA_ERROR')), map((res) => {
+            if (this._saving) {
+                console.info(`[entities-table-datasource] Received ${this._entityName} data (from service), but still saving: skip`);
+            }
+            else if (this.hasSomeEditingRow()) {
+                console.warn(`[entities-table-datasource] Received ${this._entityName} data, while some row still editing: skip; Please check save() implementation in the table!`);
+            }
+            else {
+                this.updateDatasource((res.data || []));
+                this._fetchMoreFn = res.fetchMore;
+            }
+            return res;
+        }), 
+        // Stop this pipe next time we call watchAll()
+        takeUntil(this._stopWatchSubject)
+        // ⚠ Notice: Don't put any operator after takeUntil to avoid potential subscription leaks
+        );
+    }
+    updateDatasourceFromRows(rows) {
+        // Avoid to update dataSourceSubject, when not need
+        if (this.datasourceSubject.observers?.length) {
+            if (!this.config.suppressErrors)
+                console.warn('[entities-table-datasource] Update datasource subject. Please prefer using \'rowsSubject\' instead of \'datasourceSubject\'');
+            super.updateDatasourceFromRows(rows);
+        }
+        else {
+            console.debug('[entities-table-datasource] Skipping datasourceSubject update (not used yet).');
+        }
+    }
+    async save() {
+        if (this.config.readOnly) {
+            console.error('[entities-table-datasource] Enable to save, because config.readOnly=true');
+            return false;
+        }
+        // Saving twice (should never occur)
+        if (this._saving) {
+            console.warn(`[entities-table-datasource] Trying to save ${this._entityName} rows twice. Skip`);
+            return false;
+        }
+        this._saving = true;
+        this.markAsLoading();
+        const onlyDirtyRows = this.config.saveOnlyDirtyRows;
+        try {
+            if (this._debug)
+                console.debug(`[entities-table-datasource] Saving ${this._entityName} rows... {onlyDirtyRows: ${onlyDirtyRows}}`);
+            // Get all rows
+            const rows = this.getRows();
+            // Finish editing all rows
+            const invalidRows = (await Promise.all(this.getEditingRows()
+                .map(row => row.confirmEditCreate().then(confirmed => confirmed === false ? row : null))))
+                .filter(isNotNil);
+            // Cannot finish some rows: error
+            if (invalidRows.length) {
+                // log errors
+                if (this._debug)
+                    invalidRows.forEach(row => AppTableUtils.logRowErrors(row, `[entities-table-datasource] ${this._entityName} row #${row.id}`));
+                // Stop with an error
+                throw { code: ErrorCodes.TABLE_INVALID_ROW_ERROR, message: 'ERROR.TABLE_INVALID_ROW_ERROR' };
+            }
+            let data;
+            let dataToSave;
+            if (this.validatorService) {
+                dataToSave = [];
+                data = rows.map(row => {
+                    const currentData = new this.dataConstructor();
+                    currentData.fromObject(row.currentData);
+                    // Filter to keep only dirty row
+                    if (onlyDirtyRows && row.validator.dirty)
+                        dataToSave.push(currentData);
+                    return currentData;
+                });
+                if (!onlyDirtyRows)
+                    dataToSave = data;
+            }
+            // Or use the current data without conversion (when no validator service used)
+            else {
+                data = rows.map(row => row.currentData);
+                // save all data, as we don't have any dirty marker
+                dataToSave = data;
+            }
+            // If no data to save: exit
+            if (onlyDirtyRows && !dataToSave.length) {
+                if (this._debug)
+                    console.debug(`[entities-table-datasource] No ${this._entityName} data to save. Skip`);
+                return false;
+            }
+            if (this._debug)
+                console.debug(`[entities-table-datasource] Asking service to save this ${this._entityName} data:`, dataToSave);
+            await this.dataService.saveAll(dataToSave, this.saveAllOptions);
+            if (this._debug)
+                console.debug(`[entities-table-datasource] Saving ${this._entityName} data [OK]`);
+            // LP 23/03/2021: update datasource is necessary but can be changed to a refetch() on QueryRef (must be created and registered in GraphqlService.watchQuery)
+            this.updateDatasource(data, { emitEvent: false });
+            return true;
+        }
+        catch (error) {
+            if (this._debug)
+                console.error('[entities-table-datasource] Error while saving: ' + error && error.message || error);
+            throw error;
+        }
+        finally {
+            this._saving = false;
+            this.markAsLoaded();
+        }
+    }
+    updateDatasource(data, opts) {
+        if (this._debug)
+            console.debug(`[entities-table-datasource] Updating datasource with data:`, data);
+        super.updateDatasource(data, opts);
+        if (!opts || opts.emitEvent !== false) {
+            this.markAsLoaded();
+        }
+    }
+    connect(collectionViewer) {
+        // DEBUG
+        //console.debug("[entities-datasource] connect");
+        return super.connect(collectionViewer);
+    }
+    disconnect(collectionViewer) {
+        if (this._debug)
+            console.debug('[entities-table-datasource] Disconnecting...');
+        super.disconnect(collectionViewer);
+        if (!this._stopWatchSubject.closed) {
+            if (this._debug)
+                console.debug('[entities-table-datasource] Closing...');
+            this._stopWatchSubject.next();
+            this._stopWatchSubject.complete();
+            this._stopWatchSubject.unsubscribe();
+            this.loadingSubject.complete();
+            this.loadingSubject.unsubscribe();
+        }
+    }
+    waitIdle(debounceTimeMs) {
+        return firstFalsePromise(this.loadingSubject
+            .asObservable()
+            .pipe(debounceTime(debounceTimeMs || 100) // if not started yet, wait
+        ));
+    }
+    async confirmCreate(row) {
+        const confirmed = await super.confirmCreate(row);
+        if (!confirmed)
+            return false;
+        if (row.editing && row.validator) {
+            console.warn('[entities-table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');
+            row.validator.disable({ onlySelf: true, emitEvent: false });
+        }
+        return confirmed;
+    }
+    async confirmEdit(row) {
+        const confirmed = await super.confirmEdit(row);
+        if (!confirmed)
+            return false;
+        if (row.editing && row.validator) {
+            console.warn('[entities-table-datasource] Row still has {editing: true} after confirmEdit()! Force editing to false');
+            row.validator.disable({ onlySelf: true, emitEvent: false });
+        }
+        return true;
+    }
+    async startEdit(row) {
+        const editing = await super.startEdit(row);
+        if (!editing)
+            return false;
+        if (!row.editing && row.validator) {
+            console.warn('[entities-table-datasource] Row still has {editing: false} after startEdit()! Force editing');
+            row.validator.enable({ onlySelf: true, emitEvent: false });
+        }
+        return true;
+    }
+    handleError(error, message) {
+        const errorMsg = error && error.message || error;
+        console.error(`[entities-table-datasource] Service ${this._entityName} sent error: ${errorMsg}`, error);
+        this.markAsLoaded();
+        throw new Error(message || errorMsg);
+    }
+    handleServiceError(error) {
+        const errorMsg = error && error.message || error;
+        console.error(`[entities-table-datasource] Service ${this._entityName} sent error: ${errorMsg}`, error);
+        this.markAsLoaded();
+        throw error;
+    }
+    async delete(id) {
+        // If new row: not need to propagate to the dataService
+        if (id === -1) {
+            return super.delete(id);
+        }
+        const row = this.getRow(id);
+        if (!row) {
+            console.error(`[entities-table-datasource] Row to delete with id=${id} not found`);
+            return;
+        }
+        this.markAsLoading();
+        try {
+            await this.dataService.deleteAll([row.currentData], this.saveAllOptions);
+            // Wait cache update, then table update
+            await sleep(300);
+            // make sure row has been deleted (because GraphQl cache remove can fail)
+            const present = this.getRow(id) === row;
+            if (present)
+                await super.delete(id);
+            this.markAsLoaded();
+        }
+        catch (err) {
+            this.handleServiceError(err);
+        }
+    }
+    async deleteAll(rows) {
+        this.markAsLoading();
+        const data = this.getDataFromRows(rows);
+        try {
+            // Call service deletion
+            await this.dataService.deleteAll(data, this.saveAllOptions);
+            // Workaround, to be sure all rows have been deleted
+            // Sometime, the service miss deletion, or GraphQl cache remove failed.
+            // In this case, apply missing deletion using the parent delete() function
+            const rowNotDeleted = this.getRows().filter(row => rows.includes(row));
+            if (isNotEmptyArray(rowNotDeleted)) {
+                console.warn(`[entities-table-datasource] Force deletion of ${rowNotDeleted.length} rows! Please check that data service update the cache, after deletion`);
+                // Start at the end
+                for (const r of rowNotDeleted.sort((a, b) => a.id > b.id ? -1 : 1)) {
+                    await super.delete(r.id);
+                }
+            }
+        }
+        catch (err) {
+            // Handle service error
+            this.handleServiceError(err);
+        }
+        finally {
+            this.markAsLoaded();
+        }
+    }
+    getRow(id) {
+        return super.getRow(id);
+    }
+    getRows() {
+        return this.rowsSubject.value || [];
+    }
+    getEditingRows() {
+        return this.getRows().filter(row => row.editing);
+    }
+    getSingleEditingRow() {
+        const rows = this.getEditingRows();
+        return rows.length === 1 ? rows[0] : undefined;
+    }
+    hasSomeEditingRow() {
+        return this.getRows().some(row => row.editing);
+    }
+    async createNew(insertAt, opts = { editing: true }) {
+        // Avoid multiple call (only one editing row is allowed)
+        if (this._creating && opts.editing)
+            return;
+        this._creating = true;
+        try {
+            const row = await super.createNew(insertAt, opts);
+            if (!row)
+                return undefined; // Stop here
+            // Call observers
+            if (this.config?.onRowCreated) {
+                try {
+                    await this.config.onRowCreated(row);
+                }
+                catch (err) {
+                    // Log, then continue
+                    console.error(err && err.message || err, err);
+                }
+            }
+            return row;
+        }
+        finally {
+            this._creating = false;
+        }
+    }
+    getData() {
+        const rows = this.getRows();
+        return this.getDataFromRows(rows);
+    }
+    async fetchMore(opts) {
+        if (!this._fetchMoreFn)
+            return false; // Avoid multiple call
+        if (this.hasSomeEditingRow()) {
+            console.warn(`Cannot fetch more ${this._entityName} because some row) still editing`);
+            return;
+        }
+        console.debug(`Will fetching more row(s) still...`);
+        // Forget the fetchMore function, to avoid multiple call
+        const fetchMoreFn = this._fetchMoreFn;
+        this._fetchMoreFn = null;
+        // Fetch next page
+        const res = await fetchMoreFn();
+        // Skip if empty (no more data)
+        if (isEmptyArray(res?.data))
+            return false;
+        // Update the data source
+        super.updateDatasource((this.currentData || []).concat(...res.data), opts);
+        // Remember fetchMore
+        this._fetchMoreFn = res.fetchMore;
+        return true;
+    }
+    /* -- protected method -- */
+    markAsLoading() {
+        if (this.loadingSubject.value !== true) {
+            this.loadingSubject.next(true);
+        }
+    }
+    markAsLoaded() {
+        if (this.loadingSubject.value !== false) {
+            this.loadingSubject.next(false);
+        }
+    }
+}
+EntitiesAsyncTableDataSource.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: EntitiesAsyncTableDataSource, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+EntitiesAsyncTableDataSource.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: EntitiesAsyncTableDataSource, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: EntitiesAsyncTableDataSource, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entities-async-table-datasource.class.js","sourceRoot":"","sources":["../../../../../../src/app/core/table/entities-async-table-datasource.class.ts"],"names":[],"mappings":"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","sourcesContent":["// noinspection DuplicatedCode\n\nimport { AsyncTableDataSource, AsyncTableElement, TableDataSourceConfig, ValidatorService } from '@e-is/ngx-material-table';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { Entity, IEntity } from '../services/model/entity.model';\nimport { ErrorCodes } from '../services/errors';\nimport { catchError, debounceTime, map, takeUntil } from 'rxjs/operators';\nimport { Directive, OnDestroy } from '@angular/core';\nimport { SortDirection } from '@angular/material/sort';\nimport { CollectionViewer } from '@angular/cdk/collections';\nimport { EntitiesServiceWatchOptions, FetchMoreFn, IEntitiesService, LoadResult } from '../../shared/services/entity-service.class';\nimport { firstFalsePromise } from '../../shared/observables';\nimport { isEmptyArray, isNotEmptyArray, isNotNil, removeEnd, sleep } from '../../shared/functions';\nimport { AppTableUtils } from './table.utils';\nimport { environment } from '../../../environments/environment';\nimport { IEntitiesTableDataSource } from './table.model';\n\n\nexport interface EntitiesAsyncTableDataSourceConfig<\n  T extends Entity<T, ID>,\n  ID = number,\n  WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions,\n  SO = any\n  > extends TableDataSourceConfig {\n\n  onRowCreated?: (row: AsyncTableElement<T>) => Promise<void> | void;\n  saveOnlyDirtyRows?: boolean;\n  readOnly?: boolean;\n\n  /**\n   * @deprecated\n   */\n  dataServiceOptions?: WO & SO; // Options passed to the dataService.watchAll() and dataService.saveAll()\n\n  watchAllOptions?: WO; // Options passed to the dataService.saveAll()\n  saveAllOptions?: SO; // Options passed to the dataService.saveAll()\n\n  [key: string]: any;\n}\n\n// @dynamic\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport class EntitiesAsyncTableDataSource<\n  T extends IEntity<T, ID>,\n  F = any,\n  ID = number,\n  WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions,\n  SO = any,\n  V extends ValidatorService = ValidatorService,\n  C extends EntitiesAsyncTableDataSourceConfig<T, ID, WO, SO> = EntitiesAsyncTableDataSourceConfig<T, ID, WO, SO>,\n  R extends AsyncTableElement<T> = AsyncTableElement<T>\n  >\n    extends AsyncTableDataSource<T, V, C, R>\n    implements IEntitiesTableDataSource<R>, OnDestroy {\n\n  private readonly _entityName: string;\n\n  protected _debug = false;\n  protected _creating = false;\n  protected _saving = false;\n  protected _fetchMoreFn: FetchMoreFn<LoadResult<T>> = null;\n  protected _stopWatchSubject = new Subject<void>();\n\n  loadingSubject = new BehaviorSubject<boolean>(undefined);\n\n  get watchAllOptions(): WO {\n    return this.config.watchAllOptions;\n  }\n\n  set watchAllOptions(value: WO)  {\n    this.config.watchAllOptions = value;\n  }\n\n  get saveAllOptions(): SO {\n    return this.config.saveAllOptions;\n  }\n\n  set saveAllOptions(value: SO)  {\n    this.config.saveAllOptions = value;\n  }\n\n  get loaded(): boolean {\n    return this.loadingSubject.value === false; // Should be false when undefined (initial state)\n  }\n\n  get loading(): boolean {\n    return this.loadingSubject.value !== false; // Should be true when undefined (initial state)\n  }\n\n  /**\n   * Creates a new TableDataSource instance, that can be used as datasource of `@angular/cdk` data-table.\n   *\n   * @param dataService A service to load and save data\n   * @param dataType Type of data contained by the Table. If not specified, then `data` with at least one element must be specified.\n   * @param environment\n   * @param validatorService Service that create instances of the FormGroup used to validate row fields.\n   * @param config Additional configuration for table.\n   */\n  constructor(dataType: new() => T,\n              public readonly dataService: IEntitiesService<T, F, WO>,\n              validatorService?: V,\n              options?: C) {\n    super([], dataType, validatorService, {\n      keepOriginalDataAfterConfirm: false,\n      readOnly: false,\n      saveOnlyDirtyRows: false,\n      ...options\n    });\n\n    this._entityName = removeEnd((new dataType()).__typename || 'UnknownVO', 'VO');\n    this._debug = options?.suppressErrors === false && !environment.production;\n  }\n\n  ngOnDestroy() {\n    this.disconnect();\n  }\n\n  watchAll(offset: number,\n           size: number,\n           sortBy?: string,\n           sortDirection?: SortDirection,\n           filter?: Partial<F>): Observable<LoadResult<T>> {\n\n    this._stopWatchSubject.next();\n    this._fetchMoreFn = null;\n    this.markAsLoading();\n\n    return this.dataService.watchAll(offset, size, sortBy, sortDirection, filter, this.watchAllOptions as WO)\n      .pipe(\n        catchError(err => this.handleError(err, 'ERROR.LOAD_DATA_ERROR')),\n        map((res: LoadResult<T>) => {\n          if (this._saving) {\n            console.info(`[entities-table-datasource] Received ${this._entityName} data (from service), but still saving: skip`);\n          } else if (this.hasSomeEditingRow()) {\n            console.warn(`[entities-table-datasource] Received ${this._entityName} data, while some row still editing: skip; Please check save() implementation in the table!`);\n          } else {\n            this.updateDatasource((res.data || []) as T[]);\n            this._fetchMoreFn = res.fetchMore;\n          }\n          return res;\n        }),\n        // Stop this pipe next time we call watchAll()\n        takeUntil(this._stopWatchSubject)\n        // ⚠ Notice: Don't put any operator after takeUntil to avoid potential subscription leaks\n      );\n  }\n\n  protected updateDatasourceFromRows(rows: R[]) {\n    // Avoid to update dataSourceSubject, when not need\n    if (this.datasourceSubject.observers?.length) {\n      if (!this.config.suppressErrors) console.warn('[entities-table-datasource] Update datasource subject. Please prefer using \\'rowsSubject\\' instead of \\'datasourceSubject\\'');\n      super.updateDatasourceFromRows(rows);\n    }\n    else {\n      console.debug('[entities-table-datasource] Skipping datasourceSubject update (not used yet).');\n    }\n  }\n\n  async save(): Promise<boolean> {\n    if (this.config.readOnly) {\n      console.error('[entities-table-datasource] Enable to save, because config.readOnly=true');\n      return false;\n    }\n    // Saving twice (should never occur)\n    if (this._saving) {\n      console.warn(`[entities-table-datasource] Trying to save ${this._entityName} rows twice. Skip`);\n      return false;\n    }\n\n    this._saving = true;\n    this.markAsLoading();\n\n    const onlyDirtyRows = this.config.saveOnlyDirtyRows;\n\n    try {\n      if (this._debug) console.debug(`[entities-table-datasource] Saving ${this._entityName} rows... {onlyDirtyRows: ${onlyDirtyRows}}`);\n\n      // Get all rows\n      const rows = this.getRows();\n\n      // Finish editing all rows\n      const invalidRows: AsyncTableElement<T>[] = (await Promise.all(\n        this.getEditingRows()\n          .map(row => row.confirmEditCreate().then(confirmed => confirmed === false ? row : null)\n          )))\n        .filter(isNotNil);\n\n      // Cannot finish some rows: error\n      if (invalidRows.length) {\n        // log errors\n        if (this._debug) invalidRows.forEach(row => AppTableUtils.logRowErrors(row, `[entities-table-datasource] ${this._entityName} row #${row.id}`));\n        // Stop with an error\n        throw {code: ErrorCodes.TABLE_INVALID_ROW_ERROR, message: 'ERROR.TABLE_INVALID_ROW_ERROR'};\n      }\n\n      let data: T[];\n      let dataToSave: T[];\n\n      if (this.validatorService) {\n        dataToSave = [];\n        data = rows.map(row => {\n          const currentData = new this.dataConstructor() as T;\n          currentData.fromObject(row.currentData);\n          // Filter to keep only dirty row\n          if (onlyDirtyRows && row.validator.dirty) dataToSave.push(currentData);\n          return currentData;\n        });\n        if (!onlyDirtyRows) dataToSave = data;\n      }\n      // Or use the current data without conversion (when no validator service used)\n      else {\n        data = rows.map(row => row.currentData);\n        // save all data, as we don't have any dirty marker\n        dataToSave = data;\n      }\n\n      // If no data to save: exit\n      if (onlyDirtyRows && !dataToSave.length) {\n        if (this._debug) console.debug(`[entities-table-datasource] No ${this._entityName} data to save. Skip`);\n        return false;\n      }\n\n      if (this._debug) console.debug(`[entities-table-datasource] Asking service to save this ${this._entityName} data:`, dataToSave);\n      await this.dataService.saveAll(dataToSave, this.saveAllOptions);\n\n      if (this._debug) console.debug(`[entities-table-datasource] Saving ${this._entityName} data [OK]`);\n\n      // LP 23/03/2021: update datasource is necessary but can be changed to a refetch() on QueryRef (must be created and registered in GraphqlService.watchQuery)\n      this.updateDatasource(data, {emitEvent: false});\n\n      return true;\n    } catch (error) {\n      if (this._debug) console.error('[entities-table-datasource] Error while saving: ' + error && error.message || error);\n      throw error;\n    } finally {\n      this._saving = false;\n      this.markAsLoaded();\n    }\n  }\n\n  updateDatasource(data: T[], opts?: { emitEvent: boolean }) {\n    if (this._debug) console.debug(`[entities-table-datasource] Updating datasource with data:`, data);\n\n    super.updateDatasource(data, opts);\n\n    if (!opts || opts.emitEvent !== false) {\n      this.markAsLoaded();\n    }\n  }\n\n  connect(collectionViewer: CollectionViewer): Observable<R[] | ReadonlyArray<R>> {\n    // DEBUG\n    //console.debug(\"[entities-datasource] connect\");\n    return super.connect(collectionViewer);\n  }\n\n  disconnect(collectionViewer?: CollectionViewer) {\n    if (this._debug) console.debug('[entities-table-datasource] Disconnecting...')\n    super.disconnect(collectionViewer);\n    if (!this._stopWatchSubject.closed) {\n      if (this._debug) console.debug('[entities-table-datasource] Closing...');\n      this._stopWatchSubject.next();\n      this._stopWatchSubject.complete();\n      this._stopWatchSubject.unsubscribe();\n      this.loadingSubject.complete();\n      this.loadingSubject.unsubscribe();\n    }\n  }\n\n  waitIdle(debounceTimeMs?: number): Promise<any> {\n    return firstFalsePromise(this.loadingSubject\n      .asObservable()\n      .pipe(\n        debounceTime(debounceTimeMs || 100) // if not started yet, wait\n      ));\n  }\n\n  async confirmCreate(row: R): Promise<boolean> {\n    const confirmed = await super.confirmCreate(row);\n    if (!confirmed) return false;\n    if (row.editing && row.validator) {\n      console.warn('[entities-table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');\n      row.validator.disable({onlySelf: true, emitEvent: false});\n    }\n    return confirmed;\n  }\n\n  async confirmEdit(row: R): Promise<boolean> {\n    const confirmed = await super.confirmEdit(row);\n    if (!confirmed) return false;\n    if (row.editing && row.validator) {\n      console.warn('[entities-table-datasource] Row still has {editing: true} after confirmEdit()! Force editing to false');\n      row.validator.disable({onlySelf: true, emitEvent: false});\n    }\n    return true;\n  }\n\n  async startEdit(row: R): Promise<boolean> {\n    const editing = await super.startEdit(row);\n    if (!editing) return false;\n    if (!row.editing && row.validator) {\n      console.warn('[entities-table-datasource] Row still has {editing: false} after startEdit()! Force editing');\n      row.validator.enable({onlySelf: true, emitEvent: false});\n    }\n    return true;\n  }\n\n  handleError(error: any, message: string): Observable<LoadResult<T>> {\n    const errorMsg = error && error.message || error;\n    console.error(`[entities-table-datasource] Service ${this._entityName} sent error: ${errorMsg}`, error);\n    this.markAsLoaded();\n    throw new Error(message || errorMsg);\n  }\n\n  handleServiceError(error: any) {\n    const errorMsg = error && error.message || error;\n    console.error(`[entities-table-datasource] Service ${this._entityName} sent error: ${errorMsg}`, error);\n    this.markAsLoaded();\n    throw error;\n  }\n\n  async delete(id: number): Promise<boolean> {\n    // If new row: not need to propagate to the dataService\n    if (id === -1) {\n      return super.delete(id);\n    }\n\n    const row = this.getRow(id);\n    if (!row) {\n      console.error(`[entities-table-datasource] Row to delete with id=${id} not found`);\n      return;\n    }\n\n    this.markAsLoading();\n\n    try {\n      await this.dataService.deleteAll([row.currentData], this.saveAllOptions);\n\n      // Wait cache update, then table update\n      await sleep(300);\n\n      // make sure row has been deleted (because GraphQl cache remove can fail)\n      const present = this.getRow(id) === row;\n      if (present) await super.delete(id);\n      this.markAsLoaded();\n    }\n    catch(err) {\n      this.handleServiceError(err)\n    }\n  }\n\n  async deleteAll(rows: R[]): Promise<any> {\n\n    this.markAsLoading();\n\n    const data = this.getDataFromRows(rows);\n\n    try {\n\n      // Call service deletion\n      await this.dataService.deleteAll(data, this.saveAllOptions);\n\n      // Workaround, to be sure all rows have been deleted\n      // Sometime, the service miss deletion, or GraphQl cache remove failed.\n      // In this case, apply missing deletion using the parent delete() function\n      const rowNotDeleted = this.getRows().filter(row => rows.includes(row));\n      if (isNotEmptyArray(rowNotDeleted)) {\n        console.warn(`[entities-table-datasource] Force deletion of ${rowNotDeleted.length} rows! Please check that data service update the cache, after deletion`);\n        // Start at the end\n        for (const r of rowNotDeleted.sort((a, b) => a.id > b.id ? -1 : 1)) {\n          await super.delete(r.id);\n        }\n      }\n    }\n    catch (err) {\n      // Handle service error\n      this.handleServiceError(err);\n    }\n    finally {\n      this.markAsLoaded();\n    }\n  }\n\n  getRow(id: number): R {\n    return super.getRow(id);\n  }\n\n  getRows(): R[] {\n    return this.rowsSubject.value || [];\n  }\n\n  getEditingRows(): R[] {\n    return this.getRows().filter(row => row.editing);\n  }\n\n  getSingleEditingRow(): R {\n    const rows = this.getEditingRows();\n    return rows.length === 1 ? rows[0] : undefined;\n  }\n\n  hasSomeEditingRow() {\n    return this.getRows().some(row => row.editing);\n  }\n\n  async createNew(insertAt?: number, opts = {editing: true}): Promise<R|undefined> {\n    // Avoid multiple call (only one editing row is allowed)\n    if (this._creating && opts.editing) return;\n\n    this._creating = true;\n\n    try {\n      const row = await super.createNew(insertAt, opts);\n\n      if (!row) return undefined; // Stop here\n\n      // Call observers\n      if (this.config?.onRowCreated) {\n        try {\n          await this.config.onRowCreated(row);\n        }\n        catch (err)  {\n          // Log, then continue\n          console.error(err && err.message || err, err);\n        }\n      }\n\n      return row;\n    }\n    finally {\n      this._creating = false;\n    }\n  }\n\n  getData(): T[] {\n    const rows = this.getRows();\n    return this.getDataFromRows(rows);\n  }\n\n  async fetchMore(opts?: { emitEvent: boolean }): Promise<boolean> {\n    if (!this._fetchMoreFn) return false; // Avoid multiple call\n    if (this.hasSomeEditingRow()) {\n      console.warn(`Cannot fetch more ${this._entityName} because some row) still editing`);\n      return;\n    }\n    console.debug(`Will fetching more row(s) still...`);\n\n    // Forget the fetchMore function, to avoid multiple call\n    const fetchMoreFn = this._fetchMoreFn;\n    this._fetchMoreFn = null;\n\n    // Fetch next page\n    const res: LoadResult<T> = await fetchMoreFn();\n\n    // Skip if empty (no more data)\n    if (isEmptyArray(res?.data)) return false;\n\n    // Update the data source\n    super.updateDatasource((this.currentData || []).concat(...res.data), opts);\n\n    // Remember fetchMore\n    this._fetchMoreFn = res.fetchMore;\n    return true;\n  }\n\n  /* -- protected method -- */\n\n  markAsLoading() {\n    if (this.loadingSubject.value !== true) {\n      this.loadingSubject.next(true);\n    }\n  }\n\n  markAsLoaded() {\n    if (this.loadingSubject.value !== false) {\n      this.loadingSubject.next(false);\n    }\n  }\n}\n"]}