xt-store 0.4.0

package/README.md

@@ -0,0 +1,24 @@
+# Store
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project store` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project store`.
+> Note: Don't forget to add `--project store` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build store` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build store`, go to the dist folder `cd dist/store` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test store` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/api-provider/xt-api-store-provider.d.ts

@@ -0,0 +1,26 @@
+import { Observable, Subscription } from "rxjs";
+import { HttpClient } from "@angular/common/http";
+import { OnDestroy } from "@angular/core";
+import { AbstractXtStoreProvider } from '../store-provider/xt-store-provider';
+import { XtStoreCriteria } from '../xt-store-parameters';
+import { UploadedDocumentInfo } from '../xt-document';
+import * as i0 from "@angular/core";
+/**
+ * A Store Provider that uses the DontCode API to store / read application data
+ */
+export declare class XtApiStoreProvider<T = never> extends AbstractXtStoreProvider<T> implements OnDestroy {
+    protected http: HttpClient;
+    apiUrl: string;
+    docUrl: string;
+    subscriptions: Subscription;
+    constructor(http?: HttpClient);
+    ngOnDestroy(): void;
+    storeEntity(name: string, data: T): Promise<T>;
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    searchEntities(name: string, ...criteria: XtStoreCriteria[]): Observable<T[]>;
+    canStoreDocument(): boolean;
+    storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XtApiStoreProvider<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<XtApiStoreProvider<any>>;
+}

package/fesm2022/xt-store.mjs

