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

package/src/lib/common/data/datasource/rest/rest-client.ts

@@ -0,0 +1,474 @@
+import {HttpClient, HttpParams} from '@angular/common/http';
+import {EMPTY, forkJoin, Observable, of, Subject} from 'rxjs';
+import {expand, map, mergeAll, reduce, tap} from 'rxjs/operators';
+import {HttpParamsBuilder} from '../../http-params-builder';
+import {Sort} from '../../sort';
+import {Filter} from '../../filters/filter';
+import {Page, Pageable} from '../../page';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {ContinuableListing} from '../../continuable-listing';
+import {TokenChunkRequest} from '../../token-chunk-request';
+import {IContinuableDataSource, IDataSource, IListDataSource, IPagedDataSource} from '../data-source';
+import {EntityIdUtil} from '../entity-id-util';
+import {Batcher} from '../../../utils/batcher';
+
+export class InternalRestClientConfig {
+
+  public idField = 'id';
+  public idsParam = 'ids';
+
+  constructor(userConfig?: RestClientConfig) {
+    if (userConfig) {
+      if (userConfig.idField) {
+        this.idField = userConfig.idField;
+      }
+      if (userConfig.idsParam) {
+        this.idsParam = userConfig.idsParam;
+      }
+    }
+  }
+}
+
+/**
+ * Allows to customize the rest client
+ */
+export class RestClientConfig {
+
+  /**
+   * The field to use as id. Defaults to 'id'.
+   */
+  public idField?: string;
+
+  /**
+   * The query param to use for multiple ids. Defaults to 'ids'
+   */
+  public idsParam?: string;
+}
+
+
+export class RestClient<T, TID> implements IDataSource<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly _logger = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly localChangeSubject = new Subject<T>();
+  protected readonly config: InternalRestClientConfig;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    protected readonly restEndpoint: string,
+    protected readonly http: HttpClient,
+    config?: RestClientConfig
+  ) {
+    this.config = new InternalRestClientConfig(config);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get dataChanged(): Observable<T> {
+    return this.localChangeSubject.asObservable();
+  }
+
+  /**
+   * @deprecated Use dataChanged
+   */
+  public get localChanged(): Observable<T> {
+    return this.dataChanged;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public findById(id: TID, params?: HttpParams): Observable<T> {
+    params = HttpParamsBuilder.start(params).build();
+    return this.http.get<T>(this.getEntityUrl(id), {params: params});
+  }
+
+  public findByIds(ids: any[], params?: HttpParams): Observable<T[]> {
+    this._logger.warn('Very inefficient findByIds handling ' + ids.length);
+    return forkJoin(
+      ids.map(id => this.findById(id, params))
+    );
+  }
+
+  /**
+   * Creates or Updates the given entity depending if it already has a valid id.
+   */
+  public save(entity: T, params?: HttpParams): Observable<T> {
+    const id = this.getId(entity);
+    return ((!!id) ? this.update(entity, params) : this.create(entity, params));
+  }
+
+  public create<TC = T>(newEntity: TC, params?: HttpParams): Observable<T> {
+    return this.http.post<T>(this.restEndpoint, newEntity, {
+      params: params
+    })
+      .pipe(
+        tap(e => this.onLocalChanged(e))
+      );
+  }
+
+  public update(updatedEntity: T, params?: HttpParams): Observable<T> {
+    return this.http.put<T>(
+      this.getEntityUrlBy(updatedEntity),
+      updatedEntity,
+      {
+        params: params
+      }
+    )
+      .pipe(
+        tap(e => this.onLocalChanged(e))
+      );
+  }
+
+  public updateAll(updatedEntities: T[], params?: HttpParams): Observable<T[]> {
+
+    return this.http.put<T[]>(
+      this.restEndpoint, updatedEntities, {
+        params: params
+      })
+      .pipe(
+        tap(e => this.onLocalChanged())
+      );
+  }
+
+  public delete(entity: T, params?: HttpParams): Observable<any> {
+
+    return this.http.delete(
+      this.getEntityUrlBy(entity),
+      {
+        responseType: 'text',
+        params: params
+      }
+    ).pipe(
+      tap(() => this.onLocalChanged(entity))
+    );
+  }
+
+  public deleteAll(entities: T[], params?: HttpParams): Observable<any> {
+    const ids = entities.map(e => String(this.getId(e)));
+
+    const maxBatchSize = 100;
+    const deleteRequests = Batcher.batchMap(
+      ids,
+      maxBatchSize,
+      batch => this.deleteIdBatch(batch, params)
+    );
+    this._logger.debug('Deleting ' + entities.length + ' in ' + deleteRequests.length + ' batches: ', deleteRequests);
+    return forkJoin(deleteRequests);
+  }
+
+  public getId(entity: T): TID {
+    return EntityIdUtil.getId(entity, this.config.idField);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Sub Resource Builder                                                    *
+   *                                                                         *
+   **************************************************************************/
+
+  public subResourceList<TS, TSID>(parent: T, subPath: string, config?: RestClientConfig): RestClientList<TS, TSID> {
+    return new RestClientList(
+      this.getEntityUrlBy(parent) + '/' + subPath,
+      this.http,
+      config
+    );
+  }
+
+  public subResourcePaged<TS, TSID>(parent: T, subPath: string, config?: RestClientConfig): RestClientPaged<TS, TSID> {
+    return new RestClientPaged(
+      this.getEntityUrlBy(parent) + '/' + subPath,
+      this.http,
+      config
+    );
+  }
+
+  public subResourceContinuable<TS, TSID>(parent: T, subPath: string, config?: RestClientConfig): RestClientContinuable<TS, TSID> {
+    return new RestClientContinuable(
+      this.getEntityUrlBy(parent) + '/' + subPath,
+      this.http,
+      config
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Protected methods                                                       *
+   *                                                                         *
+   **************************************************************************/
+
+  protected patchInternal<P, R = T>(id: TID, entityPatch: P, params?: HttpParams): Observable<R> {
+    return this.http.patch<R>(
+      this.getEntityUrl(id),
+      entityPatch,
+      {
+        params: params
+      }
+    ).pipe(
+      tap(e => this.onLocalChanged())
+    );
+  }
+
+  protected patchAllInternal<P, R = T>(entityPatches: P[], params?: HttpParams): Observable<R[]> {
+    return this.http.patch<R[]>(
+      this.restEndpoint,
+      entityPatches,
+      {
+        params: params
+      }
+    ).pipe(
+      tap(e => this.onLocalChanged())
+    );
+  }
+
+  protected onLocalChanged(entity?: T): void {
+    this.localChangeSubject.next(entity);
+  }
+
+  protected getEntityUrlBy(entity: T): string {
+    return this.getEntityUrl(this.getId(entity));
+  }
+
+  protected getEntityUrl(id: TID): string {
+    return this.restEndpoint + '/' + id;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Deletes the given ids in a batch call.
+   * Note that due HTTP Request URI limitations,
+   * the number of ids that can be deleted in a single batch is
+   * limited (around 150, depending on id length, since they are
+   * part of the request uri parameters.
+   */
+  private deleteIdBatch(ids: string[], params?: HttpParams): Observable<any> {
+    const builder = HttpParamsBuilder.start(params);
+    builder.appendFilter(new Filter(this.config.idsParam, ids));
+    return this.http.delete(this.restEndpoint,
+      {
+        params: builder.build(),
+        responseType: 'text'
+      })
+      .pipe(
+        tap(() => this.onLocalChanged())
+      );
+  }
+}
+
+
+export class RestClientList<T, TID> extends RestClient<T, TID> implements IListDataSource<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    restEndpoint: string,
+    http: HttpClient,
+    config?: RestClientConfig
+  ) {
+    super(restEndpoint, http, config);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public findAllFiltered(
+    filters?: Filter[],
+    sorts?: Sort[],
+    params?: HttpParams
+  ): Observable<T[]> {
+    return this.findAll(
+      HttpParamsBuilder.start(params)
+        .appendFilters(filters)
+        .appendSorts(sorts)
+        .build()
+    );
+  }
+
+  public findByIds(ids: any[], params?: HttpParams): Observable<T[]> {
+    if (ids?.length > 0) {
+      return this.findAllFiltered(
+        [new Filter(this.config.idsParam, ids)],
+        [],
+        params
+      );
+    } else {
+      return of([]);
+    }
+  }
+
+  public findAll(params?: HttpParams): Observable<T[]> {
+    return this.http.get<T[]>(this.restEndpoint, {
+      params: params
+    });
+  }
+
+
+}
+
+export class RestClientPaged<T, TID> extends RestClient<T, TID> implements IPagedDataSource<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    restEndpoint: string,
+    http: HttpClient,
+    config?: RestClientConfig
+  ) {
+    super(restEndpoint, http, config);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public findAllPaged(pageable: Pageable, filters?: Filter[], params?: HttpParams): Observable<Page<T>> {
+    return this.getPaged(this.restEndpoint, pageable, filters, params);
+  }
+
+  public findByIds(ids: any[], params?: HttpParams): Observable<T[]> {
+    if (ids?.length > 0) {
+      return this.findAllPaged(
+        new Pageable(0, ids.length),
+        [new Filter(this.config.idsParam, ids)],
+        params
+      ).pipe(
+        map(page => page.content)
+      );
+    } else {
+      return of([]);
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+
+  /**
+   * Gets the requested data page as Page<T>
+   * @param url The resource url
+   * @param pageable The page request
+   * @param filters The filtersSnapshot request
+   * @param params Additional parameters
+   */
+  private getPaged(url: string, pageable: Pageable, filters?: Filter[], params?: HttpParams): Observable<Page<T>> {
+    params = HttpParamsBuilder.start(params)
+      .appendPageable(pageable)
+      .appendFilters(filters)
+      .build();
+    return this.http.get<Page<T>>(url, {params: params});
+  }
+
+}
+
+export class RestClientContinuable<T, TID> extends RestClient<T, TID> implements IContinuableDataSource<T> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    restEndpoint: string,
+    http: HttpClient,
+    config?: RestClientConfig
+  ) {
+    super(restEndpoint, http, config);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public findAllContinuable(request: TokenChunkRequest, params?: HttpParams): Observable<ContinuableListing<T>> {
+    return this.http.get<ContinuableListing<T>>(this.restEndpoint,
+      {
+        params: HttpParamsBuilder.start(params)
+          .appendContinuationRequest(request)
+          .build()
+      }
+    );
+  }
+
+  public findByIds(ids: any[], params?: HttpParams): Observable<T[]> {
+    if (ids?.length > 0) {
+      return this.loadAll(
+        [new Filter(this.config.idsParam, ids)],
+        [],
+        params
+      );
+    } else {
+      return of([]);
+    }
+  }
+
+  private loadAll(
+    filters?: Filter[],
+    sorts?: Sort[],
+    params?: HttpParams
+  ): Observable<T[]> {
+    return this.findAllContinuable(
+      new TokenChunkRequest(null, filters, sorts),
+      params
+    ).pipe(
+      expand((listing) => { // the previous "listing" -> This is recursive
+        return listing.nextContinuationToken // if there's "nextContinuationToken", we refetch or we EMPTY to complete the "expand()"
+          ? this.findAllContinuable(
+            new TokenChunkRequest(listing.nextContinuationToken, filters, sorts),
+            params
+          )
+          : EMPTY;
+      }),
+      map(listing => listing.content),
+      reduce(
+        (agg, listing) => {
+          agg.push(...listing);
+          return agg;
+        },
+        <T[]>[]
+      )
+    );
+  }
+
+}

package/src/lib/common/data/entity-set-patch.ts

@@ -0,0 +1,210 @@
+import {JsonMap, JsonMapUtil} from '../json-map';
+
+
+export class EntitySetPatch<ID, ItemUpdate> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly idToMapKeyFn: (id: ID) => string | number;
+
+  private upsertsById: JsonMap<ItemUpdate> = {};
+  private updatesById: JsonMap<ItemUpdate> = {};
+  private upsertOnes: ItemUpdate[] = [];
+  private updateOnes: ItemUpdate[] = [];
+  private deleteOther?: boolean;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  public static start<ID, ItemUpdate>(
+    idToMapKeyFn?: (id: ID) => string | number
+  ): EntitySetPatch<ID, ItemUpdate> {
+    return new EntitySetPatch<ID, ItemUpdate>(idToMapKeyFn);
+  }
+
+  private static idToMapKeyDefault<ID>(id: ID): string | number {
+    if (typeof id === 'string') {
+      return id;
+    } else if (typeof id === 'number') {
+      return id;
+    } else {
+      return id + '';
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    idToMapKeyFn?: (id: ID) => string | number
+  ) {
+    this.idToMapKeyFn = idToMapKeyFn ?? EntitySetPatch.idToMapKeyDefault;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Query                                                                   *
+   *                                                                         *
+   **************************************************************************/
+
+  public getUpsertsById(): Map<ID, ItemUpdate> {
+    return JsonMapUtil.toMap(this.upsertsById);
+  }
+
+  public getUpdatesById(): Map<ID, ItemUpdate> {
+    return JsonMapUtil.toMap(this.updatesById);
+  }
+
+  public getUpsertOnes(): ItemUpdate[] {
+    return [...this.upsertOnes];
+  }
+
+  public getUpdateOnes(): ItemUpdate[] {
+    return [...this.updateOnes];
+  }
+
+  /**
+   * Gets all ids which should be deleted.
+   * Also consider isDeleteOther, which means
+   * everything gets deleted.
+   */
+  public collectDeletions(): ID[] {
+    return [
+      ...Array.from(this.getUpsertsById().entries())
+        .filter(([id, update]) => !update)
+        .map(([id, update]) => id),
+      ...Array.from(this.getUpdatesById().entries())
+        .filter(([id, update]) => !update)
+        .map(([id, update]) => id),
+    ];
+  }
+
+  /**
+   * Delete all entities which are not
+   * explicitly defined in this update.
+   * "Replace with" semantics.
+   */
+  public get isDeleteOther(): boolean {
+    return this.deleteOther;
+  }
+
+  /**
+   * Collects all upserts. (Updates are ignored)
+   */
+  public collectUpserts(): ItemUpdate[] {
+    return [
+      ...Array.from(this.getUpsertsById().entries())
+        .filter(([id, update]) => !!update)
+        .map(([id, update]) => update),
+      ...this.upsertOnes
+    ];
+  }
+
+  /**
+   * Collects all updates. (Upserts are ignored)
+   */
+  public collectUpdates(): ItemUpdate[] {
+    return [
+      ...Array.from(this.getUpdatesById().entries())
+        .filter(([id, update]) => !!update)
+        .map(([id, update]) => update),
+      ...this.updateOnes
+    ];
+  }
+
+  public collectUpdatesAndUpserts(): ItemUpdate[] {
+    return [
+      ...this.collectUpserts(),
+      ...this.collectUpdates()
+    ];
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Builder API                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  public update(updateOne: ItemUpdate): this {
+    this.updateOnes.push(updateOne);
+    return this;
+  }
+
+  public updateAll(updateOne: ItemUpdate[]): this {
+    this.updateOnes.push(...updateOne);
+    return this;
+  }
+
+  public updateById(id: ID, updateOne: ItemUpdate): this {
+    this.updatesById[this.idToMapKeyFn(id)] = updateOne;
+    return this;
+  }
+
+  public updateAllById(updates: Map<ID, ItemUpdate>): this {
+    updates.forEach((v, k) => this.updateById(k, v));
+    return this;
+  }
+
+  public upsert(updateOne: ItemUpdate): this {
+    this.upsertOnes.push(updateOne);
+    return this;
+  }
+
+  public upsertAll(updateOne: ItemUpdate[]): this {
+    this.upsertOnes.push(...updateOne);
+    return this;
+  }
+
+  public upsertById(id: ID, updateOne: ItemUpdate): this {
+    this.upsertsById[this.idToMapKeyFn(id)] = updateOne;
+    return this;
+  }
+
+  public upsertAllById(upserts: Map<ID, ItemUpdate>): this {
+    upserts.forEach((v, k) => this.upsertById(k, v));
+    return this;
+  }
+
+  public deleteById(...idArgs: ID[]): this {
+    idArgs.forEach(id => this.upsertById(id, null));
+    return this;
+  }
+
+  public deleteByIds(ids: ID[]): this {
+    ids.forEach(id => this.upsertById(id, null));
+    return this;
+  }
+
+  public deleteAllOther(): this {
+    this.deleteOther = true;
+    return this;
+  }
+
+  public deleteAll(): this {
+    this.clear();
+    this.deleteAllOther();
+    return this;
+  }
+
+  public clear(): this {
+    this.upsertOnes = [];
+    this.upsertsById = {};
+    this.updateOnes = [];
+    this.updatesById = {};
+    return this;
+  }
+
+}
+
+
+