@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

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

@@ -1,209 +0,0 @@
-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

@@ -1,19 +0,0 @@
-
-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

@@ -1,96 +0,0 @@
-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

@@ -1,318 +0,0 @@
-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;
-  }
-
-}
-