@elderbyte/ngx-starter 14.12.0-beta5 → 14.12.0-beta6

package/src/lib/common/data/data-context/data-context-builder.ts

@@ -0,0 +1,354 @@
+import {DataContextContinuablePaged} from './data-context-continuable-paged';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {DataContextSimple} from './data-context-simple';
+import {DataContextActivePage} from './data-context-active-page';
+import {Sort} from '../sort';
+import {DataContextContinuableToken} from './data-context-continuable-token';
+import {IDataContext, IDataContextActivePage, IDataContextContinuable} from './data-context';
+import {DataContextSourceAutoReloader} from './data-context-source-auto-reloader';
+import {LocalPagedDataSource} from '../datasource/local/local-paged-data-source';
+import {LocalListDataSource} from '../datasource/local/local-list-data-source';
+import {SortUtil} from '../../utils/sort-util';
+import {
+  IContinuableDataSource,
+  IDataSource,
+  IListDataSource,
+  IPagedDataSource,
+  isContinuableDataSource,
+  isListDataSource,
+  isPagedDataSource
+} from '../datasource/data-source';
+import {DelegateDataSource} from '../datasource/fetcher/delegate-data-source';
+import {AutoStartSpec, DataContextAutoStarter} from './data-context-auto-starter';
+import {FilterUtil} from '../../utils/filter-util';
+
+/**
+ * Provides the ability to build a IDataContext<T>.
+ */
+export class DataContextBuilder<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private _indexFn?: ((item: T) => any);
+  private _localApply?: ((data: T[]) => T[]);
+  private _localSort?: ((data: T[], sorts: Sort[]) => T[]);
+  private _skipLocalSort = false;
+  private _pageSize = 50;
+  private _reloadOnLocalChanges = false;
+  private _activePaged = false;
+  private _autoStartSpec?: AutoStartSpec;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Creates a new DataContextBuilder.
+   * @returns A new DataContextBuilder for the given data type.
+   */
+  public static start<T>(): DataContextBuilder<T> {
+    return new DataContextBuilder<T>();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor() {
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Optional index function where each element will be indexed by.
+   * If you have configured this, you can use the findByIndex(key) on the data-context.
+   */
+  public indexBy(indexFn?: ((item: T) => any)): this {
+    this._indexFn = indexFn;
+    return this;
+  }
+
+  /**
+   * The desired size of a page/chunk when loading data.
+   * Note that continuable apis might just take this as a wish or even completely ignore this param.
+   */
+  public pageSize(size: number): this {
+    this._pageSize = size;
+    return this;
+  }
+
+  /**
+   * Sort the data context locally.
+   *
+   * Note that this might be a costly operation when there are a lot of elements present.
+   * Prefer server side sorting if possible.
+   */
+  public localSort(localSort?: (data: T[], sorts: Sort[]) => T[]): this {
+    this._localSort = localSort ? localSort : SortUtil.sortData;
+    return this;
+  }
+
+  /**
+   * Enable active paging (in contrast to the infinite load) in the data context.
+   * Only supported if the underlying datasource supports pagination.
+   */
+  public activePaged(): this {
+    this._activePaged = true;
+    return this;
+  }
+
+  /**
+   * For each element which is added to the datacontext, apply the given function.
+   */
+  public localApply(localApply: ((data: T[]) => T[])): this {
+    this._localApply = localApply;
+    return this;
+  }
+
+  /**
+   * On a local change event, automatically reload data in the data-context.
+   * This means whenever there was an modify operation on the rest client,
+   * such as Update, Delete or Create, the data will be reloaded.
+   */
+  public reloadOnLocalChanges(): this {
+    this._reloadOnLocalChanges = true;
+    return this;
+  }
+
+  public autoStartAsap(sort?: Sort[]): this {
+    return this.autoStartOn(
+      AutoStartSpec.asap(sort)
+    );
+  }
+
+  public autoStartOnFilters(filters: Array<string[]>, sort?: Sort[]): this {
+    return this.autoStartOn(
+      AutoStartSpec.requireFilters(filters, sort)
+    );
+  }
+
+  public autoStartOnFiltersAll(filters: string[], sort?: Sort[]): this {
+    return this.autoStartOn(
+      AutoStartSpec.requireFiltersAll(filters, sort)
+    );
+  }
+
+  public autoStartOnFiltersAny(filters: string[], sort?: Sort[]): this {
+    return this.autoStartOn(
+      AutoStartSpec.requireFiltersAny(filters, sort)
+    );
+  }
+
+  public autoStartOn(spec: AutoStartSpec): this {
+    this._autoStartSpec = spec;
+    return this;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * DataSource Builder                                                      *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Build a new DataContext from the given DataSource.
+   *
+   * Common DataSources are RestClient, LocalListDataSource and DelegateDataSource.
+   *
+   * @param ds
+   */
+  public build(ds: IDataSource<T>): IDataContext<T> {
+    return this.buildFromSource(ds);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Local Data Builder                                                      *
+   *                                                                         *
+   **************************************************************************/
+
+  public buildLocal(items: T[], idProperty?: string): IDataContext<T> {
+    return this.build(
+      LocalListDataSource.from(items, idProperty, this._localSort, FilterUtil.filterData)
+    );
+  }
+
+  public buildLocalActivePaged(
+    data: T[],
+    idProperty?: string
+  ): IDataContextActivePage<T> {
+    this._skipLocalSort = true;
+    this.activePaged();
+    return <IDataContextActivePage<T>>this.build(
+      LocalPagedDataSource.from(data, idProperty, this._localSort, FilterUtil.filterData)
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Empty Data Builder                                                      *
+   *                                                                         *
+   **************************************************************************/
+
+  public buildEmpty(): IDataContext<T> {
+    return this.build(
+      DelegateDataSource.emptyListFetcher()
+    );
+  }
+
+  public buildEmptyContinuable(): IDataContextContinuable<T> {
+    return <IDataContextContinuable<T>>this.build(
+      DelegateDataSource.emptyContinuableFetcher()
+    );
+  }
+
+  public buildEmptyActivePaged(): IDataContextActivePage<T> {
+    return <IDataContextActivePage<T>>this
+      .activePaged()
+      .build(
+        DelegateDataSource.emptyPageFetcher(),
+      );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Legacy Client Builder                                                   *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * @deprecated Switch to build(dataSource)
+   */
+  public buildClient(
+    dataSource: IListDataSource<T>
+  ): IDataContext<T> {
+    return this.build(dataSource);
+  }
+
+  /**
+   * @deprecated Switch to build(dataSource)
+   */
+  public buildPagedClient(
+    dataSource: IPagedDataSource<T>
+  ): IDataContextContinuable<T> {
+    return <IDataContextContinuable<T>>this.build(dataSource);
+  }
+
+  /**
+   * @deprecated Switch to build(dataSource)
+   */
+  public buildContinuationTokenClient(
+    dataSource: IContinuableDataSource<T>
+  ): IDataContextContinuable<T> {
+    return <IDataContextContinuable<T>>this.build(dataSource);
+  }
+
+  /**
+   * @deprecated Switch to .activePaged().build(dataSource)
+   */
+  public buildActivePagedClient(
+    dataSource: IPagedDataSource<T>
+  ): IDataContextActivePage<T> {
+    return <IDataContextActivePage<T>>this.activePaged().build(dataSource);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private buildFromSource(ds: IDataSource<T>): IDataContext<T> {
+
+    let dataContext: IDataContext<T>;
+
+    if (isListDataSource(ds)) {
+      dataContext = this.fromListSource(ds);
+    } else if (isPagedDataSource(ds)) {
+      if (this._activePaged) {
+        dataContext = this.fromActivePageSource(ds);
+      } else {
+        dataContext = this.fromPageSource(ds);
+      }
+    } else if (isContinuableDataSource(ds)) {
+      dataContext = this.fromContinuationSource(ds);
+    } else {
+      throw new Error('Unsupported IDataSource type: ' + typeof (ds));
+    }
+
+    if (this._autoStartSpec) {
+      this.setupDataContextAutoStart(dataContext, this._autoStartSpec);
+    }
+
+    return this.setupDataContextAutoReload(dataContext, ds);
+  }
+
+  private fromListSource(listSource: IListDataSource<T>): IDataContext<T> {
+    return new DataContextSimple<T>(
+      listSource,
+      this._indexFn,
+      this._localApply,
+      this._localSort
+    );
+  }
+
+  private fromPageSource(pageSource: IPagedDataSource<T>): IDataContextContinuable<T> {
+    return new DataContextContinuablePaged<T>(
+      pageSource,
+      this._pageSize,
+      this._indexFn,
+      this._localApply,
+      this._localSort
+    );
+  }
+
+  private fromContinuationSource(continuationSource: IContinuableDataSource<T>): IDataContextContinuable<T> {
+    return new DataContextContinuableToken<T>(
+      continuationSource,
+      this._pageSize,
+      this._indexFn,
+      this._localApply,
+      this._localSort
+    );
+  }
+
+  private fromActivePageSource(pageSource: IPagedDataSource<T>): IDataContextActivePage<T> {
+    return new DataContextActivePage<T>(
+      pageSource,
+      this._pageSize,
+      this._indexFn,
+      this._localApply,
+      this._skipLocalSort ? null : this._localSort
+    );
+  }
+
+  private setupDataContextAutoReload<DC extends IDataContext<T>>(dc: DC, dataSource: IDataSource<any>): DC {
+    if (this._reloadOnLocalChanges) {
+      const binding = new DataContextSourceAutoReloader(dc, dataSource);
+    }
+    return dc;
+  }
+
+  private setupDataContextAutoStart<DC extends IDataContext<T>>(dc: DC, autoStartSpec: AutoStartSpec): DC {
+    if (this._autoStartSpec) {
+      this.logger.debug('Setting up data context auto start with spec:', this._autoStartSpec);
+      const binding = new DataContextAutoStarter(dc, autoStartSpec);
+    }
+    return dc;
+  }
+
+}

package/src/lib/common/data/data-context/data-context-continuable-base.ts

@@ -0,0 +1,100 @@
+import {DataContextBase} from './data-context-base';
+import {Sort} from '../sort';
+import {Filter} from '../filters/filter';
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {Observable} from 'rxjs';
+import {IDataContextContinuable} from './data-context';
+import {IDataSource} from '../datasource/data-source';
+
+
+/**
+ * Extends a simple flat list data-context with infinite-scroll pagination support.
+ *
+ */
+export abstract class DataContextContinuableBase<T> extends DataContextBase<T> implements IDataContextContinuable<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly cblogger: Logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private _chunkSize: number;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructors                                                            *
+   *                                                                         *
+   **************************************************************************/
+
+  protected constructor(
+    dataSource: IDataSource<T>,
+    chunkSize: number,
+    indexFn: ((item: T) => any),
+    localApply: ((data: T[]) => T[]),
+    localSort: ((data: T[], sorts: Sort[]) => T[])
+  ) {
+    super(dataSource, indexFn, localApply, localSort);
+    this._chunkSize = chunkSize;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public loadAll(sorts?: Sort[], filters?: Filter[]): void {
+
+    this.cblogger.debug('Starting to load all data ...');
+
+    // load first page
+    this.start(sorts, filters)
+      .subscribe(() => {
+        this.cblogger.debug('First page has been loaded. Loading remaining data ...');
+        // load rest in a recursive manner
+        this.loadAllRec();
+      }, err => {
+        this.onError(err);
+        this.cblogger.error('Failed to load first page of load all procedure!', err);
+      });
+  }
+
+  public get chunkSize(): number {
+    return this._chunkSize;
+  }
+
+  public set chunkSize(size: number) {
+    if (this._chunkSize !== size) {
+      this._chunkSize = size;
+      this.onChunkSizeChanged(size);
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private Methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  protected onChunkSizeChanged(newSize: number): void {  }
+
+  private loadAllRec(): void {
+    this.loadMore()
+      .subscribe(() => {
+        this.cblogger.debug('Loading data chunk finished, loading next...');
+        this.loadAllRec();
+      }, err => {
+        this.onError(err);
+        this.cblogger.error('Loading all failed!', err);
+      }, () => {
+        this.cblogger.info('All data loaded completely.');
+      });
+  }
+
+  public abstract loadMore(): Observable<any>;
+  public abstract get hasMoreDataSnapshot(): boolean;
+  public abstract get hasMoreData(): Observable<boolean>;
+}

package/src/lib/common/data/data-context/data-context-continuable-paged.ts

@@ -0,0 +1,191 @@
+
+import {combineLatest, EMPTY, Observable, Subject} from 'rxjs';
+import {Page, Pageable} from '../page';
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {DataContextContinuableBase} from './data-context-continuable-base';
+import {first, map, takeUntil} from 'rxjs/operators';
+import {Sort} from '../sort';
+import {IPagedDataSource} from '../datasource/data-source';
+
+/**
+ * Extends a simple flat list data-context with infinite-scroll pagination support.
+ *
+ */
+export class DataContextContinuablePaged<T> extends DataContextContinuableBase<T> {
+
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+
+    private readonly logger: Logger = LoggerFactory.getLogger(this.constructor.name);
+
+    private _pageCache: Map<number, Observable<Page<T>>> = new Map();
+    private _latestPage = 0;
+
+    private readonly _hasMoreData: Observable<boolean>;
+
+    /***************************************************************************
+     *                                                                         *
+     * Constructors                                                            *
+     *                                                                         *
+     **************************************************************************/
+
+    constructor(
+        dataSource: IPagedDataSource<T>,
+        pageSize: number,
+        indexFn: ((item: T) => any),
+        localApply: ((data: T[]) => T[]),
+        localSort: ((data: T[], sorts: Sort[]) => T[])
+    ) {
+        super(dataSource, pageSize, indexFn, localApply, localSort);
+
+        this._hasMoreData = combineLatest([this.total, this.data]).pipe(
+          map(([total, data]) => this.checkHasMoreData(total, data)),
+          takeUntil(this.unsubscribe$)
+        );
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+
+    public get dataSource(): IPagedDataSource<T> {
+      return <IPagedDataSource<T>>super.dataSource;
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+
+    /**
+     * Load the next chunk of data.
+     * Useful for infinite scroll like data flows.
+     *
+     */
+    public loadMore(): Observable<any> {
+        if (this.hasMoreDataSnapshot) {
+            this.logger.info('Loading more...' + this._latestPage);
+
+            if (this.loadingSnapshot) { return EMPTY; }
+            const nextPage = this._latestPage + 1;
+            return this.fetchPage(nextPage, this.chunkSize);
+        } else {
+            this.logger.debug('Cannot load more data, since no more data available.');
+            return EMPTY;
+        }
+    }
+
+    public get hasMoreData(): Observable<boolean> {
+      return this._hasMoreData;
+    }
+
+    public get hasMoreDataSnapshot(): boolean {
+        return this.checkHasMoreData(this.totalSnapshot, this.dataSnapshot);
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+
+    private checkHasMoreData(total: number | undefined, data: T[]): boolean {
+      if (total) {
+        return total > data.length;
+      }
+      return false;
+    }
+
+    protected onChunkSizeChanged(newSize: number): void {
+        this.reload();
+    }
+
+    protected reloadInternal(): Observable<any> {
+
+      // Since continuable data-contexts are appending data,
+      // we need to clear it for a reload.
+      this.clearAll(true);
+
+      return this.fetchPage(0, this.chunkSize, true);
+    }
+
+    protected clearAll(silent = false): void {
+        super.clearAll(silent);
+        this._pageCache = new Map();
+        this._latestPage = 0;
+    }
+
+    private fetchPage(pageIndex: number, pageSize: number, clear = false): Observable<any> {
+
+        const subject = new Subject<void>();
+
+        const pageRequest = new Pageable(pageIndex, pageSize, this.sort.sortsSnapshot);
+
+        if (this._pageCache.has(pageIndex)) {
+            // Page already loaded - skipping request!
+            this.logger.trace('Skipping fetching page since its already in page observable cache.');
+            subject.next();
+        } else {
+
+            this.onLoading();
+
+            this.logger.debug(`Loading page ${pageIndex} using pageable:`, pageRequest);
+
+            const pageObs = this.dataSource.findAllPaged(pageRequest, this.filter.filtersSnapshot);
+
+            this._pageCache.set(pageIndex, pageObs);
+
+            pageObs.subscribe((page: Page<T>) => {
+
+
+                this.logger.debug('Got page data:', page);
+
+                this.populatePageData(page, clear);
+
+                if (this._latestPage < page.number) {
+                    this._latestPage = page.number; // TODO This might cause that pages are skipped
+                }
+
+                subject.next();
+                this.onIdle();
+            }, err => {
+                this.onError(err);
+                this.setData([]);
+                this.setTotal(0);
+                this.logger.error('Failed to query data', err);
+                subject.error(err);
+            });
+        }
+
+        return subject.pipe(first());
+    }
+
+    /**
+     * Load the data from the given page into the current data context
+     */
+    private populatePageData(page: Page<T>, clear: boolean): void {
+        try {
+            this.setTotal(page.totalElements);
+            const start = page.number * page.size;
+
+            const newData = clear ? [] : [...this.dataSnapshot];
+            for (let i = 0; i < page.content.length; i++) {
+                const item = page.content[i];
+                newData[i + start] = item;
+                this.indexItem(item);
+            }
+            this.setData(newData, true);
+        } catch (err) {
+            this.onError(err);
+            this.logger.error('Failed to populate data with page', page, err);
+        }
+    }
+
+
+}