@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

package/lib/common/data/datasource/fetcher/delegate-data-source.d.ts

@@ -0,0 +1,84 @@
+import { IContinuableDataSource, IDataSource, IListDataSource, IPagedDataSource } from '../data-source';
+import { Observable } from 'rxjs';
+import { Filter } from '../../filters/filter';
+import { Sort } from '../../sort';
+import { Page, Pageable } from '../../page';
+import { TokenChunkRequest } from '../../token-chunk-request';
+import { ContinuableListing } from '../../continuable-listing';
+export declare abstract class DelegateDataSource<T> implements IDataSource<T> {
+    private readonly idProperty;
+    private readonly findByIdFn;
+    private readonly findAllByIdFn;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    static emptyListFetcher<T>(): IDataSource<T>;
+    static listFetcher<T>(listFetcher: (sorts: Sort[], filters?: Filter[]) => Observable<Array<T>>, idProperty?: string, findByIdFn?: (id: any) => Observable<T>, findAllByIdFn?: (ids: any[]) => Observable<T[]>): IDataSource<T>;
+    static emptyPageFetcher<T>(): IDataSource<T>;
+    static pageFetcher<T>(pageFetcher: (pageable: Pageable, filters?: Filter[]) => Observable<Page<T>>, idProperty?: string, findByIdFn?: (id: any) => Observable<T>, findAllByIdFn?: (ids: any[]) => Observable<T[]>): IDataSource<T>;
+    static emptyContinuableFetcher<T>(): IDataSource<T>;
+    static continuableFetcher<T>(chunkFetcher: (tokenChunkRequest: TokenChunkRequest) => Observable<ContinuableListing<T>>, idProperty?: string, findByIdFn?: (id: any) => Observable<T>, findAllByIdFn?: (ids: any[]) => Observable<T[]>): IDataSource<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    protected constructor(idProperty: string, findByIdFn: (id: any) => Observable<T>, findAllByIdFn: (ids: any[]) => Observable<T[]>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataChanged(): Observable<any>;
+    findById(id: any): Observable<T>;
+    findByIds(ids: any[]): Observable<T[]>;
+    getId(entity: T): any;
+}
+export declare class DelegateListDataSource<T> extends DelegateDataSource<T> implements IListDataSource<T> {
+    private readonly listFetcherFn;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(listFetcherFn: (sorts: Sort[], filters?: Filter[]) => Observable<Array<T>>, idProperty: string, findByIdFn: (id: any) => Observable<T>, findAllByIdFn: (ids: any[]) => Observable<T[]>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findAllFiltered(filters?: Filter[], sorts?: Sort[]): Observable<Array<T>>;
+}
+export declare class DelegatePagedDataSource<T> extends DelegateDataSource<T> implements IPagedDataSource<T> {
+    private readonly pageFetcherFn;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(pageFetcherFn: (pageable: Pageable, filters?: Filter[]) => Observable<Page<T>>, idProperty: string, findByIdFn: (id: any) => Observable<T>, findAllByIdFn: (ids: any[]) => Observable<T[]>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findAllPaged(pageable: Pageable, filters?: Filter[]): Observable<Page<T>>;
+    process(pageSize: number, processFn: (dataChunk: T[]) => void, filters?: Filter[]): void;
+}
+export declare class DelegateContinuableDataSource<T> extends DelegateDataSource<T> implements IContinuableDataSource<T> {
+    private readonly chunkFetcherFn;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(chunkFetcherFn: (tokenChunkRequest: TokenChunkRequest) => Observable<ContinuableListing<T>>, idProperty: string, findByIdFn: (id: any) => Observable<T>, findAllByIdFn: (ids: any[]) => Observable<T[]>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findAllContinuable(tokenChunkRequest: TokenChunkRequest): Observable<ContinuableListing<T>>;
+}

package/lib/common/data/datasource/local/local-list-data-source.d.ts

@@ -0,0 +1,61 @@
+import { Filter } from '../../filters/filter';
+import { Sort } from '../../sort';
+import { Observable } from 'rxjs';
+import { IListDataSource } from '../data-source';
+export declare class LocalListDataSource<T> implements IListDataSource<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    private readonly data$;
+    private readonly dataChange$;
+    private readonly localSort;
+    private readonly localFilter;
+    private readonly idProperty;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Creates an empty local list data-source.
+     * You can set / modify data by using the data property.
+     * @param idProperty
+     * @param localSort
+     * @param localFilter
+     */
+    static empty<T>(idProperty: string | null, localSort?: ((data: T[], sorts: Sort[]) => T[]), localFilter?: ((data: T[], filters: Filter[]) => T[])): LocalListDataSource<T>;
+    static from<T>(localData: T[], idProperty: string | null, localSort?: ((data: T[], sorts: Sort[]) => T[]), localFilter?: ((data: T[], filters: Filter[]) => T[])): LocalListDataSource<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(localData: T[], localSort: ((data: T[], sorts: Sort[]) => T[]), localFilter: ((data: T[], filters: Filter[]) => T[]), idProperty: string | null);
+    /***************************************************************************
+     *                                                                         *
+     * IDataSource API                                                         *
+     *                                                                         *
+     **************************************************************************/
+    get dataChanged(): Observable<any>;
+    findById(id: any): Observable<T>;
+    findByIds(ids: any[]): Observable<T[]>;
+    findAllFiltered(filters?: Filter[], sorts?: Sort[]): Observable<T[]>;
+    getId(entity: T): any;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    set data(data: T[]);
+    get data(): T[];
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    protected onLocalDataChanges(data: T[]): void;
+    private guessIdProperty;
+}

package/lib/common/data/datasource/local/local-paged-data-source.d.ts

@@ -0,0 +1,49 @@
+import { Page, Pageable } from '../../page';
+import { Filter } from '../../filters/filter';
+import { Observable } from 'rxjs';
+import { Sort } from '../../sort';
+import { IPagedDataSource } from '../data-source';
+export declare class LocalPagedDataSource<T> implements IPagedDataSource<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly localListFetcher;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Creates an empty local list data-source.
+     * You can set / modify data by using the data property.
+     * @param idProperty
+     * @param localSort
+     * @param localFilter
+     */
+    static empty<T>(idProperty: string | null, localSort?: ((data: T[], sorts: Sort[]) => T[]), localFilter?: ((data: T[], filters: Filter[]) => T[])): LocalPagedDataSource<T>;
+    static from<T>(localData: T[], idProperty: string | null, localSort?: ((data: T[], sorts: Sort[]) => T[]), localFilter?: ((data: T[], filters: Filter[]) => T[])): LocalPagedDataSource<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(localData: T[], idProperty: string | null, localSort: ((data: T[], sorts: Sort[]) => T[]), localFilter: ((data: T[], filters: Filter[]) => T[]));
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataChanged(): Observable<any>;
+    findById(id: any): Observable<T>;
+    findByIds(ids: any[]): Observable<T[]>;
+    findAllPaged(pageable: Pageable, filters?: Filter[]): Observable<Page<T>>;
+    getId(entity: T): string;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private pageSlice;
+}

package/lib/common/data/datasource/public_api.d.ts

@@ -0,0 +1,7 @@
+export * from './data-source';
+export * from './data-source-adapter';
+export * from './data-source-processor';
+export * from './rest/public_api';
+export * from './local/local-list-data-source';
+export * from './local/local-paged-data-source';
+export * from './fetcher/delegate-data-source';

package/lib/common/data/datasource/rest/public_api.d.ts

@@ -0,0 +1 @@
+export * from './rest-client';

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

@@ -0,0 +1,162 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Sort } from '../../sort';
+import { Filter } from '../../filters/filter';
+import { Page, Pageable } from '../../page';
+import { ContinuableListing } from '../../continuable-listing';
+import { TokenChunkRequest } from '../../token-chunk-request';
+import { IContinuableDataSource, IDataSource, IListDataSource, IPagedDataSource } from '../data-source';
+export declare class InternalRestClientConfig {
+    idField: string;
+    idsParam: string;
+    constructor(userConfig?: RestClientConfig);
+}
+/**
+ * Allows to customize the rest client
+ */
+export declare class RestClientConfig {
+    /**
+     * The field to use as id. Defaults to 'id'.
+     */
+    idField?: string;
+    /**
+     * The query param to use for multiple ids. Defaults to 'ids'
+     */
+    idsParam?: string;
+}
+export declare class RestClient<T, TID> implements IDataSource<T> {
+    protected readonly restEndpoint: string;
+    protected readonly http: HttpClient;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly _logger;
+    private readonly localChangeSubject;
+    protected readonly config: InternalRestClientConfig;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(restEndpoint: string, http: HttpClient, config?: RestClientConfig);
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataChanged(): Observable<T>;
+    /**
+     * @deprecated Use dataChanged
+     */
+    get localChanged(): Observable<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findById(id: TID, params?: HttpParams): Observable<T>;
+    findByIds(ids: any[], params?: HttpParams): Observable<T[]>;
+    /**
+     * Creates or Updates the given entity depending if it already has a valid id.
+     */
+    save(entity: T, params?: HttpParams): Observable<T>;
+    create<TC = T>(newEntity: TC, params?: HttpParams): Observable<T>;
+    update(updatedEntity: T, params?: HttpParams): Observable<T>;
+    updateAll(updatedEntities: T[], params?: HttpParams): Observable<T[]>;
+    delete(entity: T, params?: HttpParams): Observable<any>;
+    deleteAll(entities: T[], params?: HttpParams): Observable<any>;
+    getId(entity: T): TID;
+    /***************************************************************************
+     *                                                                         *
+     * Sub Resource Builder                                                    *
+     *                                                                         *
+     **************************************************************************/
+    subResourceList<TS, TSID>(parent: T, subPath: string, config?: RestClientConfig): RestClientList<TS, TSID>;
+    subResourcePaged<TS, TSID>(parent: T, subPath: string, config?: RestClientConfig): RestClientPaged<TS, TSID>;
+    subResourceContinuable<TS, TSID>(parent: T, subPath: string, config?: RestClientConfig): RestClientContinuable<TS, TSID>;
+    /***************************************************************************
+     *                                                                         *
+     * Protected methods                                                       *
+     *                                                                         *
+     **************************************************************************/
+    protected patchInternal<P, R = T>(id: TID, entityPatch: P, params?: HttpParams): Observable<R>;
+    protected patchAllInternal<P, R = T>(entityPatches: P[], params?: HttpParams): Observable<R[]>;
+    protected onLocalChanged(entity?: T): void;
+    protected getEntityUrlBy(entity: T): string;
+    protected getEntityUrl(id: TID): string;
+    /***************************************************************************
+     *                                                                         *
+     * 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;
+}
+export declare class RestClientList<T, TID> extends RestClient<T, TID> implements IListDataSource<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(restEndpoint: string, http: HttpClient, config?: RestClientConfig);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findAllFiltered(filters?: Filter[], sorts?: Sort[], params?: HttpParams): Observable<T[]>;
+    findByIds(ids: any[], params?: HttpParams): Observable<T[]>;
+    findAll(params?: HttpParams): Observable<T[]>;
+}
+export declare class RestClientPaged<T, TID> extends RestClient<T, TID> implements IPagedDataSource<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(restEndpoint: string, http: HttpClient, config?: RestClientConfig);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findAllPaged(pageable: Pageable, filters?: Filter[], params?: HttpParams): Observable<Page<T>>;
+    findByIds(ids: any[], params?: HttpParams): Observable<T[]>;
+    /***************************************************************************
+     *                                                                         *
+     * 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;
+}
+export declare class RestClientContinuable<T, TID> extends RestClient<T, TID> implements IContinuableDataSource<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(restEndpoint: string, http: HttpClient, config?: RestClientConfig);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    findAllContinuable(request: TokenChunkRequest, params?: HttpParams): Observable<ContinuableListing<T>>;
+    findByIds(ids: any[], params?: HttpParams): Observable<T[]>;
+    private loadAll;
+}

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

@@ -0,0 +1,74 @@
+export declare class EntitySetPatch<ID, ItemUpdate> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly idToMapKeyFn;
+    private upsertsById;
+    private updatesById;
+    private upsertOnes;
+    private updateOnes;
+    private deleteOther?;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    static start<ID, ItemUpdate>(idToMapKeyFn?: (id: ID) => string | number): EntitySetPatch<ID, ItemUpdate>;
+    private static idToMapKeyDefault;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(idToMapKeyFn?: (id: ID) => string | number);
+    /***************************************************************************
+     *                                                                         *
+     * Query                                                                   *
+     *                                                                         *
+     **************************************************************************/
+    getUpsertsById(): Map<ID, ItemUpdate>;
+    getUpdatesById(): Map<ID, ItemUpdate>;
+    getUpsertOnes(): ItemUpdate[];
+    getUpdateOnes(): ItemUpdate[];
+    /**
+     * Gets all ids which should be deleted.
+     * Also consider isDeleteOther, which means
+     * everything gets deleted.
+     */
+    collectDeletions(): ID[];
+    /**
+     * Delete all entities which are not
+     * explicitly defined in this update.
+     * "Replace with" semantics.
+     */
+    get isDeleteOther(): boolean;
+    /**
+     * Collects all upserts. (Updates are ignored)
+     */
+    collectUpserts(): ItemUpdate[];
+    /**
+     * Collects all updates. (Upserts are ignored)
+     */
+    collectUpdates(): ItemUpdate[];
+    collectUpdatesAndUpserts(): ItemUpdate[];
+    /***************************************************************************
+     *                                                                         *
+     * Builder API                                                             *
+     *                                                                         *
+     **************************************************************************/
+    update(updateOne: ItemUpdate): this;
+    updateAll(updateOne: ItemUpdate[]): this;
+    updateById(id: ID, updateOne: ItemUpdate): this;
+    updateAllById(updates: Map<ID, ItemUpdate>): this;
+    upsert(updateOne: ItemUpdate): this;
+    upsertAll(updateOne: ItemUpdate[]): this;
+    upsertById(id: ID, updateOne: ItemUpdate): this;
+    upsertAllById(upserts: Map<ID, ItemUpdate>): this;
+    deleteById(...idArgs: ID[]): this;
+    deleteByIds(ids: ID[]): this;
+    deleteAllOther(): this;
+    deleteAll(): this;
+    clear(): this;
+}

package/lib/common/data/field-comparator.d.ts

@@ -0,0 +1,43 @@
+export declare type ComparatorFn<T> = (a: T, b: T) => number;
+export declare function naturalValueComparator(a: any, b: any): number;
+export declare function alphaNumStringComparator(a: any, b: any): number;
+/**
+ * Provides the ability to build a sorting comparator dynamically using
+ * a given array of fields / additional syntax.
+ *
+ * - Supports ASC / DESC
+ * - Supports multiple fields
+ * - Supports nested fields
+ *
+ * Example:
+ *
+ * ComparatorBuilder.fieldSort('simple', '-reveresed', 'some.very.deep.nested.path')
+ *
+ */
+export declare class ComparatorBuilder {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    static NATURAL_VALUE_COMPARATOR: ComparatorFn<any>;
+    static ALPHANUM_STRING_COMPARATOR: ComparatorFn<string>;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Dynamically builds a comparator function, using the given fields for sorting.
+     *
+     * @param fields One or more field name to sort.
+     */
+    static fieldSort<T = any>(...fields: string[]): ComparatorFn<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private static dynamicSort;
+    private static resolveProperty;
+}

package/lib/common/data/filters/filter-context.d.ts

@@ -0,0 +1,63 @@
+import { Filter } from './filter';
+import { Observable } from 'rxjs';
+export declare class FilterContext {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly _filters$;
+    /***************************************************************************
+     *                                                                         *
+     * Static Utilities                                                        *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Update the given filters with new ones, merging the two.
+     * The updated filters take precedence.
+     * @param filters
+     * @param updatedFilters
+     */
+    static updateFilters(filters: Filter[], updatedFilters: Filter[]): Filter[];
+    /***************************************************************************
+     *                                                                         *
+     * Read API                                                                *
+     *                                                                         *
+     **************************************************************************/
+    get filters(): Observable<Filter[]>;
+    get filtersSnapshot(): Filter[];
+    findFilterValue(key: string): string | string[] | undefined;
+    findFilter(key: string): Filter | undefined;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    removeFilter(key: string): void;
+    /**
+     * This method updatees / adds the given filter, leaving
+     * existing ones untouched.
+     * @param updatedFilter
+     */
+    updateFilter(updatedFilter?: Filter): void;
+    /**
+     * This method updates / adds the given filters, leaving
+     * existing ones untouched.
+     * @param updatedFilters
+     */
+    updateFilters(updatedFilters?: Filter[]): void;
+    /**
+     * Replace all existing filters with the given new ones.
+     * @param newFilters
+     */
+    replaceFilters(newFilters?: Filter[]): void;
+    clear(): void;
+    mergeFilters(filters: Filter[]): void;
+    mergeFilter(filter: Filter): void;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private equals;
+}

package/lib/common/data/filters/filter.d.ts

@@ -0,0 +1,52 @@
+export declare class Filter {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * The filter key.
+     * Unique inside a FilterContext or Filter request.
+     */
+    readonly key: string;
+    /**
+     * The filter value as string.
+     * Multiple string values are supported.
+     */
+    readonly value: string | string[] | null;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(key: string, value: string | string[] | null);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    static merge(current: Filter, forcedFilter: Filter): Filter;
+    /**
+     * Checks if this filter supports multiple values.
+     * @param filter
+     */
+    static isMulti(filter: Filter): boolean;
+    /**
+     * Checks if this filter has a value.
+     * This is the case when the value is non-null and
+     * in case it's an array, also non-empty.
+     */
+    static hasValue(self: Filter): boolean;
+    /**
+     * Checks this filter has the same value as the other given filter.
+     * @param self
+     * @param other
+     */
+    static equals(self: Filter, other: Filter): boolean;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private static addValuesToSet;
+}