@elderbyte/ngx-starter 14.10.0 → 14.11.1

package/src/lib/common/data/data-context/mat-table-data-context-binding.ts

@@ -0,0 +1,209 @@
+import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import { MatSort, SortDirection as MatSortDirection } from '@angular/material/sort';
+import {IDataContext, IDataContextActivePage, isActivePagedDataContext} from './data-context';
+import {combineLatest, merge, Observable, Subject, Unsubscribable} from 'rxjs';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {filter, map, mergeAll, mergeMap, switchMap, takeUntil} from 'rxjs/operators';
+import {Sort, SortDirection} from '../sort';
+import {PageRequest} from '../page';
+
+
+export class MatTableDataContextBindingBuilder {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private _dataContext$: Observable<IDataContext<any>>;
+  private _sorts$: Observable<MatSort[]>;
+  private _matPaginator$: Observable<MatPaginator>;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  public static start(dataContext$: Observable<IDataContext<any>>): MatTableDataContextBindingBuilder {
+    return new MatTableDataContextBindingBuilder(dataContext$);
+  }
+
+  constructor(dataContext$: Observable<IDataContext<any>>) {
+    this._dataContext$ = dataContext$;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public withSorts(sorts$: Observable<MatSort[]>): this {
+    this._sorts$ = sorts$;
+    return this;
+  }
+
+  public withPaginator(paginator$: Observable<MatPaginator>): this {
+    this._matPaginator$ = paginator$;
+    return this;
+  }
+
+  public bindUntil(destroy$: Observable<any>): MatTableDataContextBinding {
+    return new MatTableDataContextBinding(
+      this._dataContext$,
+      this._sorts$,
+      this._matPaginator$,
+      destroy$
+    );
+  }
+
+}
+
+export class MatTableDataContextBinding {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger(this.constructor.name);
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private readonly _dataContext$: Observable<IDataContext<any>>,
+    private readonly _matSorts$: Observable<MatSort[]> | null,
+    private readonly _matPaginator$: Observable<MatPaginator> | null,
+    destroy$: Observable<any>
+  ) {
+    this.subscribeUntil(destroy$);
+  }
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private subscribeUntil(destroy$: Observable<any>): void {
+    if (this._matSorts$) {
+      this.bindMatSortsToDataContextUntil(this._matSorts$, destroy$);
+      this.bindDataContextToMatSortsUntil(this._matSorts$, destroy$);
+    }
+
+    if (this._matPaginator$) {
+      this.bindPaginatorUntil(this._matPaginator$, destroy$);
+    }
+  }
+
+  private bindDataContextToMatSortsUntil(matSorts$: Observable<MatSort[]>, destroy$: Observable<any>): void {
+
+    const dcSorts$ = this._dataContext$.pipe(
+      filter(dc => !!dc),
+      switchMap(dc => dc.sort.sorts)
+    );
+
+    combineLatest([dcSorts$, matSorts$]).pipe(
+      takeUntil(destroy$),
+    ).subscribe(([dcSorts, matSorts]) => {
+
+      if (dcSorts.length >= 1) {
+        // At least one sort active
+        const sort = dcSorts[0];
+        this.updateMatSorts(sort, matSorts);
+      } else {
+        // No sort active
+        this.updateMatSorts(Sort.NONE, matSorts);
+      }
+    });
+  }
+
+  private updateMatSorts(dcSort: Sort, matSorts: MatSort[]): void {
+    const active = dcSort.prop;
+    const direction = this.toMatDirection(dcSort.dir);
+    matSorts.forEach(matSort => this.updateMatSort(active, direction, matSort));
+  }
+
+  private updateMatSort(
+    activeProp: string,
+    direction: MatSortDirection,
+    matSort: MatSort
+  ): void {
+
+    if (activeProp) {
+      if (!matSort.sortables.has(activeProp)) {
+        // The current sort property is not part of this MatSort.
+        activeProp = Sort.NONE.prop; // Force no sort in this mat context
+      }
+    }
+
+    if (matSort.active !== activeProp || matSort.direction !== direction) {
+      // We do only update matSort when there was a real change
+      matSort.active = activeProp;
+      matSort.direction = direction;
+      matSort._stateChanges.next();
+    }
+  }
+
+
+
+  private bindMatSortsToDataContextUntil(sorts$: Observable<MatSort[]>, destroy$: Observable<any>): void {
+
+    const sortChanges$ = sorts$.pipe(
+      mergeMap(sorts => merge(...sorts.map(s => s.sortChange))),
+      map(matSort => {
+        return new Sort(
+          matSort.active,
+          this.fromMatDirection(matSort.direction)
+        );
+      })
+    );
+
+    combineLatest([this._dataContext$, sortChanges$]).pipe(
+      takeUntil(destroy$),
+    ).subscribe(([dc, sortRequest]) => {
+      if (dc) {
+        dc.sort.updateSort(sortRequest);
+      }
+    });
+  }
+
+  private bindPaginatorUntil(paginator$: Observable<MatPaginator>, destroy$: Observable<any>): void {
+
+    const pageRequest$ = paginator$.pipe(
+      filter(paginator => !!paginator),
+      switchMap(paginator => paginator.page),
+      map(pageEvent => new PageRequest(pageEvent.pageIndex, pageEvent.pageSize))
+    );
+
+    combineLatest([this._dataContext$, pageRequest$]).pipe(
+      takeUntil(destroy$),
+    ).subscribe(([dc, pageRequest]) => {
+      if (dc) {
+        if (isActivePagedDataContext(dc)) {
+          const pagedDc = dc as IDataContextActivePage<any>;
+          pagedDc.setActivePage(pageRequest);
+        } else {
+          this.logger.warn('Can not bind the given paginator to the given data-context,' +
+            ' as the datacontext does not support pagination!', dc);
+        }
+      }
+    });
+  }
+
+  private toMatDirection(direction: SortDirection): MatSortDirection {
+    return direction;
+  }
+
+  private fromMatDirection(matSortDirection: MatSortDirection): SortDirection {
+    return matSortDirection;
+  }
+}

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