@@ -0,0 +1,792 @@
+import { map, of, throwError, Subscription, lastValueFrom } from 'rxjs';
+import { SpecialFields, Counters } from 'xt-type';
+import * as i1 from '@angular/common/http';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { inject, Injectable } from '@angular/core';
+import { map as map$1, mergeAll } from 'rxjs/operators';
+
+class XtStoreManager {
+    static { this.testProvider = null; }
+    constructor(provider) {
+        this.providerByPosition = new Map();
+        this.providerByType = new Map();
+        this._default = provider;
+        this.reset();
+    }
+    reset() {
+        this.providerByPosition.clear();
+        this.providerByType.clear();
+    }
+    getProvider(name) {
+        // Override for testing
+        if (XtStoreManager.testProvider != null)
+            return XtStoreManager.testProvider;
+        if (name == null) {
+            return this._default;
+        }
+        else {
+            let ret = null;
+            // Try to find if the entity is loaded from a defined source
+            /*const srcDefinition = this.modelMgr.findTargetOfProperty(
+              DontCodeModel.APP_ENTITIES_FROM_NODE,
+              position
+            )?.value as DontCodeSourceType;
+            if (srcDefinition) {
+              ret = this.providerByType.get(srcDefinition.type);
+            }
+            if (!ret) {*/
+            ret = this.providerByPosition.get(name);
+            //}
+            return ret ?? this._default;
+        }
+    }
+    getProviderSafe(name) {
+        const ret = this.getProvider(name);
+        if (ret == null) {
+            throw new Error('Trying to get an undefined or null provider');
+        }
+        else {
+            return ret;
+        }
+    }
+    getDefaultProvider() {
+        return this.getProvider();
+    }
+    getDefaultProviderSafe() {
+        return this.getProviderSafe();
+    }
+    setProvider(value, name) {
+        if (name == null)
+            this._default = value;
+        else {
+            this.providerByPosition.set(name, value);
+        }
+    }
+    setProviderForSourceType(value, srcType) {
+        this.providerByType.set(srcType, value);
+    }
+    setDefaultProvider(value) {
+        this.setProvider(value);
+    }
+    removeProvider(name) {
+        if (name == null)
+            this._default = undefined;
+        else {
+            this.providerByPosition.delete(name);
+        }
+    }
+    removeProviderForSourceType(srcType) {
+        this.providerByType.delete(srcType);
+    }
+    removeDefaultProvider() {
+        this.removeProvider();
+    }
+    storeEntity(name, entity) {
+        return this.getProviderSafe(name).storeEntity(name, entity);
+    }
+    loadEntity(name, key) {
+        return this.getProviderSafe(name).loadEntity(name, key);
+    }
+    safeLoadEntity(name, key) {
+        return this.getProviderSafe(name).safeLoadEntity(name, key);
+    }
+    deleteEntity(name, key) {
+        return this.getProviderSafe(name).deleteEntity(name, key);
+    }
+    searchEntities(name, ...criteria) {
+        return this.getProviderSafe(name).searchEntities(name, ...criteria);
+    }
+    searchAndPrepareEntities(name, sort, groupBy, dataTransformer, ...criteria) {
+        return this.getProviderSafe(name).searchAndPrepareEntities(name, sort, groupBy, dataTransformer, ...criteria);
+    }
+    canStoreDocument(name) {
+        const res = this.getProvider(name)?.canStoreDocument();
+        if (res)
+            return res;
+        else
+            return false;
+    }
+    storeDocuments(toStore, name) {
+        return this.getProviderSafe(name).storeDocuments(toStore);
+    }
+    static setTestMode(testProvider) {
+        this.testProvider = testProvider;
+    }
+}
+
+var XtStoreCriteriaOperator;
+(function (XtStoreCriteriaOperator) {
+    XtStoreCriteriaOperator["EQUALS"] = "=";
+    XtStoreCriteriaOperator["LESS_THAN"] = "<";
+    XtStoreCriteriaOperator["LESS_THAN_EQUAL"] = "<=";
+})(XtStoreCriteriaOperator || (XtStoreCriteriaOperator = {}));
+class XtStoreCriteria {
+    constructor(name, value, operator) {
+        this.name = name;
+        this.value = value;
+        if (!operator)
+            this.operator = XtStoreCriteriaOperator.EQUALS;
+        else {
+            this.operator = operator;
+        }
+    }
+}
+var XtSortByDirection;
+(function (XtSortByDirection) {
+    XtSortByDirection["None"] = "None";
+    XtSortByDirection["Ascending"] = "Ascending";
+    XtSortByDirection["Descending"] = "Descending";
+})(XtSortByDirection || (XtSortByDirection = {}));
+var XtGroupByShow;
+(function (XtGroupByShow) {
+    XtGroupByShow["OnlyLowest"] = "OnlyLowest";
+    XtGroupByShow["OnlyHighest"] = "OnlyHighest";
+})(XtGroupByShow || (XtGroupByShow = {}));
+var XtGroupByOperation;
+(function (XtGroupByOperation) {
+    XtGroupByOperation["Count"] = "Count";
+    XtGroupByOperation["Sum"] = "Sum";
+    XtGroupByOperation["Average"] = "Average";
+    XtGroupByOperation["Minimum"] = "Minimum";
+    XtGroupByOperation["Maximum"] = "Maximum";
+})(XtGroupByOperation || (XtGroupByOperation = {}));
+
+/**
+ * Helps handle metadata information about loaded items
+ */
+class XtStoreProviderHelper {
+    static { this.specialFieldsCache = new Map(); }
+    /**
+     * In case some entity definition has changed, clear the cache
+     */
+    static clearConfigCache() {
+        this.specialFieldsCache.clear();
+    }
+    /**
+     * In case the provider source doesn't support search criteria, they can be applied here
+     * @param list
+     * @param criteria
+     */
+    static applyFilters(list, ...criteria) {
+        if ((criteria == null) || (criteria.length == 0))
+            return list;
+        return list.filter(element => {
+            for (const criterium of criteria) {
+                const toTest = element[criterium.name];
+                switch (criterium.operator) {
+                    case XtStoreCriteriaOperator.EQUALS:
+                        return criterium.value == toTest;
+                    case XtStoreCriteriaOperator.LESS_THAN:
+                        return toTest < criterium.value;
+                    case XtStoreCriteriaOperator.LESS_THAN_EQUAL:
+                        return toTest <= criterium.value;
+                    default:
+                        throw new Error("Operator " + criterium.operator + " unknown");
+                }
+            }
+            return true;
+        });
+        return list;
+    }
+    /** Returns any field who is a date, in order to convert it from json. Keep the result in a cache map
+     *
+     * @param name
+     * @param entity
+     * @protected
+     */
+    static findSpecialFields(name, entity) {
+        let specialFields = XtStoreProviderHelper.specialFieldsCache.get(name);
+        if (specialFields != null)
+            return specialFields;
+        const curScore = { score: -1, field: null };
+        specialFields = new SpecialFields();
+        const fields = entity.fields;
+        if (fields != null) {
+            let prop;
+            for (prop in fields) {
+                // Finds the date fields that will need to be converted from json to javascript Date
+                if (fields[prop]?.type === 'Date' || fields[prop]?.type === 'Date & Time') {
+                    specialFields.addDateField(fields[prop]?.name);
+                }
+                else {
+                    XtStoreProviderHelper.scoreIdFieldFromEntityField(fields[prop], curScore);
+                }
+            }
+        }
+        if (curScore.score > 0) {
+            specialFields.idField = curScore.field;
+        }
+        XtStoreProviderHelper.specialFieldsCache.set(name, specialFields);
+        // eslint-disable-next-line no-restricted-syntax
+        //console.debug("Found special fields for entity at position "+name, specialFields);
+        return specialFields;
+    }
+    static findSpecialFieldsFromData(data, existingFields) {
+        if ((existingFields.idField == null) && (data?.length > 0)) {
+            // We must guess the id field from data
+            const first = data[0];
+            const curScore = { score: -1, field: null };
+            let prop;
+            for (prop in first) {
+                XtStoreProviderHelper.scoreIdFieldFromProperty(prop, curScore);
+            }
+            if (curScore.score > 0) {
+                const test = data.length > 1 ? data[Math.floor((data.length + 1) / 2)] : null;
+                if ((test == null) || (test[curScore.field] != first[curScore.field])) // Just check that another element doesn't have the same value as an id should be unique
+                    existingFields.idField = curScore.field;
+            }
+        }
+    }
+    static scoreIdFieldFromEntityField(prop, score) {
+        return XtStoreProviderHelper.scoreIdFieldFromProperty(prop?.name, score);
+    }
+    static scoreIdFieldFromProperty(name, score) {
+        if (name == null)
+            return false;
+        const propName = name.toLowerCase();
+        // Finds if the element is the id field
+        if (propName === "_id") {
+            score.field = "_id"; // Don't need to process Id
+            score.score = 100;
+            return true;
+        }
+        else {
+            if ((propName == "id") || (propName == "uniqueid") || (propName == "identifier") || (propName == 'key') || (propName == 'primaryKey') || (propName == 'uniqueKey')) {
+                if (score.score < 80) {
+                    score.score = 80;
+                    score.field = name;
+                }
+            }
+            else if (propName.includes("unique") || propName.includes("primary")) {
+                if (score.score < 50) {
+                    score.score = 50;
+                    score.field = name;
+                }
+            }
+            else if (propName.includes("id") || propName.includes('key')) {
+                if (score.score < 30) {
+                    score.score = 30;
+                    score.field = name;
+                }
+            }
+            return false;
+        }
+    }
+    /**
+     * Ensure _id is removed if necessary before saving the element
+     * @param listToConvert
+     * @param specialFields
+     * @protected
+     */
+    static cleanUpDataBeforeSaving(listToConvert, specialFields) {
+        if ((specialFields?.idField != null) && (specialFields?.idField != '_id')) {
+            listToConvert.forEach(value => {
+                delete value._id;
+            });
+        }
+    }
+    /**
+     * Converts dates and dateTimes properties of each element of the array to Typescript format
+     * Ensure _id is set with the right id
+     * @param listToConvert
+     * @param specialFields
+     * @protected
+     */
+    static cleanUpLoadedData(listToConvert, specialFields) {
+        if (specialFields != null) {
+            if (specialFields.idField == null) {
+                XtStoreProviderHelper.findSpecialFieldsFromData(listToConvert, specialFields);
+            }
+            listToConvert.forEach((val) => {
+                if ((specialFields.idField != null) && (specialFields.idField != "_id")) // We need to copy the id to the standard _id field
+                 {
+                    val._id = val[specialFields.idField];
+                }
+                specialFields.dateFields?.forEach(prop => {
+                    const toConvert = val[prop];
+                    if (toConvert != null) {
+                        let timeEpoch = Date.parse(toConvert);
+                        if (isNaN(timeEpoch)) {
+                            // Invalid date try to remove a possible TZ description in []
+                            const tzDescIndex = toConvert.lastIndexOf('[');
+                            if (tzDescIndex != -1) {
+                                timeEpoch = Date.parse(toConvert.substring(0, tzDescIndex));
+                            }
+                        }
+                        if (isNaN(timeEpoch)) {
+                            delete val[prop];
+                        }
+                        else {
+                            val[prop] = new Date(timeEpoch);
+                        }
+                    }
+                });
+            });
+        }
+    }
+    /**
+     * Sort the array using the defined sort declarations across all properties.
+     *
+     * @param toSort
+     * @param sortOptions
+     */
+    static multiSortArray(toSort, sortOptions) {
+        if (sortOptions == null)
+            return toSort;
+        return toSort;
+    }
+    /**
+     * Calculates sum, avg, min or max values per group
+     * @param values
+     * @param groupBy
+     * @param modelMgr
+     * @param position
+     * @param item
+     */
+    static calculateGroupedByValues(name, values, groupBy) {
+        // We are counting per different value of the groupedBy Item
+        if ((groupBy != null) && (groupBy.display != null)) {
+            let fieldToGroupBy = groupBy.of;
+            if (groupBy.show != null)
+                fieldToGroupBy = groupBy.show.valueOf();
+            const counters = new Map();
+            let lastGroupDelimiter;
+            let oneGroupOfCounters = new Map();
+            const fieldsRequired = groupBy.getRequiredListOfFields();
+            for (const value of values) {
+                if (value[fieldToGroupBy] != lastGroupDelimiter) { // We change the group
+                    lastGroupDelimiter = value[fieldToGroupBy];
+                    const storedGroupOfCounters = counters.get(lastGroupDelimiter);
+                    if (storedGroupOfCounters == null) {
+                        oneGroupOfCounters = new Map();
+                        counters.set(lastGroupDelimiter, oneGroupOfCounters);
+                    }
+                    else {
+                        oneGroupOfCounters = storedGroupOfCounters;
+                    }
+                }
+                for (const field of fieldsRequired) {
+                    let counter = oneGroupOfCounters?.get(field);
+                    if (counter == null) {
+                        counter = new Counters();
+                        oneGroupOfCounters.set(field, counter);
+                    }
+                    const valSrc = value[field];
+                    const val = valSrc;
+                    if (valSrc != null) {
+                        const modelMgr = null;
+                        // If it's an object, we need to set the calculated values as the object itself
+                        if ((typeof valSrc === 'object') && (!(valSrc instanceof Date)) && (modelMgr != null)) {
+                            if (counter.sum == null)
+                                counter.sum = structuredClone(valSrc);
+                            else {
+                                counter.sum = modelMgr.modifyValues(counter.sum, valSrc, counter.metaData, (first, second) => {
+                                    if ((first != null) && (second != null))
+                                        return first + second;
+                                    else if (first == null) {
+                                        return second;
+                                    }
+                                    else if (second == null) {
+                                        return first;
+                                    }
+                                } /*,
+                                position, item*/);
+                            }
+                            const value = modelMgr.extractValue(valSrc, counter.metaData /*,position, item*/);
+                            if (counter.minimum == null) {
+                                counter.minimum = valSrc;
+                                counter.minAsValue = value;
+                            }
+                            else {
+                                const minValue = counter.minAsValue;
+                                if ((value != null) && ((minValue == null) || (value < minValue))) {
+                                    counter.minimum = valSrc;
+                                    counter.minAsValue = value;
+                                }
+                            }
+                            if (counter.maximum == null) {
+                                counter.maximum = valSrc;
+                                counter.maxAsValue = value;
+                            }
+                            else {
+                                const maxValue = counter.maxAsValue;
+                                if ((value != null) && ((maxValue == null) || (value > maxValue))) {
+                                    counter.maximum = valSrc;
+                                    counter.maxAsValue = value;
+                                }
+                            }
+                            if (value != null) {
+                                counter.count++;
+                            }
+                        }
+                        else if (typeof val === 'number') {
+                            if (counter.sum == null)
+                                counter.sum = 0;
+                            counter.sum = counter.sum + val;
+                            if ((counter.minimum == null) || (val < counter.minimum)) {
+                                counter.minimum = valSrc;
+                                counter.minAsValue = valSrc;
+                            }
+                            if ((counter.maximum == null) || (val > counter.maximum)) {
+                                counter.maximum = valSrc;
+                                counter.maxAsValue = valSrc;
+                            }
+                            counter.count++;
+                        }
+                        else if ((val instanceof Date) && (!isNaN(val.getTime()))) {
+                            counter.sum = null;
+                            if ((counter.minimum == null) || (val.valueOf() < counter.minimum.valueOf())) {
+                                counter.minimum = valSrc;
+                            }
+                            if ((counter.maximum == null) || (val.valueOf() > counter.maximum.valueOf())) {
+                                counter.maximum = valSrc;
+                            }
+                            counter.count++;
+                        }
+                        else { // strings
+                            counter.count++;
+                        }
+                    }
+                }
+            }
+            // Now that we have all the counters, let's generate the GroupedFields
+            let ret;
+            if (counters.size > 0) {
+                ret = new DontCodeStoreGroupedByEntities(groupBy, new Map);
+                for (const groupKey of counters.keys()) {
+                    const group = counters.get(groupKey);
+                    for (const aggregate of Object.values(groupBy.display)) {
+                        let value;
+                        const counter = group.get(aggregate.of);
+                        if (counter != null) {
+                            switch (aggregate.operation) {
+                                case XtGroupByOperation.Count:
+                                    value = counter.count;
+                                    break;
+                                case XtGroupByOperation.Sum:
+                                    value = counter.sum;
+                                    break;
+                                case XtGroupByOperation.Average:
+                                    {
+                                        const modelMgr = null;
+                                        if ((counter.sum == null) || (counter.count == 0))
+                                            value = null;
+                                        else if ((typeof counter.sum === 'object') && (!(counter.sum instanceof Date)) && (modelMgr != null)) {
+                                            value = modelMgr.applyValue(structuredClone(counter.sum), modelMgr.extractValue(counter.sum, counter.metaData /*, position, item*/) / counter.count, counter.metaData, undefined /*, position, item*/);
+                                        }
+                                        else
+                                            value = counter.sum / counter.count;
+                                    }
+                                    break;
+                                case XtGroupByOperation.Minimum:
+                                    value = counter.minimum;
+                                    break;
+                                case XtGroupByOperation.Maximum:
+                                    value = counter.maximum;
+                                    break;
+                            }
+                            let listOfValues = ret.values?.get(groupKey);
+                            if (listOfValues == null) {
+                                listOfValues = new Array();
+                                ret.values?.set(groupKey, listOfValues);
+                            }
+                            listOfValues.push(new DontCodeStoreGroupedByValues(aggregate, value));
+                        }
+                    }
+                }
+                return ret.values.size > 0 ? ret : undefined;
+            }
+        }
+        return undefined;
+    }
+}
+class DontCodeStorePreparedEntities {
+    constructor(sortedData, sortInfo, groupedByEntities) {
+        this.sortedData = sortedData;
+        this.sortInfo = sortInfo;
+        this.groupedByEntities = groupedByEntities;
+    }
+}
+class DontCodeStoreGroupedByEntities {
+    constructor(groupInfo, values) {
+        this.groupInfo = groupInfo;
+        this.values = values;
+        if (values == null)
+            this.values = new Map();
+    }
+}
+class DontCodeStoreGroupedByValues {
+    constructor(forAggregate, value) {
+        this.forAggregate = forAggregate;
+        this.value = value;
+    }
+}
+
+class XtStoreSortBy {
+    constructor(by, direction, subSort) {
+        this.by = by;
+        this.subSort = subSort;
+        if (direction == null)
+            this.direction = XtSortByDirection.None;
+        else
+            this.direction = direction;
+    }
+}
+class XtStoreGroupBy {
+    constructor(of, display, show) {
+        this.of = of;
+        this.show = show;
+        if (display == null)
+            this.display = {};
+        else
+            this.display = display;
+    }
+    atLeastOneGroupIsRequested() {
+        if ((this.display != null) && (Object.keys(this.display).length > 0))
+            return true;
+        return false;
+    }
+    getRequiredListOfFields() {
+        const ret = new Set();
+        if (this.display != null) {
+            for (const aggregate of Object.values(this.display)) {
+                ret.add(aggregate.of);
+            }
+        }
+        return ret;
+    }
+}
+class XtStoreGroupByAggregate {
+    constructor(of, operation) {
+        this.of = of;
+        this.operation = operation;
+    }
+}
+
+class AbstractXtStoreProvider {
+    constructor() {
+    }
+    safeLoadEntity(name, key) {
+        return this.loadEntity(name, key).then(value => {
+            if (value == null)
+                return Promise.reject("Not found");
+            else
+                return value;
+        });
+    }
+    /**
+     * If the store supports queries with criteria, this function must be implemented, if not, listEntities must be implemented, and this function will apply filters
+     * @param position
+     * @param criteria
+     */
+    searchEntities(name, ...criteria) {
+        return this.listEntities(name).pipe(map(value => {
+            return XtStoreProviderHelper.applyFilters(value, ...criteria);
+        }));
+    }
+    /**
+     * Returns the list of entities at a given position in the model. Implements at least this function or searchEntities depending on the capability of the store
+     * @param position
+     * @protected
+     */
+    listEntities(name) {
+        return this.searchEntities(name);
+    }
+    searchAndPrepareEntities(name, sort, groupBy, transformer, ...criteria) {
+        return this.searchEntities(name, ...criteria).pipe(map(value => {
+            // Run the transformation if any
+            if (transformer != null)
+                return transformer.postLoadingTransformation(value);
+            else
+                return value;
+        }), map(value => {
+            let groupedByValues;
+            if ((sort != null) || (groupBy?.atLeastOneGroupIsRequested() === true)) {
+                value = XtStoreProviderHelper.multiSortArray(value, this.calculateSortHierarchy(sort, groupBy));
+                if (groupBy != null) {
+                    groupedByValues = XtStoreProviderHelper.calculateGroupedByValues(name, value, groupBy);
+                }
+            }
+            return new DontCodeStorePreparedEntities(value, sort, groupedByValues);
+        }));
+    }
+    calculateSortHierarchy(sort, groupBy) {
+        // We must first sort by the groupBy, and then by the sort
+        let rootSort;
+        if (groupBy != null) {
+            rootSort = new XtStoreSortBy(groupBy.of, undefined, sort);
+        }
+        else {
+            rootSort = sort;
+        }
+        return rootSort;
+    }
+}
+
+class XtMemoryStoreProvider extends AbstractXtStoreProvider {
+    constructor() {
+        super(...arguments);
+        this.storage = new Map();
+    }
+    canStoreDocument() {
+        return false;
+    }
+    getSafeStore(name) {
+        let ret = this.storage.get(name);
+        if (ret == null) {
+            ret = new Map();
+            this.storage.set(name, ret);
+        }
+        return ret;
+    }
+    deleteEntity(name, key) {
+        const store = this.getSafeStore(name);
+        return Promise.resolve(store.delete(key));
+    }
+    loadEntity(name, key) {
+        const store = this.getSafeStore(name);
+        return Promise.resolve(store.get(key));
+    }
+    listEntities(name) {
+        const store = this.getSafeStore(name);
+        //console.debug("Listing entities for "+name+" with ",store);
+        return of(Array.from(store.values()));
+    }
+    storeEntity(name, entity) {
+        const store = this.getSafeStore(name);
+        if (entity._id == null) {
+            entity._id = Math
+                .random().toString(36).substring(2, 8);
+        }
+        store.set(entity._id, entity);
+        return Promise.resolve(entity);
+    }
+    storeDocuments(toStore) {
+        return throwError(() => {
+            throw new Error("Not implemented.");
+        });
+    }
+}
+
+/**
+ * A Store Provider that uses the DontCode API to store / read application data
+ */
+class XtApiStoreProvider extends AbstractXtStoreProvider {
+    constructor(http /* protected configService: CommonConfigService*/) {
+        super();
+        this.http = inject(HttpClient, { optional: true });
+        this.subscriptions = new Subscription();
+        if (http != null) {
+            this.http = http;
+        }
+        if (this.http == null) {
+            throw new Error("You must provide an HttpClient, either through constructor or injection.");
+        }
+        this.apiUrl = 'https://test.dont-code.net/data';
+        this.docUrl = 'https://test.dont-code.net/documents';
+        /*this.updateConfig (this.configService.getConfig());
+        this.subscriptions.add (this.configService.getUpdates ().pipe (map ((updatedConfig) => {
+          this.updateConfig (updatedConfig);
+        })).subscribe());*/
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /*  updateConfig(newConfig: Readonly<CommonLibConfig>) {
+        if (newConfig.storeApiUrl!=null)
+          this.apiUrl = newConfig.storeApiUrl;
+        if (newConfig.documentApiUrl!=null)
+          this.docUrl = newConfig.documentApiUrl;
+      }*/
+    storeEntity(name, data) {
+        const id = data._id;
+        // Reconverts dates or Ids
+        const specialFields = XtStoreProviderHelper.findSpecialFields(name, {});
+        XtStoreProviderHelper.cleanUpDataBeforeSaving([data], specialFields);
+        if (id != undefined) {
+            return lastValueFrom(this.http.put(this.apiUrl + '/' + name + '/' + id, data, { observe: "body", responseType: "json" }));
+        }
+        else {
+            return lastValueFrom(this.http.post(this.apiUrl + '/' + name, data, { observe: "body", responseType: "json" }));
+        }
+    }
+    loadEntity(name, key) {
+        const obs = this.http.get(this.apiUrl + '/' + name + '/' + key, { observe: "body", responseType: "json" });
+        const specialFields = XtStoreProviderHelper.findSpecialFields(name, {});
+        return lastValueFrom(obs).then((value) => {
+            XtStoreProviderHelper.cleanUpLoadedData([value], specialFields);
+            return value;
+        });
+    }
+    deleteEntity(name, key) {
+        return lastValueFrom(this.http.delete(this.apiUrl + '/' + name + '/' + key, { observe: "body", responseType: "json" })).then(value => {
+            return true;
+        });
+    }
+    searchEntities(name, ...criteria) {
+        const specialFields = XtStoreProviderHelper.findSpecialFields(name, {});
+        return this.http.get(this.apiUrl + '/' + name, { observe: "body", responseType: "json" }).pipe(map$1(value => {
+            XtStoreProviderHelper.cleanUpLoadedData(value, specialFields);
+            return value;
+        }), map$1(value => {
+            return XtStoreProviderHelper.applyFilters(value, ...criteria);
+        }));
+    }
+    canStoreDocument() {
+        return true;
+    }
+    storeDocuments(toStore) {
+        const myFormData = new FormData();
+        const headers = new HttpHeaders();
+        headers.append('Content-Type', 'multipart/form-data');
+        headers.append('Accept', 'application/json');
+        let count = 0;
+        // store files details into formdata
+        toStore.forEach(file => {
+            myFormData.append('document#' + count, file);
+            count++;
+        });
+        //HTTP Angular service, which will send call to Laravel API With headers and myformdata
+        return this.http.post(this.docUrl, myFormData, { headers: headers }).pipe(mergeAll());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtApiStoreProvider, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtApiStoreProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtApiStoreProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+
+class StoreTestBed {
+    constructor() {
+        this.storeManager = new XtStoreManager();
+    }
+    ensureMemoryProviderOnly() {
+        XtStoreManager.setTestMode(new XtMemoryStoreProvider());
+    }
+    async defineTestDataFor(entityName, testData) {
+        for (const testEntity of testData) {
+            await this.storeManager.storeEntity(entityName, testEntity);
+        }
+    }
+    getStoreManager() {
+        return this.storeManager;
+    }
+    getStoreProviderFor(entityName) {
+        return this.storeManager.getProviderSafe(entityName);
+    }
+}
+
+/*
+ * Public API Surface of store
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AbstractXtStoreProvider, DontCodeStoreGroupedByEntities, DontCodeStoreGroupedByValues, DontCodeStorePreparedEntities, StoreTestBed, XtApiStoreProvider, XtGroupByOperation, XtGroupByShow, XtMemoryStoreProvider, XtSortByDirection, XtStoreCriteria, XtStoreCriteriaOperator, XtStoreGroupBy, XtStoreGroupByAggregate, XtStoreManager, XtStoreProviderHelper, XtStoreSortBy };
+//# sourceMappingURL=xt-store.mjs.map

package/fesm2022/xt-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xt-store.mjs","sources":["../../../projects/store/src/store-manager/xt-store-manager.ts","../../../projects/store/src/xt-store-parameters.ts","../../../projects/store/src/store-provider/xt-store-provider-helper.ts","../../../projects/store/src/xt-reporting.ts","../../../projects/store/src/store-provider/xt-store-provider.ts","../../../projects/store/src/store-provider/xt-memory-store-provider.ts","../../../projects/store/src/api-provider/xt-api-store-provider.ts","../../../projects/store/src/test/store-test-bed.ts","../../../projects/store/src/public-api.ts","../../../projects/store/src/xt-store.ts"],"sourcesContent":["import { XtStoreProvider } from '../store-provider/xt-store-provider';\nimport { Observable } from 'rxjs';\nimport { UploadedDocumentInfo } from '../xt-document';\nimport { XtStoreCriteria, XtGroupBy, XtSortBy } from '../xt-store-parameters';\nimport { DontCodeStorePreparedEntities } from '../store-provider/xt-store-provider-helper';\nimport { XtDataTransformer } from '../store-provider/xt-data-transformer';\n\nexport class XtStoreManager {\n  private _default?: XtStoreProvider<any>;\n  private providerByPosition = new Map<string, XtStoreProvider<any>>();\n  private providerByType = new Map<string, XtStoreProvider<any>>();\n\n  protected static testProvider:XtStoreProvider<any>|null = null;\n\n  constructor(\n    provider?: XtStoreProvider<any>\n  ) {\n    this._default = provider;\n    this.reset();\n  }\n\n  reset() {\n    this.providerByPosition.clear();\n    this.providerByType.clear();\n  }\n\n  getProvider<T=never>(name?: string): XtStoreProvider<T> | undefined {\n    // Override for testing\n    if( XtStoreManager.testProvider!=null) return XtStoreManager.testProvider;\n\n    if (name == null) {\n      return this._default;\n    } else {\n      let ret = null;\n      // Try to find if the entity is loaded from a defined source\n      /*const srcDefinition = this.modelMgr.findTargetOfProperty(\n        DontCodeModel.APP_ENTITIES_FROM_NODE,\n        position\n      )?.value as DontCodeSourceType;\n      if (srcDefinition) {\n        ret = this.providerByType.get(srcDefinition.type);\n      }\n      if (!ret) {*/\n        ret = this.providerByPosition.get(name);\n      //}\n      return ret ?? this._default;\n    }\n  }\n\n  getProviderSafe<T=never>(name?: string): XtStoreProvider<T> {\n    const ret = this.getProvider<T>(name);\n    if (ret == null) {\n      throw new Error('Trying to get an undefined or null provider');\n    } else {\n      return ret;\n    }\n  }\n\n  getDefaultProvider<T=never>(): XtStoreProvider<T> | undefined {\n    return this.getProvider();\n  }\n\n  getDefaultProviderSafe<T=never>(): XtStoreProvider<T> {\n    return this.getProviderSafe();\n  }\n\n  setProvider<T=never>(value: XtStoreProvider<T>, name?: string): void {\n    if (name == null) this._default = value;\n    else {\n      this.providerByPosition.set(name, value);\n    }\n  }\n\n  setProviderForSourceType<T=never>(\n    value: XtStoreProvider<T>,\n    srcType: string\n  ): void {\n    this.providerByType.set(srcType, value);\n  }\n\n  setDefaultProvider<T=never>(value: XtStoreProvider<T>): void {\n    this.setProvider(value);\n  }\n\n  removeProvider(name?: string): void {\n    if (name == null) this._default = undefined;\n    else {\n      this.providerByPosition.delete(name);\n    }\n  }\n\n  removeProviderForSourceType(srcType: string): void {\n    this.providerByType.delete(srcType);\n  }\n\n  removeDefaultProvider(): void {\n    this.removeProvider();\n  }\n\n  storeEntity<T=never>(name: string, entity: T): Promise<T> {\n    return this.getProviderSafe<T>(name).storeEntity(name, entity);\n  }\n\n  loadEntity<T=never>(name: string, key: any): Promise<T|undefined> {\n    return this.getProviderSafe<T>(name).loadEntity(name, key);\n  }\n\n  safeLoadEntity<T=never>(name: string, key: any): Promise<T> {\n    return this.getProviderSafe<T>(name).safeLoadEntity(name, key);\n  }\n\n  deleteEntity(name: string, key: any): Promise<boolean> {\n    return this.getProviderSafe(name).deleteEntity(name, key);\n  }\n\n  searchEntities<T=never>(\n    name: string,\n    ...criteria: XtStoreCriteria[]\n  ): Observable<Array<T>> {\n    return this.getProviderSafe<T>(name).searchEntities(name, ...criteria);\n  }\n\n  searchAndPrepareEntities<T=never>(\n    name: string,\n    sort?:XtSortBy,\n    groupBy?:XtGroupBy,\n    dataTransformer?:XtDataTransformer,\n    ...criteria: XtStoreCriteria[]\n  ): Observable<DontCodeStorePreparedEntities<T>> {\n    return this.getProviderSafe<T>(name).searchAndPrepareEntities(name, sort, groupBy, dataTransformer, ...criteria);\n  }\n\n\n  canStoreDocument(name?: string): boolean {\n    const res = this.getProvider(name)?.canStoreDocument();\n    if (res) return res;\n    else return false;\n  }\n\n  storeDocuments(\n    toStore: File[],\n    name?: string\n  ): Observable<UploadedDocumentInfo> {\n    return this.getProviderSafe(name).storeDocuments(toStore);\n  }\n\n  public static setTestMode (testProvider:XtStoreProvider<any>) {\n    this.testProvider=testProvider;\n  }\n\n}\n\n","\nexport enum XtStoreCriteriaOperator {\n  EQUALS = '=',\n  LESS_THAN = '<',\n  LESS_THAN_EQUAL = '<=',\n}\n\nexport class XtStoreCriteria {\n  name: string;\n  value: any;\n  operator: XtStoreCriteriaOperator;\n\n  constructor(\n    name: string,\n    value: any,\n    operator?: XtStoreCriteriaOperator\n  ) {\n    this.name = name;\n    this.value = value;\n    if (!operator) this.operator = XtStoreCriteriaOperator.EQUALS;\n    else {\n      this.operator = operator;\n    }\n  }\n}\n\nexport type XtSortBy ={\n  by:string,\n  direction: XtSortByDirection\n}\n\nexport enum XtSortByDirection {\n  None = \"None\",\n  Ascending = \"Ascending\",\n  Descending = \"Descending\"\n}\n\nexport enum XtGroupByShow {\n  OnlyLowest=\"OnlyLowest\",\n  OnlyHighest=\"OnlyHighest\"\n}\n\nexport enum XtGroupByOperation {\n  Count= \"Count\",\n  Sum=\"Sum\",\n  Average=\"Average\",\n  Minimum=\"Minimum\",\n  Maximum=\"Maximum\"\n}\n\nexport type XtGroupBy= {\n  of: string,\n  display:{[key:string]:XtGroupByAggregate};\n  show?:XtGroupByShow,\n  label?:string\n\n  atLeastOneGroupIsRequested (): boolean;\n  getRequiredListOfFields(): Set<string>;\n}\n\nexport type XtGroupByAggregate = {\n  operation: XtGroupByOperation;\n  of:string,\n  label?:string\n}\n\n\n","import { SpecialFields, Counters } from 'xt-type';\nimport {\n  XtGroupByAggregate,\n  XtStoreCriteria,\n  XtStoreCriteriaOperator,\n  XtGroupBy,\n  XtSortBy, XtGroupByOperation\n} from '../xt-store-parameters';\n\n/**\n * Helps handle metadata information about loaded items\n */\nexport class XtStoreProviderHelper {\n\n  static specialFieldsCache = new Map<string, SpecialFields>();\n  /**\n   * In case some entity definition has changed, clear the cache\n   */\n  public static clearConfigCache (): void {\n    this.specialFieldsCache.clear();\n  }\n\n  /**\n   * In case the provider source doesn't support search criteria, they can be applied here\n   * @param list\n   * @param criteria\n   */\n  public static applyFilters<T> (list:Array<T>, ...criteria: XtStoreCriteria[]): Array<T> {\n    if ((criteria==null)||(criteria.length==0)) return list;\n    return list.filter(element => {\n      for (const criterium of criteria) {\n        const toTest = element[criterium.name as keyof T];\n        switch (criterium.operator) {\n          case XtStoreCriteriaOperator.EQUALS:\n            return criterium.value==toTest;\n          case XtStoreCriteriaOperator.LESS_THAN:\n            return toTest < criterium.value;\n          case XtStoreCriteriaOperator.LESS_THAN_EQUAL:\n            return toTest <= criterium.value;\n          default:\n            throw new Error (\"Operator \"+criterium.operator+\" unknown\");\n        }\n      }\n      return true;\n    });\n    return list;\n  }\n\n  /** Returns any field who is a date, in order to convert it from json. Keep the result in a cache map\n   *\n   * @param name\n   * @param entity\n   * @protected\n   */\n  public static findSpecialFields (name:string, entity:any):SpecialFields {\n    let specialFields = XtStoreProviderHelper.specialFieldsCache.get(name);\n    if (specialFields!=null) return specialFields;\n\n    const curScore: {score:number, field:any} = {score:-1, field:null}\n\n    specialFields = new SpecialFields();\n    const fields = entity.fields;\n    if( fields!=null) {\n      let prop: keyof typeof fields;\n      for (prop in fields) {\n        // Finds the date fields that will need to be converted from json to javascript Date\n        if (fields[prop]?.type==='Date' || fields[prop]?.type==='Date & Time') {\n          specialFields.addDateField(fields[prop]?.name);\n        } else {\n          XtStoreProviderHelper.scoreIdFieldFromEntityField(fields[prop], curScore);\n        }\n      }\n    }\n    if (curScore.score>0) {\n      specialFields.idField=curScore.field;\n    }\n    XtStoreProviderHelper.specialFieldsCache.set(name, specialFields);\n\n    // eslint-disable-next-line no-restricted-syntax\n    //console.debug(\"Found special fields for entity at position \"+name, specialFields);\n    return specialFields;\n  }\n\n  protected static findSpecialFieldsFromData(data: Array<any>, existingFields: SpecialFields) {\n    if( (existingFields.idField==null) && (data?.length>0)) {\n      // We must guess the id field from data\n      const first=data[0];\n      const curScore: {score:number, field:any} = {score:-1, field:null}\n      let prop: keyof typeof first;\n\n      for (prop in first) {\n        XtStoreProviderHelper.scoreIdFieldFromProperty(prop, curScore);\n      }\n      if (curScore.score>0) {\n        const test=data.length>1?data[Math.floor((data.length+1)/2)]:null;\n        if ((test==null) || (test[curScore.field]!=first[curScore.field]))  // Just check that another element doesn't have the same value as an id should be unique\n          existingFields.idField=curScore.field;\n      }\n    }\n  }\n\n  protected static scoreIdFieldFromEntityField (prop:any, score:{score:number, field:any}): boolean {\n    return XtStoreProviderHelper.scoreIdFieldFromProperty(prop?.name, score);\n  }\n\n  protected static scoreIdFieldFromProperty (name:string, score:{score:number, field:any}): boolean {\n    if( name==null)\n      return false;\n    const propName=name.toLowerCase();\n    // Finds if the element is the id field\n    if( propName === \"_id\") {\n      score.field=\"_id\";  // Don't need to process Id\n      score.score = 100;\n      return true;\n    } else {\n      if ((propName == \"id\")||(propName==\"uniqueid\")||(propName==\"identifier\") || (propName=='key') || (propName=='primaryKey')||(propName=='uniqueKey')) {\n        if (score.score<80) {\n          score.score=80;\n          score.field=name;\n        }\n      } else if (propName.includes(\"unique\")||propName.includes(\"primary\")) {\n        if (score.score<50) {\n          score.score = 50;\n          score.field=name;\n        }\n      }else if (propName.includes(\"id\")||propName.includes('key')) {\n        if (score.score<30) {\n          score.score = 30;\n          score.field=name;\n        }\n      }\n      return false;\n    }\n\n  }\n  /**\n   * Ensure _id is removed if necessary before saving the element\n   * @param listToConvert\n   * @param specialFields\n   * @protected\n   */\n  public static cleanUpDataBeforeSaving (listToConvert:Array<any>, specialFields:SpecialFields) : void {\n    if ((specialFields?.idField!=null)&&(specialFields?.idField!='_id')) {\n      listToConvert.forEach(value => {\n        delete value._id;\n      })\n    }\n  }\n\n  /**\n   * Converts dates and dateTimes properties of each element of the array to Typescript format\n   * Ensure _id is set with the right id\n   * @param listToConvert\n   * @param specialFields\n   * @protected\n   */\n  public static cleanUpLoadedData (listToConvert:Array<any>, specialFields:SpecialFields) : void {\n\n    if (specialFields!=null) {\n      if( specialFields.idField==null) {\n        XtStoreProviderHelper.findSpecialFieldsFromData (listToConvert, specialFields);\n      }\n      listToConvert.forEach((val)=> {\n        if ((specialFields.idField!=null)&&(specialFields.idField!=\"_id\")) // We need to copy the id to the standard _id field\n        {\n          val._id=val[specialFields.idField];\n        }\n        specialFields.dateFields?.forEach(prop => {\n          const toConvert = val[prop];\n          if (toConvert!=null) {\n            let timeEpoch =Date.parse(toConvert);\n            if( isNaN(timeEpoch)) {\n              // Invalid date try to remove a possible TZ description in []\n              const tzDescIndex = toConvert.lastIndexOf('[');\n              if (tzDescIndex!=-1) {\n                timeEpoch=Date.parse(toConvert.substring(0, tzDescIndex));\n              }\n            }\n            if (isNaN(timeEpoch)) {\n              delete val[prop];\n            }\n            else {\n              val[prop]=new Date(timeEpoch);\n\n            }\n          }\n        })\n      })\n    }\n  }\n\n  /**\n   * Sort the array using the defined sort declarations across all properties.\n   *\n   * @param toSort\n   * @param sortOptions\n   */\n  static multiSortArray<T>(toSort: T[], sortOptions?: XtSortBy): T[] {\n    if( sortOptions==null)\n      return toSort;\n    return toSort;\n  }\n\n  /**\n   * Calculates sum, avg, min or max values per group\n   * @param values\n   * @param groupBy\n   * @param modelMgr\n   * @param position\n   * @param item\n   */\n  static calculateGroupedByValues<T>(name: string, values: T[], groupBy: XtGroupBy):DontCodeStoreGroupedByEntities|undefined {\n      // We are counting per different value of the groupedBy Item\n    if ((groupBy!=null) && (groupBy.display!=null)) {\n      let fieldToGroupBy=groupBy.of as keyof T;\n      if (groupBy.show!=null) fieldToGroupBy=groupBy.show.valueOf() as keyof T;\n\n      const counters=new Map<any,Map<keyof T, Counters>> ();\n      let lastGroupDelimiter:any;\n      let oneGroupOfCounters=new Map<keyof T, Counters>();\n\n      const fieldsRequired = groupBy.getRequiredListOfFields() as Set<keyof T>;\n      for (const value of values) {\n        if (value[fieldToGroupBy]!=lastGroupDelimiter) {   // We change the group\n          lastGroupDelimiter=value[fieldToGroupBy];\n          const storedGroupOfCounters=counters.get(lastGroupDelimiter);\n          if( storedGroupOfCounters==null) {\n            oneGroupOfCounters = new Map<keyof T, Counters>();\n            counters.set(lastGroupDelimiter, oneGroupOfCounters);\n          }else {\n            oneGroupOfCounters = storedGroupOfCounters;\n          }\n        }\n\n        for (const field of fieldsRequired) {\n          let counter=oneGroupOfCounters?.get(field);\n          if( counter==null) {\n            counter = new Counters();\n            oneGroupOfCounters.set(field, counter);\n          }\n\n          const valSrc=value[field];\n          const val=valSrc;\n          if (valSrc!=null) {\n            const modelMgr:any=null;\n              // If it's an object, we need to set the calculated values as the object itself\n            if ((typeof valSrc === 'object') &&  (!(valSrc instanceof Date)) && (modelMgr!=null)) {\n              if( counter.sum==null) counter.sum=structuredClone(valSrc);\n              else {\n                counter.sum=modelMgr.modifyValues(counter.sum, valSrc, counter.metaData,\n                  (first: any, second: any) => {\n                    if ((first!=null) && (second!=null))\n                      return first + second;\n                    else if (first == null) {\n                      return second;\n                    } else if (second==null) {\n                      return first;\n                    }\n                  }/*,\n                  position, item*/);\n              }\n              const value=modelMgr.extractValue(valSrc, counter.metaData/*,position, item*/);\n              if( counter.minimum==null)  { counter.minimum=valSrc; counter.minAsValue=value}\n              else {\n                const minValue=counter.minAsValue;\n                if ((value!=null) && ((minValue==null) || (value < minValue)) ) { counter.minimum = valSrc; counter.minAsValue=value }\n              }\n\n              if( counter.maximum==null) { counter.maximum=valSrc; counter.maxAsValue=value;}\n              else {\n                const maxValue=counter.maxAsValue;\n\n                if ((value!=null) && ((maxValue==null) || (value > maxValue)))\n                  { counter.maximum = valSrc; counter.maxAsValue = value;}\n\n              }\n\n              if (value!=null) {\n                counter.count++;\n              }\n\n            } else if (typeof val === 'number') {\n              if( counter.sum==null) counter.sum=0;\n              counter.sum=counter.sum+val;\n              if( (counter.minimum==null) || (val < counter.minimum))\n                { counter.minimum=valSrc; counter.minAsValue=valSrc as number;}\n              if( (counter.maximum==null) || (val > counter.maximum))\n                { counter.maximum=valSrc; counter.maxAsValue=valSrc as number;}\n              counter.count++;\n            } else if ((val instanceof Date) && (!isNaN(val.getTime()))) {\n              counter.sum=null;\n              if ((counter.minimum==null) || (val.valueOf() < counter.minimum.valueOf())) {\n                counter.minimum=valSrc;\n              }\n              if ((counter.maximum==null) || (val.valueOf() > counter.maximum.valueOf())) {\n                counter.maximum=valSrc;\n              }\n              counter.count++;\n            } else {  // strings\n              counter.count++;\n            }\n          }\n        }\n      }\n\n      // Now that we have all the counters, let's generate the GroupedFields\n      let ret: DontCodeStoreGroupedByEntities|undefined;\n      if (counters.size>0) {\n        ret = new DontCodeStoreGroupedByEntities(groupBy, new Map<any,DontCodeStoreGroupedByValues[]>);\n        for (const groupKey of counters.keys()) {\n          const group=counters.get(groupKey)!;\n\n          for (const aggregate of Object.values(groupBy.display)) {\n            let value;\n            const counter = group.get(aggregate.of as keyof T);\n            if (counter != null) {\n              switch (aggregate.operation) {\n                case XtGroupByOperation.Count:\n                  value = counter.count;\n                  break;\n                case XtGroupByOperation.Sum:\n                  value = counter.sum;\n                  break;\n                case XtGroupByOperation.Average: {\n                  const modelMgr:any=null;\n                  if ((counter.sum==null) || (counter.count==0)) value=null;\n                  else if ((typeof counter.sum === 'object') &&  (!(counter.sum instanceof Date)) && (modelMgr!=null)) {\n                    value = modelMgr.applyValue(structuredClone(counter.sum),\n                      modelMgr.extractValue(counter.sum, counter.metaData/*, position, item*/)/counter.count,\n                      counter.metaData, undefined/*, position, item*/);\n                  } else value = counter.sum / counter.count;\n                }\n                  break;\n                case XtGroupByOperation.Minimum:\n                  value = counter.minimum;\n                  break;\n                case XtGroupByOperation.Maximum:\n                  value = counter.maximum;\n                  break;\n              }\n              let listOfValues= ret.values?.get(groupKey);\n              if (listOfValues==null) {\n                listOfValues = new Array<DontCodeStoreGroupedByValues>();\n                  ret.values?.set(groupKey, listOfValues);\n              }\n              listOfValues.push(new DontCodeStoreGroupedByValues(aggregate, value));\n            }\n          }\n        }\n        return ret.values!.size>0?ret:undefined;\n      }\n    }\n    return undefined;\n  }\n}\n\n\nexport class DontCodeStorePreparedEntities<T> {\n  constructor(public sortedData:T[], public sortInfo?:XtSortBy, public groupedByEntities?:DontCodeStoreGroupedByEntities) {\n  }\n}\n\nexport class DontCodeStoreGroupedByEntities {\n  constructor(public groupInfo:XtGroupBy, public values?:Map<any,DontCodeStoreGroupedByValues[]>) {\n    if (values==null)\n      this.values=new Map<any,DontCodeStoreGroupedByValues[]>();\n  }\n}\n\nexport class DontCodeStoreGroupedByValues {\n  constructor(public forAggregate:XtGroupByAggregate, public value:any) {\n  }\n}\n\n","import {\n  XtGroupBy,\n  XtGroupByAggregate, XtGroupByOperation,\n  XtGroupByShow,\n  XtSortBy,\n  XtSortByDirection\n} from './xt-store-parameters';\n\nexport interface DontCodeReportType {\n  title: string;\n  for: string;\n  groupedBy?: {[key:string]:XtGroupBy};\n  sortedBy?: {[key:string]:XtSortBy};\n  as?: {[key:string]:DontCodeReportDisplayType};\n}\n\nexport interface DontCodeReportDisplayType {\n  type: string;\n  of: string;\n  by?:string;\n  title: string;\n}\n\nexport class XtStoreSortBy implements XtSortBy {\n\n  direction: XtSortByDirection;\n\n  constructor(public by: string, direction?:XtSortByDirection, public subSort?:XtSortBy) {\n    if (direction==null)   this.direction=XtSortByDirection.None;\n    else this.direction=direction;\n  }\n}\n\nexport class XtStoreGroupBy implements XtGroupBy {\n  display:{[key:string]:XtStoreGroupByAggregate};\n\n  constructor(public of:string, display?:{[key:string]:XtStoreGroupByAggregate}, public show?:XtGroupByShow) {\n    if (display==null) this.display={};\n    else this.display=display;\n  }\n\n  public atLeastOneGroupIsRequested (): boolean {\n    if( (this.display!=null) && (Object.keys(this.display).length>0))\n      return true;\n    return false;\n  }\n\n  getRequiredListOfFields(): Set<string> {\n    const ret = new Set<string>();\n    if( this.display!=null) {\n      for (const aggregate of Object.values(this.display)) {\n        ret.add(aggregate.of);\n      }\n    }\n    return ret;\n  }\n}\n\nexport class XtStoreGroupByAggregate implements XtGroupByAggregate{\n  constructor(public of:string, public operation:XtGroupByOperation) {\n  }\n}\n\n","import {XtDataTransformer} from \"./xt-data-transformer\";\nimport { map, Observable } from 'rxjs';\nimport { XtStoreCriteria, XtGroupBy, XtSortBy } from '../xt-store-parameters';\nimport {\n  DontCodeStoreGroupedByEntities,\n  DontCodeStorePreparedEntities,\n  XtStoreProviderHelper\n} from './xt-store-provider-helper';\nimport { UploadedDocumentInfo } from '../xt-document';\nimport { XtStoreSortBy } from '../xt-reporting';\n\n/**\n * The standard interface for any store provider\n */\nexport type XtStoreProvider<T=never>= {\n  storeEntity( name:string, entity: T): Promise<T>;\n\n  /**\n   * Rejects the promise if the entity is not found\n   * @param name\n   * @param key\n   */\n  safeLoadEntity( name: string, key: any): Promise<T>;\n  loadEntity( name: string, key: any): Promise<T|undefined>;\n\n  deleteEntity(name:string, key: any): Promise<boolean>;\n\n  searchEntities(\n    name: string,\n    ...criteria: XtStoreCriteria[]\n  ): Observable<Array<T>>;\n\n  searchAndPrepareEntities(\n    name: string,\n    sort?:XtSortBy,\n    groupBy?:XtGroupBy,\n    transformer?: XtDataTransformer<T>,\n    ...criteria: XtStoreCriteria[]\n  ): Observable<DontCodeStorePreparedEntities<T>>;\n\n  canStoreDocument(): boolean;\n\n  /**\n   * Upload documents to a server store and returns the url or the id needed to retrieve them.\n   * @param toStore\n   * @param position\n   */\n  storeDocuments(\n    toStore: File[]\n  ): Observable<UploadedDocumentInfo>;\n}\n\nexport abstract class AbstractXtStoreProvider<T=never> implements XtStoreProvider<T> {\n  abstract canStoreDocument(): boolean;\n\n  abstract deleteEntity(name:string, key: any): Promise<boolean>;\n\n  abstract loadEntity(name:string, key: any): Promise<T|undefined>;\n\n  constructor () {\n  }\n\n  safeLoadEntity(name: string, key: any): Promise<T> {\n    return this.loadEntity(name, key).then(value => {\n      if (value==null)\n        return Promise.reject(\"Not found\");\n      else return value;\n    })\n  }\n\n  /**\n   * If the store supports queries with criteria, this function must be implemented, if not, listEntities must be implemented, and this function will apply filters\n   * @param position\n   * @param criteria\n   */\n  searchEntities(name: string, ...criteria: XtStoreCriteria[]): Observable<T[]> {\n    return this.listEntities(name).pipe(\n      map (value => {\n        return XtStoreProviderHelper.applyFilters(value, ...criteria) as T[];\n      })\n    );\n  }\n\n  /**\n   * Returns the list of entities at a given position in the model. Implements at least this function or searchEntities depending on the capability of the store\n   * @param position\n   * @protected\n   */\n  protected listEntities (name:string): Observable<T[]> {\n    return this.searchEntities(name);\n  }\n\n  searchAndPrepareEntities(name: string, sort?: XtSortBy, groupBy?: XtGroupBy, transformer?: XtDataTransformer<T>, ...criteria: XtStoreCriteria[]): Observable<DontCodeStorePreparedEntities<T>> {\n    return this.searchEntities(name, ...criteria).pipe(\n      map (value => {\n        // Run the transformation if any\n        if (transformer!=null) return transformer.postLoadingTransformation(value);\n        else return value;\n      }),\n      map (value => {\n        let groupedByValues:DontCodeStoreGroupedByEntities|undefined;\n        if((sort!=null) || (groupBy?.atLeastOneGroupIsRequested()===true)) {\n          value = XtStoreProviderHelper.multiSortArray(value, this.calculateSortHierarchy(sort, groupBy)) as T[];\n          if (groupBy!=null) {\n            groupedByValues = XtStoreProviderHelper.calculateGroupedByValues(name, value, groupBy);\n          }\n        }\n        return new DontCodeStorePreparedEntities<T> (value, sort, groupedByValues);\n      })\n    );\n  }\n\n  abstract storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo>;\n\n  abstract storeEntity(position: string, entity: T): Promise<T>;\n\n\n  protected calculateSortHierarchy(sort?: XtSortBy, groupBy?: XtGroupBy ):XtSortBy|undefined {\n    // We must first sort by the groupBy, and then by the sort\n    let rootSort:XtSortBy|undefined;\n    if (groupBy!=null) {\n      rootSort=new XtStoreSortBy(groupBy.of, undefined, sort);\n    } else {\n      rootSort=sort;\n    }\n    return rootSort;\n  }\n\n}\n","import { AbstractXtStoreProvider } from './xt-store-provider';\nimport { Observable, of, throwError } from 'rxjs';\nimport { UploadedDocumentInfo } from '../xt-document';\nimport { ManagedData } from 'xt-type/src';\n\nexport class XtMemoryStoreProvider<T extends ManagedData> extends AbstractXtStoreProvider<T> {\n  protected storage=new Map<string, Map<string, T>>();\n\n  override canStoreDocument(): boolean {\n    return false;\n  }\n\n  getSafeStore (name:string):Map<string,T> {\n    let ret = this.storage.get(name);\n    if (ret==null) {\n      ret = new Map<string, T>();\n      this.storage.set(name, ret);\n    }\n    return ret;\n  }\n\n  deleteEntity(name: string, key: any): Promise<boolean> {\n    const store = this.getSafeStore (name);\n    return Promise.resolve(store.delete(key));\n  }\n\n  loadEntity(name: string, key: any): Promise<T | undefined> {\n    const store = this.getSafeStore (name);\n    return Promise.resolve(store.get(key));\n  }\n\n  override listEntities(name: string): Observable<T[]> {\n    const store = this.getSafeStore (name);\n    //console.debug(\"Listing entities for \"+name+\" with \",store);\n    return of (Array.from(store.values()));\n  }\n\n  storeEntity(name: string, entity: T): Promise<T> {\n    const store = this.getSafeStore (name);\n    if (entity._id==null) {\n      entity._id = Math\n        .random().toString(36).substring(2, 8);\n    }\n    store.set(entity._id, entity);\n    return Promise.resolve(entity);\n  }\n\n  override storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo> {\n    return throwError (() => {\n      throw new Error (\"Not implemented.\");\n    });\n  }\n\n}\n","import {lastValueFrom, Observable, Subscription, throwError} from \"rxjs\";\nimport {HttpClient, HttpHeaders} from \"@angular/common/http\";\nimport {inject, Injectable, OnDestroy, Optional} from \"@angular/core\";\nimport {map, mergeAll} from \"rxjs/operators\";\nimport { AbstractXtStoreProvider } from '../store-provider/xt-store-provider';\nimport { XtStoreProviderHelper } from '../store-provider/xt-store-provider-helper';\nimport { XtStoreCriteria } from '../xt-store-parameters';\nimport { UploadedDocumentInfo } from '../xt-document';\n\n/**\n * A Store Provider that uses the DontCode API to store / read application data\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class XtApiStoreProvider<T=never> extends AbstractXtStoreProvider<T> implements OnDestroy {\n\n  protected http: HttpClient = inject (HttpClient, {optional:true}) as any;\n\n  apiUrl: string;\n  docUrl: string;\n  subscriptions = new Subscription();\n\n  constructor(http?:HttpClient/* protected configService: CommonConfigService*/) {\n    super();\n    if (http!=null) {\n      this.http=http;\n    }\n\n    if (this.http==null) {\n      throw new Error (\"You must provide an HttpClient, either through constructor or injection.\");\n    }\n    this.apiUrl = 'https://test.dont-code.net/data';\n    this.docUrl = 'https://test.dont-code.net/documents';\n\n    /*this.updateConfig (this.configService.getConfig());\n    this.subscriptions.add (this.configService.getUpdates ().pipe (map ((updatedConfig) => {\n      this.updateConfig (updatedConfig);\n    })).subscribe());*/\n\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n/*  updateConfig(newConfig: Readonly<CommonLibConfig>) {\n    if (newConfig.storeApiUrl!=null)\n      this.apiUrl = newConfig.storeApiUrl;\n    if (newConfig.documentApiUrl!=null)\n      this.docUrl = newConfig.documentApiUrl;\n  }*/\n\n  storeEntity(name: string, data: T): Promise<T> {\n\n    const id=(data as any)._id;\n    // Reconverts dates or Ids\n    const specialFields = XtStoreProviderHelper.findSpecialFields(name, { });\n    XtStoreProviderHelper.cleanUpDataBeforeSaving([data], specialFields);\n\n    if( id != undefined) {\n      return lastValueFrom(this.http.put<T>(this.apiUrl+'/'+name+'/'+id, data, {observe:\"body\", responseType:\"json\"}));\n    } else {\n      return lastValueFrom(this.http.post<T>(this.apiUrl+'/'+name, data, {observe:\"body\", responseType:\"json\"}));\n    }\n  }\n\n  loadEntity(name: string, key: any): Promise<T|undefined> {\n    const obs = this.http.get<T>(this.apiUrl+'/'+name+'/'+key, {observe:\"body\", responseType:\"json\"});\n    const specialFields = XtStoreProviderHelper.findSpecialFields(name, { });\n\n    return lastValueFrom(obs).then((value) => {\n      XtStoreProviderHelper.cleanUpLoadedData([value], specialFields);\n      return value;\n    });\n  }\n\n  deleteEntity(name: string, key: any): Promise<boolean> {\n    return lastValueFrom(this.http.delete(this.apiUrl+'/'+name+'/'+key, {observe:\"body\", responseType:\"json\"})).then(value => {\n      return true;\n    });\n    }\n\n  override searchEntities(name: string, ...criteria: XtStoreCriteria[]): Observable<T[]> {\n\n    const specialFields = XtStoreProviderHelper.findSpecialFields(name, { });\n    return this.http.get(this.apiUrl+'/'+name, {observe:\"body\", responseType:\"json\"}).pipe(\n        map(value => {\n          XtStoreProviderHelper.cleanUpLoadedData(value as T [], specialFields);\n          return value as T[];\n        }),map(value => {\n          return XtStoreProviderHelper.applyFilters( value, ...criteria);\n        }\n      )\n    );\n    }\n\n  canStoreDocument(): boolean {\n    return true;\n  }\n\n  storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo> {\n    const myFormData = new FormData();\n    const headers = new HttpHeaders();\n    headers.append('Content-Type', 'multipart/form-data');\n    headers.append('Accept', 'application/json');\n    let count=0;\n    // store files details into formdata\n    toStore.forEach( file => {\n      myFormData.append('document#'+count, file);\n      count++;\n    });\n    //HTTP Angular service, which will send call to Laravel API With headers and myformdata\n    return this.http.post<UploadedDocumentInfo[]>(this.docUrl, myFormData, { headers: headers }).pipe(\n      mergeAll ()\n    );\n  }\n\n}\n","import { XtStoreManager } from '../store-manager/xt-store-manager';\nimport { XtMemoryStoreProvider } from '../store-provider/xt-memory-store-provider';\nimport { ManagedData } from 'xt-type';\nimport { XtStoreProvider } from '../store-provider/xt-store-provider';\n\n\nexport class StoreTestBed {\n  readonly storeManager = new XtStoreManager();\n\n  public ensureMemoryProviderOnly () {\n    XtStoreManager.setTestMode(new XtMemoryStoreProvider<ManagedData>());\n  }\n\n  public async defineTestDataFor (entityName:string, testData:ManagedData[]): Promise<void> {\n    for (const testEntity of testData) {\n      await this.storeManager.storeEntity(entityName, testEntity);\n    }\n  }\n\n  public getStoreManager () {\n    return this.storeManager;\n  }\n\n  public getStoreProviderFor (entityName:string):XtStoreProvider {\n    return this.storeManager.getProviderSafe(entityName);\n  }\n}\n","/*\n * Public API Surface of store\n */\n\nexport * from './store-manager/xt-store-manager';\nexport * from './store-provider/xt-store-provider';\nexport * from './store-provider/xt-store-provider-helper';\nexport * from './store-provider/xt-memory-store-provider';\n\nexport * from './api-provider/xt-api-store-provider';\n\nexport * from './xt-store-parameters';\nexport * from './xt-document';\nexport * from './xt-reporting';\n\nexport * from './test/store-test-bed';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["map"],"mappings":"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"}

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="xt-store" />
+export * from './public-api';

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "xt-store",
+  "version": "0.4.0",
+  "peerDependencies": {
+    "@angular/common": "^19.1.0",
+    "@angular/core": "^19.1.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/xt-store.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/xt-store.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,9 @@
+export * from './store-manager/xt-store-manager';
+export * from './store-provider/xt-store-provider';
+export * from './store-provider/xt-store-provider-helper';
+export * from './store-provider/xt-memory-store-provider';
+export * from './api-provider/xt-api-store-provider';
+export * from './xt-store-parameters';
+export * from './xt-document';
+export * from './xt-reporting';
+export * from './test/store-test-bed';

package/store-manager/xt-store-manager.d.ts

@@ -0,0 +1,33 @@
+import { XtStoreProvider } from '../store-provider/xt-store-provider';
+import { Observable } from 'rxjs';
+import { UploadedDocumentInfo } from '../xt-document';
+import { XtStoreCriteria, XtGroupBy, XtSortBy } from '../xt-store-parameters';
+import { DontCodeStorePreparedEntities } from '../store-provider/xt-store-provider-helper';
+import { XtDataTransformer } from '../store-provider/xt-data-transformer';
+export declare class XtStoreManager {
+    private _default?;
+    private providerByPosition;
+    private providerByType;
+    protected static testProvider: XtStoreProvider<any> | null;
+    constructor(provider?: XtStoreProvider<any>);
+    reset(): void;
+    getProvider<T = never>(name?: string): XtStoreProvider<T> | undefined;
+    getProviderSafe<T = never>(name?: string): XtStoreProvider<T>;
+    getDefaultProvider<T = never>(): XtStoreProvider<T> | undefined;
+    getDefaultProviderSafe<T = never>(): XtStoreProvider<T>;
+    setProvider<T = never>(value: XtStoreProvider<T>, name?: string): void;
+    setProviderForSourceType<T = never>(value: XtStoreProvider<T>, srcType: string): void;
+    setDefaultProvider<T = never>(value: XtStoreProvider<T>): void;
+    removeProvider(name?: string): void;
+    removeProviderForSourceType(srcType: string): void;
+    removeDefaultProvider(): void;
+    storeEntity<T = never>(name: string, entity: T): Promise<T>;
+    loadEntity<T = never>(name: string, key: any): Promise<T | undefined>;
+    safeLoadEntity<T = never>(name: string, key: any): Promise<T>;
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    searchEntities<T = never>(name: string, ...criteria: XtStoreCriteria[]): Observable<Array<T>>;
+    searchAndPrepareEntities<T = never>(name: string, sort?: XtSortBy, groupBy?: XtGroupBy, dataTransformer?: XtDataTransformer, ...criteria: XtStoreCriteria[]): Observable<DontCodeStorePreparedEntities<T>>;
+    canStoreDocument(name?: string): boolean;
+    storeDocuments(toStore: File[], name?: string): Observable<UploadedDocumentInfo>;
+    static setTestMode(testProvider: XtStoreProvider<any>): void;
+}

package/store-provider/xt-data-transformer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enable custom transformation of data
+ */
+export interface XtDataTransformer<T = never> {
+    /**
+     * Enable transformation of data right after it has been loaded from the store
+     * @param source
+     */
+    postLoadingTransformation(source: any[]): T[];
+}

package/store-provider/xt-memory-store-provider.d.ts

@@ -0,0 +1,14 @@
+import { AbstractXtStoreProvider } from './xt-store-provider';
+import { Observable } from 'rxjs';
+import { UploadedDocumentInfo } from '../xt-document';
+import { ManagedData } from 'xt-type/src';
+export declare class XtMemoryStoreProvider<T extends ManagedData> extends AbstractXtStoreProvider<T> {
+    protected storage: Map<string, Map<string, T>>;
+    canStoreDocument(): boolean;
+    getSafeStore(name: string): Map<string, T>;
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    listEntities(name: string): Observable<T[]>;
+    storeEntity(name: string, entity: T): Promise<T>;
+    storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo>;
+}

package/store-provider/xt-store-provider-helper.d.ts

@@ -0,0 +1,81 @@
+import { SpecialFields } from 'xt-type';
+import { XtGroupByAggregate, XtStoreCriteria, XtGroupBy, XtSortBy } from '../xt-store-parameters';
+/**
+ * Helps handle metadata information about loaded items
+ */
+export declare class XtStoreProviderHelper {
+    static specialFieldsCache: Map<string, SpecialFields>;
+    /**
+     * In case some entity definition has changed, clear the cache
+     */
+    static clearConfigCache(): void;
+    /**
+     * In case the provider source doesn't support search criteria, they can be applied here
+     * @param list
+     * @param criteria
+     */
+    static applyFilters<T>(list: Array<T>, ...criteria: XtStoreCriteria[]): Array<T>;
+    /** Returns any field who is a date, in order to convert it from json. Keep the result in a cache map
+     *
+     * @param name
+     * @param entity
+     * @protected
+     */
+    static findSpecialFields(name: string, entity: any): SpecialFields;
+    protected static findSpecialFieldsFromData(data: Array<any>, existingFields: SpecialFields): void;
+    protected static scoreIdFieldFromEntityField(prop: any, score: {
+        score: number;
+        field: any;
+    }): boolean;
+    protected static scoreIdFieldFromProperty(name: string, score: {
+        score: number;
+        field: any;
+    }): boolean;
+    /**
+     * Ensure _id is removed if necessary before saving the element
+     * @param listToConvert
+     * @param specialFields
+     * @protected
+     */
+    static cleanUpDataBeforeSaving(listToConvert: Array<any>, specialFields: SpecialFields): void;
+    /**
+     * Converts dates and dateTimes properties of each element of the array to Typescript format
+     * Ensure _id is set with the right id
+     * @param listToConvert
+     * @param specialFields
+     * @protected
+     */
+    static cleanUpLoadedData(listToConvert: Array<any>, specialFields: SpecialFields): void;
+    /**
+     * Sort the array using the defined sort declarations across all properties.
+     *
+     * @param toSort
+     * @param sortOptions
+     */
+    static multiSortArray<T>(toSort: T[], sortOptions?: XtSortBy): T[];
+    /**
+     * Calculates sum, avg, min or max values per group
+     * @param values
+     * @param groupBy
+     * @param modelMgr
+     * @param position
+     * @param item
+     */
+    static calculateGroupedByValues<T>(name: string, values: T[], groupBy: XtGroupBy): DontCodeStoreGroupedByEntities | undefined;
+}
+export declare class DontCodeStorePreparedEntities<T> {
+    sortedData: T[];
+    sortInfo?: XtSortBy | undefined;
+    groupedByEntities?: DontCodeStoreGroupedByEntities | undefined;
+    constructor(sortedData: T[], sortInfo?: XtSortBy | undefined, groupedByEntities?: DontCodeStoreGroupedByEntities | undefined);
+}
+export declare class DontCodeStoreGroupedByEntities {
+    groupInfo: XtGroupBy;
+    values?: Map<any, DontCodeStoreGroupedByValues[]> | undefined;
+    constructor(groupInfo: XtGroupBy, values?: Map<any, DontCodeStoreGroupedByValues[]> | undefined);
+}
+export declare class DontCodeStoreGroupedByValues {
+    forAggregate: XtGroupByAggregate;
+    value: any;
+    constructor(forAggregate: XtGroupByAggregate, value: any);
+}

package/store-provider/xt-store-provider.d.ts

@@ -0,0 +1,51 @@
+import { XtDataTransformer } from "./xt-data-transformer";
+import { Observable } from 'rxjs';
+import { XtStoreCriteria, XtGroupBy, XtSortBy } from '../xt-store-parameters';
+import { DontCodeStorePreparedEntities } from './xt-store-provider-helper';
+import { UploadedDocumentInfo } from '../xt-document';
+/**
+ * The standard interface for any store provider
+ */
+export type XtStoreProvider<T = never> = {
+    storeEntity(name: string, entity: T): Promise<T>;
+    /**
+     * Rejects the promise if the entity is not found
+     * @param name
+     * @param key
+     */
+    safeLoadEntity(name: string, key: any): Promise<T>;
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    searchEntities(name: string, ...criteria: XtStoreCriteria[]): Observable<Array<T>>;
+    searchAndPrepareEntities(name: string, sort?: XtSortBy, groupBy?: XtGroupBy, transformer?: XtDataTransformer<T>, ...criteria: XtStoreCriteria[]): Observable<DontCodeStorePreparedEntities<T>>;
+    canStoreDocument(): boolean;
+    /**
+     * Upload documents to a server store and returns the url or the id needed to retrieve them.
+     * @param toStore
+     * @param position
+     */
+    storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo>;
+};
+export declare abstract class AbstractXtStoreProvider<T = never> implements XtStoreProvider<T> {
+    abstract canStoreDocument(): boolean;
+    abstract deleteEntity(name: string, key: any): Promise<boolean>;
+    abstract loadEntity(name: string, key: any): Promise<T | undefined>;
+    constructor();
+    safeLoadEntity(name: string, key: any): Promise<T>;
+    /**
+     * If the store supports queries with criteria, this function must be implemented, if not, listEntities must be implemented, and this function will apply filters
+     * @param position
+     * @param criteria
+     */
+    searchEntities(name: string, ...criteria: XtStoreCriteria[]): Observable<T[]>;
+    /**
+     * Returns the list of entities at a given position in the model. Implements at least this function or searchEntities depending on the capability of the store
+     * @param position
+     * @protected
+     */
+    protected listEntities(name: string): Observable<T[]>;
+    searchAndPrepareEntities(name: string, sort?: XtSortBy, groupBy?: XtGroupBy, transformer?: XtDataTransformer<T>, ...criteria: XtStoreCriteria[]): Observable<DontCodeStorePreparedEntities<T>>;
+    abstract storeDocuments(toStore: File[]): Observable<UploadedDocumentInfo>;
+    abstract storeEntity(position: string, entity: T): Promise<T>;
+    protected calculateSortHierarchy(sort?: XtSortBy, groupBy?: XtGroupBy): XtSortBy | undefined;
+}

package/test/store-test-bed.d.ts

@@ -0,0 +1,10 @@
+import { XtStoreManager } from '../store-manager/xt-store-manager';
+import { ManagedData } from 'xt-type';
+import { XtStoreProvider } from '../store-provider/xt-store-provider';
+export declare class StoreTestBed {
+    readonly storeManager: XtStoreManager;
+    ensureMemoryProviderOnly(): void;
+    defineTestDataFor(entityName: string, testData: ManagedData[]): Promise<void>;
+    getStoreManager(): XtStoreManager;
+    getStoreProviderFor(entityName: string): XtStoreProvider;
+}

package/xt-document.d.ts

@@ -0,0 +1,5 @@
+export type UploadedDocumentInfo = {
+    documentName: string;
+    isUrl: boolean;
+    documentId?: string;
+};

package/xt-reporting.d.ts

@@ -0,0 +1,43 @@
+import { XtGroupBy, XtGroupByAggregate, XtGroupByOperation, XtGroupByShow, XtSortBy, XtSortByDirection } from './xt-store-parameters';
+export interface DontCodeReportType {
+    title: string;
+    for: string;
+    groupedBy?: {
+        [key: string]: XtGroupBy;
+    };
+    sortedBy?: {
+        [key: string]: XtSortBy;
+    };
+    as?: {
+        [key: string]: DontCodeReportDisplayType;
+    };
+}
+export interface DontCodeReportDisplayType {
+    type: string;
+    of: string;
+    by?: string;
+    title: string;
+}
+export declare class XtStoreSortBy implements XtSortBy {
+    by: string;
+    subSort?: XtSortBy | undefined;
+    direction: XtSortByDirection;
+    constructor(by: string, direction?: XtSortByDirection, subSort?: XtSortBy | undefined);
+}
+export declare class XtStoreGroupBy implements XtGroupBy {
+    of: string;
+    show?: XtGroupByShow | undefined;
+    display: {
+        [key: string]: XtStoreGroupByAggregate;
+    };
+    constructor(of: string, display?: {
+        [key: string]: XtStoreGroupByAggregate;
+    }, show?: XtGroupByShow | undefined);
+    atLeastOneGroupIsRequested(): boolean;
+    getRequiredListOfFields(): Set<string>;
+}
+export declare class XtStoreGroupByAggregate implements XtGroupByAggregate {
+    of: string;
+    operation: XtGroupByOperation;
+    constructor(of: string, operation: XtGroupByOperation);
+}

package/xt-store-parameters.d.ts

@@ -0,0 +1,46 @@
+export declare enum XtStoreCriteriaOperator {
+    EQUALS = "=",
+    LESS_THAN = "<",
+    LESS_THAN_EQUAL = "<="
+}
+export declare class XtStoreCriteria {
+    name: string;
+    value: any;
+    operator: XtStoreCriteriaOperator;
+    constructor(name: string, value: any, operator?: XtStoreCriteriaOperator);
+}
+export type XtSortBy = {
+    by: string;
+    direction: XtSortByDirection;
+};
+export declare enum XtSortByDirection {
+    None = "None",
+    Ascending = "Ascending",
+    Descending = "Descending"
+}
+export declare enum XtGroupByShow {
+    OnlyLowest = "OnlyLowest",
+    OnlyHighest = "OnlyHighest"
+}
+export declare enum XtGroupByOperation {
+    Count = "Count",
+    Sum = "Sum",
+    Average = "Average",
+    Minimum = "Minimum",
+    Maximum = "Maximum"
+}
+export type XtGroupBy = {
+    of: string;
+    display: {
+        [key: string]: XtGroupByAggregate;
+    };
+    show?: XtGroupByShow;
+    label?: string;
+    atLeastOneGroupIsRequested(): boolean;
+    getRequiredListOfFields(): Set<string>;
+};
+export type XtGroupByAggregate = {
+    operation: XtGroupByOperation;
+    of: string;
+    label?: string;
+};