@elderbyte/ngx-starter 14.11.0 → 14.11.1

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

@@ -0,0 +1,177 @@
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {ContinuableListing} from '../continuable-listing';
+import {DataContextContinuableBase} from './data-context-continuable-base';
+import {BehaviorSubject, EMPTY, Observable, Subject} from 'rxjs';
+import {first, take} from 'rxjs/operators';
+import {TokenChunkRequest} from '../token-chunk-request';
+import {Sort} from '../sort';
+import {IContinuableDataSource} from '../datasource/data-source';
+
+export class DataContextContinuableToken<T> extends DataContextContinuableBase<T> {
+
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger: Logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly _hasMoreData = new BehaviorSubject<boolean>(false);
+  private readonly _chunkCache: Set<string|undefined> = new Set();
+
+  private _expectedChunkToken?: string;
+
+  // protected nextContinuationToken?: string;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    dataSource: IContinuableDataSource<T>,
+    chunkSize: number,
+    indexFn: ((item: T) => any),
+    localApply: ((data: T[]) => T[]),
+    localSort: ((data: T[], sorts: Sort[]) => T[])
+  ) {
+    super(dataSource, chunkSize, indexFn, localApply, localSort);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get dataSource(): IContinuableDataSource<T> {
+    return <IContinuableDataSource<T>>super.dataSource;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get hasMoreDataSnapshot(): boolean {
+    return this._hasMoreData.getValue();
+  }
+
+  public get hasMoreData(): Observable<boolean> {
+    return this._hasMoreData.asObservable();
+  }
+
+  public loadMore(): Observable<any> {
+
+    if (this.loadingSnapshot) {
+      this.logger.debug('Skipping load-more since already loading a chunk!');
+      return EMPTY;
+    }
+
+    const token = this._expectedChunkToken;
+
+    if (token && token.length > 0) {
+      return this.fetchNextChunk(token);
+    } else {
+      this.logger.debug('Cannot load more data, since no more data available.');
+      return EMPTY;
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Protect API                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  protected clearAll(silent = false): void {
+    super.clearAll(silent);
+    this._chunkCache.clear();
+    this._hasMoreData.next(true);
+    this._expectedChunkToken = undefined;
+  }
+
+  protected reloadInternal(): Observable<any> {
+
+    // Since continuable data-contexts are appending data,
+    // we need to clear it for a reload.
+    this.clearAll(true);
+
+    return this.fetchNextChunk(undefined);
+  }
+
+  private fetchNextChunk(nextToken?: string): Observable<ContinuableListing<T>> {
+
+
+    const subject = new Subject<ContinuableListing<T>>();
+
+    nextToken = nextToken ? nextToken : undefined;
+
+    if (this._chunkCache.has(nextToken)) {
+      this.logger.debug('Skipping fetching chunk for token "' + nextToken + '" since its already in observable cache.');
+      subject.complete();
+    } else {
+
+      this.onLoading();
+
+      this._chunkCache.add(nextToken);
+
+      this.dataSource.findAllContinuable(new TokenChunkRequest(nextToken, this.filter.filtersSnapshot, this.sort.sortsSnapshot))
+        .pipe(first())
+        .subscribe(
+          chunk => {
+            this.logger.debug('Got next chunk data:', chunk);
+            this._hasMoreData.next(chunk.hasMore);
+            this.chunkSize = chunk.chunkSize;
+            this.populateChunkData(chunk);
+            subject.next(chunk);
+            this.onIdle();
+          }, err => {
+            this.onError(err);
+            this.logger.error('Failed to query data', err);
+            this.setData([]);
+            this.setTotal(0);
+            subject.error(err);
+          }
+        );
+    }
+    return subject.pipe(take(1));
+  }
+
+  /**
+   * Load the data from the given page into the current data context
+   */
+  private populateChunkData(chunk: ContinuableListing<T>): void {
+    if (this.areTokenEqual(chunk.continuationToken, this._expectedChunkToken)) {
+      try {
+        this.setTotal(chunk.total);
+
+        if (chunk.continuationToken) {
+          // We had previous chunks so append to current data.
+          this.appendData(chunk.content);
+        } else {
+          this.setData(chunk.content);
+        }
+
+      } catch (err) {
+        this.onError(err);
+        this.logger.error('Failed to populate data with chunk', chunk, err);
+      }
+      this._expectedChunkToken = chunk.nextContinuationToken;
+    } else {
+      this.logger.warn('Discarding continuable chunk (items: ' + chunk.content.length + ', token: ' + chunk.continuationToken + ' )' +
+        ' as it does not match the expected contiunation-token: ' + this._expectedChunkToken);
+    }
+  }
+
+  private areTokenEqual(token1?: string, token2?: string): boolean {
+    if (!token1 && !token2) { return true; }
+    return token1 === token2;
+  }
+
+
+}

package/src/lib/common/data/data-context/data-context-life-cycle-binding.ts

@@ -0,0 +1,59 @@
+import {Subscription, Unsubscribable} from 'rxjs';
+import {IDataContext} from './data-context';
+
+/**
+ * Allows making any kind of subscription which will be automatically unsubscribed
+ * upon data context closing/cleanup.
+ */
+export abstract class DataContextLifeCycleBinding implements Unsubscribable {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  protected _subscription: Subscription;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  protected constructor(
+    protected readonly _dataContext: IDataContext<any>
+  ) {
+    if (_dataContext == null) {
+      throw new Error('dataContext must not be null!');
+    }
+
+    this._dataContext.data.subscribe(
+      changed => {},
+      err => {},
+      () => this.unsubscribe()
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public unsubscribe(): void {
+    if (this._subscription) {
+      this._subscription.unsubscribe();
+      this._subscription = null;
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Protected                                                               *
+   *                                                                         *
+   **************************************************************************/
+
+  protected abstract subscribe(): void;
+
+}

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

@@ -0,0 +1,80 @@
+import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
+import {DataContextBase} from './data-context-base';
+import {Sort} from '../sort';
+import {Observable, Subject} from 'rxjs';
+import {first} from 'rxjs/operators';
+import {IListDataSource} from '../datasource/data-source';
+
+export class DataContextSimple<T> extends DataContextBase<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly log: Logger = LoggerFactory.getLogger(this.constructor.name);
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    dataSource: IListDataSource<T>,
+    indexFn: ((item: T) => any),
+    localApply: ((data: T[]) => T[]),
+    localSort: ((data: T[], sorts: Sort[]) => T[])
+  ) {
+    super(dataSource, indexFn, localApply, localSort);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get dataSource(): IListDataSource<T> {
+    return <IListDataSource<T>>super.dataSource;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  protected reloadInternal(): Observable<any> {
+
+    const subject = new Subject<void>();
+
+    if (this.dataSource) {
+
+      this.onLoading();
+
+      this.dataSource.findAllFiltered(this.filter.filtersSnapshot, this.sort.sortsSnapshot)
+        .pipe(first())
+        .subscribe(
+          list => {
+            this.onIdle();
+            this.setTotal(list.length);
+            this.setData(list);
+            this.log.debug('data-context: Got list data: ' + list.length);
+
+            subject.next();
+          }, err => {
+            this.onError(err);
+            this.clearAll();
+            this.log.error('data-context: Failed to query data', err);
+            subject.error(err);
+          });
+    } else {
+      this.log.warn('data-context: Skipping data context load - no list fetcher present!');
+      subject.error(new Error('data-context: Skipping data context load - no list fetcher present!'));
+    }
+
+    return subject.pipe(first());
+  }
+}

package/src/lib/common/data/data-context/data-context-source-auto-reloader.ts

@@ -0,0 +1,21 @@
+import {IDataContext} from './data-context';
+import {IDataSource} from '../datasource/data-source';
+import {DataContextLifeCycleBinding} from './data-context-life-cycle-binding';
+
+export class DataContextSourceAutoReloader extends DataContextLifeCycleBinding {
+
+  constructor(
+    dataContext: IDataContext<any>,
+    private readonly dataApi: IDataSource<any>
+  ) {
+    super(dataContext);
+
+    this.subscribe();
+  }
+
+  protected subscribe(): void {
+    this._subscription = this.dataApi.dataChanged.subscribe(
+      () => this._dataContext.reload()
+    );
+  }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Represents the status of a data-context
+ */
+export class DataContextStatus {
+
+    /***************************************************************************
+     *                                                                         *
+     * Static builders                                                         *
+     *                                                                         *
+     **************************************************************************/
+
+    public static idle(): DataContextStatus {
+      return new DataContextStatus(null);
+    }
+
+    public static error(error: any): DataContextStatus {
+        return new DataContextStatus(error);
+    }
+
+    public static loading(): DataContextStatus {
+      return new DataContextStatus(null, true);
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Constructors                                                            *
+     *                                                                         *
+     **************************************************************************/
+
+    constructor(
+        private readonly _error: any,
+        private readonly _loading = false
+    ) {}
+
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+
+    public get idle(): boolean {
+      return !this.loading && !this.error;
+    }
+
+    public get loading(): boolean {
+      return this._loading;
+    }
+
+    public get error(): any {
+        return this._error;
+    }
+
+    public get hasError(): boolean {
+        return !!this._error;
+    }
+}

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

@@ -0,0 +1,204 @@
+import {DataContextStatus} from './data-context-status';
+import {Observable} from 'rxjs';
+import {Sort} from '../sort';
+import {Filter} from '../filters/filter';
+import {FilterContext} from '../filters/filter-context';
+import {PageRequest} from '../page';
+import {SortContext} from '../sort-context';
+import {IDataSource} from '../datasource/data-source';
+
+
+export class DataContextSnapshot<T> {
+  constructor(
+    public readonly data: T[],
+    public readonly isEmpty: boolean,
+    public readonly isLoading: boolean,
+    public readonly total: number | undefined,
+    public readonly status: DataContextStatus
+  ) { }
+}
+
+/**
+ * Manages a set of data (rows) which are to be displayed in a UI Component.
+ *
+ */
+export interface IDataContext<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Gets the underlying DataSource of this DataContext.
+   */
+  readonly dataSource: IDataSource<T>;
+
+  /**
+   * Gets a snapshot of the current state in this data-context
+   */
+  readonly snapshot: DataContextSnapshot<T>;
+
+  /**
+   * Observable which emits the current data over time.
+   */
+  readonly data: Observable<T[]>;
+
+  /**
+   * Indicates if the context currently holds no data
+   */
+  readonly isEmpty: boolean;
+
+  /**
+   * Indicates if the context has been started.
+   */
+  readonly isStarted: boolean;
+
+  /**
+   * Indicates if the context has been started.
+   */
+  readonly isStarted$: Observable<boolean>;
+
+  /**
+   * Indicates if the context has been closed.
+   * Depending on the implementation, restarting might not be possible.
+   */
+  readonly isClosed: boolean;
+
+  /**
+   * Indicates if data is loading over time
+   */
+  readonly loading: Observable<boolean>;
+
+  /**
+   * The total count of all elements over time
+   * (I.e. the expected count when the data contex is completed)
+   */
+  readonly total: Observable<number | undefined>;
+
+  /**
+   * Observable which emits when the status changes (i.e. error)
+   */
+  readonly status: Observable<DataContextStatus>;
+
+  /**
+   * Gets the sort context. Changes in this context are reflected by the data-context.
+   */
+  readonly sort: SortContext;
+
+  /**
+   * Gets the filter context. Changes in this context are reflected by the data-context.
+   */
+  readonly filter: FilterContext;
+
+  /***************************************************************************
+   *                                                                         *
+   * API                                                                     *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Starts populating data context by loading first
+   * batch of data.
+   */
+  start(sorts?: Sort[], filters?: Filter[]): Observable<any>;
+
+  /**
+   * Requests a reload of the current data / chunk.
+   * Attempts to keep the current position.
+   */
+  reload(): void;
+
+  /**
+   * Refresh the data view from the local data model. (Does not request new data from the server)
+   * Useful if the data model has changes that need to be reflected in the UI.
+   */
+  refresh(): void;
+
+  /**
+   * Closes the data-context and cleans up resources
+   */
+  close(): void;
+
+  /**
+   * Returns the item by the given index key.
+   * Requires that index functionality is enabled.
+   * @param key
+   */
+  findByIndex(key: any): T | undefined;
+
+}
+
+/**
+ * Represents a data-context which backs a infinite like data stream
+ * where more data will be loaded and added to the backing rows.
+ */
+export interface IDataContextContinuable<T> extends IDataContext<T> {
+
+  /**
+   * Returns true if this data-context can load more data
+   */
+  readonly hasMoreDataSnapshot: boolean;
+
+  /**
+   * Returns true if this data-context can load more data over time
+   */
+  readonly hasMoreData: Observable<boolean>;
+
+  /**
+   * Loads more data if any available.
+   * E.g. next page.
+   *
+   */
+  loadMore(): Observable<any>;
+
+  /**
+   * Loads all available data. In case of
+   * paged context loads page by page until finished.
+   */
+  loadAll(sorts?: Sort[], filters?: Filter[]): void;
+
+}
+
+export interface IDataContextActivePage<T> extends IDataContext<T> {
+
+  /**
+   * Gets the active page over time
+   */
+  readonly page: Observable<PageRequest>;
+
+  /**
+   * Gets the current active page
+   */
+  readonly pageSnapshot: PageRequest;
+
+  /**
+   * Sets the active page
+   */
+  setActivePage(page: PageRequest): void;
+}
+
+/***************************************************************************
+ *                                                                         *
+ * Type Predicates                                                         *
+ *                                                                         *
+ **************************************************************************/
+
+export function isDataContext(object: any): object is IDataContext<any> {
+
+  if (!object) { return false; }
+
+  return (object as IDataContext<any>).data !== undefined
+    && (object as IDataContext<any>).start !== undefined
+    && (object as IDataContext<any>).reload !== undefined
+    && (object as IDataContext<any>).refresh !== undefined;
+}
+
+export function isContinuableDataContext(object: IDataContext<any>): object is IDataContextContinuable<any> {
+  return (object as IDataContextContinuable<any>).loadMore !== undefined;
+}
+
+export function isActivePagedDataContext(object: IDataContext<any>): object is IDataContextActivePage<any> {
+  return (object as IDataContextActivePage<any>).setActivePage !== undefined;
+}