@@ -0,0 +1,19 @@
+
+export * from './data-context-status';
+export * from './data-context';
+export * from './data-context-base';
+export * from './data-context-simple';
+export * from './data-context-continuable-base';
+export * from './data-context-continuable-paged';
+export * from './data-context-continuable-token';
+export * from './data-context-active-page';
+
+export * from './mat-table-data-context-binding';
+export * from './data-context-life-cycle-binding';
+export * from './data-context-auto-starter';
+export * from './data-context-source-auto-reloader';
+
+export * from './data-context-builder';
+
+
+

package/src/lib/common/data/datasource/data-source-adapter.ts

@@ -0,0 +1,96 @@
+import {IDataSource, isContinuableDataSource, isListDataSource, isPagedDataSource} from './data-source';
+import {EMPTY, Observable} from 'rxjs';
+import {Filter} from '../filters/filter';
+import {Sort} from '../sort';
+import {Pageable} from '../page';
+import {filter, map} from 'rxjs/operators';
+import {TokenChunkRequest} from '../token-chunk-request';
+
+export class DataSourceAdapter<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  public static from<T>(dataSource: IDataSource<T>): DataSourceAdapter<T> {
+    return new DataSourceAdapter<T>(dataSource);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private readonly dataSource: IDataSource<T>,
+  ) {
+
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Returns the first item which matches the given filter / sort
+   * @param filters
+   * @param sorts
+   */
+  public findFirst(
+    filters: Filter[],
+    sorts: Sort[] = []
+  ): Observable<T> {
+    return this.findAll(filters, sorts, 1).pipe(
+      filter(data => (data && data.length > 0)),
+      map(data => data[0])
+    );
+  }
+
+  /**
+   * Find all items which match the given filters.
+   */
+  public findAll(
+    filters: Filter[],
+    sorts: Sort[] = [],
+    limit = 50
+  ): Observable<T[]> {
+    if (isListDataSource(this.dataSource)) {
+      return this.dataSource.findAllFiltered(
+        filters,
+        sorts
+      );
+    } else if (isPagedDataSource(this.dataSource)) {
+      return this.dataSource.findAllPaged(
+        new Pageable(0, limit, sorts),
+        filters
+      ).pipe(
+        map(page => page.content)
+      );
+    } else if (isContinuableDataSource(this.dataSource)) {
+      return this.dataSource.findAllContinuable(
+        new TokenChunkRequest(null, filters, sorts)
+      ).pipe(
+        map(page => page.content)
+      );
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+}

package/src/lib/common/data/datasource/data-source-processor.ts

@@ -0,0 +1,318 @@
+import {
+  IContinuableDataSource,
+  IDataSource, IListDataSource,
+  IPagedDataSource,
+  isContinuableDataSource,
+  isListDataSource,
+  isPagedDataSource
+} from './data-source';
+import {Page, Pageable} from '../page';
+import {Filter} from '../filters/filter';
+import {TokenChunkRequest} from '../token-chunk-request';
+import {ContinuableListing} from '../continuable-listing';
+import {Sort} from '../sort';
+import {Observable} from 'rxjs/internal/Observable';
+import {map, switchMap, takeWhile, tap} from 'rxjs/operators';
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {BehaviorSubject} from 'rxjs';
+
+
+export enum ProcessState {
+
+  INIT = 'INIT',
+
+  RUNNING = 'RUNNING',
+
+  COMPLETED = 'COMPLETED',
+
+  ERROR = 'ERROR'
+
+}
+
+export class ProcessIterationContext<T> {
+
+  public static init<T>(): ProcessIterationContext<T> {
+    return new ProcessIterationContext(ProcessState.INIT);
+  }
+
+  public static processingList<T> (list: T[]): ProcessIterationContext<T> {
+    return new ProcessIterationContext(ProcessState.RUNNING, list);
+  }
+
+  public static processingPage<T>(currentPage: Page<T>): ProcessIterationContext<T> {
+    return new ProcessIterationContext(ProcessState.RUNNING, null, currentPage);
+  }
+
+  public static processingContinuable<T>(currentChunk: ContinuableListing<T>): ProcessIterationContext<T> {
+    return new ProcessIterationContext(ProcessState.RUNNING, null, null, currentChunk);
+  }
+
+  public static completed<T>(): ProcessIterationContext<T> {
+    return new ProcessIterationContext(ProcessState.COMPLETED);
+  }
+
+  public static error<T>(): ProcessIterationContext<T> {
+    return new ProcessIterationContext(ProcessState.ERROR);
+  }
+
+  public constructor(
+    public readonly state: ProcessState,
+    public readonly items?: T[],
+    public readonly page?: Page<T>,
+    public readonly continuable?: ContinuableListing<T>
+  ) {
+    if (page) { this.items = page.content; }
+    if (continuable) { this.items = continuable.content; }
+  }
+}
+
+export class DataSourceProcessor<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly log: Logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly _dataSource: IDataSource<T>;
+  private readonly _chunkSize;
+  private readonly _process$ = new BehaviorSubject<ProcessIterationContext<T>>(ProcessIterationContext.init());
+
+  /***************************************************************************
+   *                                                                         *
+   * Static                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  public static start<T>(
+    dataSource: IDataSource<T>,
+    chunkSize?: number
+  ): DataSourceProcessor<T> {
+    return new DataSourceProcessor(
+      dataSource,
+      chunkSize
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  protected constructor(
+    dataSource: IDataSource<T>,
+    chunkSize?: number
+  ) {
+    this._dataSource = dataSource;
+    this._chunkSize = chunkSize || 100;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get dataSource(): IDataSource<T> {
+    return this._dataSource;
+  }
+
+  protected get listDataSource(): IListDataSource<T> {
+    return this.dataSource as IListDataSource<T>;
+  }
+
+  protected get pagedDataSource(): IPagedDataSource<T> {
+    return this.dataSource as IPagedDataSource<T>;
+  }
+
+  protected get continuableDataSource(): IContinuableDataSource<T> {
+    return this.dataSource as IContinuableDataSource<T>;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Allows to iterative load and process the contents of the
+   * data source in scope.
+   *
+   * @param processFn to iterative execute upon each item of each iteration
+   * @param filters to filter the data source
+   * @param sorts to sort the data source
+   */
+  public process$(
+    processFn: (dataChunk: T[]) => any,
+    filters: Filter[],
+    sorts: Sort[]
+  ): Observable<ProcessIterationContext<T>> {
+    return this._process$.pipe(
+      takeWhile(ctx => this.notCompleted(ctx)),
+      switchMap(ctx => this.loadNext(ctx, filters, sorts)),
+      tap(updatedCtx => {
+        processFn(updatedCtx.items);
+        this._process$.next(updatedCtx);
+      })
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Loading                                                                 *
+   *                                                                         *
+   **************************************************************************/
+
+  private loadNext(
+    currentCtx: ProcessIterationContext<T>,
+    filters: Filter[],
+    sorts: Sort[]
+  ): Observable<ProcessIterationContext<T>> {
+
+    let updatedCtx$: Observable<ProcessIterationContext<T>>;
+    if (isListDataSource(this._dataSource)) {
+      updatedCtx$ = this.loadList(filters, sorts);
+    } else if (isPagedDataSource(this._dataSource)) {
+      updatedCtx$ = this.loadNextPage(currentCtx.page, filters, sorts);
+    } else if (isContinuableDataSource(this._dataSource)) {
+      updatedCtx$ = this.loadNextContinuable(currentCtx.continuable, filters, sorts);
+    } else {
+      throw new Error('Unsupported DataSource!');
+    }
+
+    return updatedCtx$;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * List                                                                    *
+   *                                                                         *
+   **************************************************************************/
+
+  private loadList(filters: Filter[], sorts: Sort[]): Observable<ProcessIterationContext<T>> {
+
+    this.log.debug('Loading list with filters and sorts...', [filters, sorts]);
+
+    return this.listDataSource.findAllFiltered(filters, sorts)
+      .pipe(
+        map(page => this.listIteration(page))
+      );
+  }
+
+  private listIteration(
+    items: T[]
+  ): ProcessIterationContext<T> {
+    return new ProcessIterationContext(
+      ProcessState.COMPLETED,
+      items,
+      null,
+      null
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Paged                                                                   *
+   *                                                                         *
+   **************************************************************************/
+
+  private loadNextPage(
+    currentPage: Page<T>,
+    filters: Filter[],
+    sorts: Sort[]
+  ): Observable<ProcessIterationContext<T>> {
+
+    const nextPageRequest = currentPage
+      ? Page.nextPageable(currentPage, sorts)
+      : new Pageable(0, this._chunkSize, sorts);
+
+    this.log.debug('Loading next page...', [nextPageRequest, filters, sorts]);
+
+    return this.pagedDataSource.findAllPaged(nextPageRequest, filters)
+      .pipe(
+        map(page => this.pageIteration(page))
+      );
+  }
+
+  private pageIteration(
+    page: Page<T>
+  ): ProcessIterationContext<T> {
+    return new ProcessIterationContext(
+      this.pageIterationState(page),
+      null,
+      page,
+      null
+    );
+  }
+
+  private pageIterationState(page: Page<T>): ProcessState {
+    return Page.hasNext(page)
+      ? ProcessState.RUNNING
+      : ProcessState.COMPLETED;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Continuable                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  private loadNextContinuable(
+    currentChunk: ContinuableListing<T>,
+    filters: Filter[],
+    sorts: Sort[]
+  ): Observable<ProcessIterationContext<T>> {
+
+    const nextChunkRequest = currentChunk
+      ? new TokenChunkRequest(currentChunk.nextContinuationToken, filters, sorts)
+      : new TokenChunkRequest(null, filters, sorts);
+
+    this.log.debug('Loading next chunk...', [nextChunkRequest, filters, sorts]);
+
+    return this.continuableDataSource.findAllContinuable(nextChunkRequest)
+      .pipe(
+        map(chunk => this.continuableIteration(chunk))
+      );
+  }
+
+  private continuableIteration(
+    chunk: ContinuableListing<T>,
+  ): ProcessIterationContext<T> {
+    return new ProcessIterationContext(
+      this.continuableIterationState(chunk),
+      null,
+      null,
+      chunk
+    );
+  }
+
+  private continuableIterationState(chunk: ContinuableListing<T>): ProcessState {
+    return chunk.hasMore
+      ? ProcessState.RUNNING
+      : ProcessState.COMPLETED;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private Methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private notCompleted(ctx: ProcessIterationContext<T>): boolean {
+    const completed = ctx.state === ProcessState.COMPLETED;
+
+    if (completed) {
+      this.log.debug('Process completed with context', ctx);
+    } else {
+      this.log.debug('Starting next process iteration, current iteration context:', ctx);
+    }
+
+    return !completed;
+  }
+
+}
+