@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

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

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

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

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