@ecodev/natural 62.1.2 → 63.0.0

package/fesm2022/ecodev-natural-vanilla.mjs

@@ -0,0 +1,1193 @@
+import { pickBy, cloneDeep, uniq, groupBy, mergeWith, defaultsDeep, omit, merge, pick, defaults } from 'lodash-es';
+import { BehaviorSubject, from, switchMap, ReplaySubject, Subject, debounceTime, raceWith, take, mergeMap, EMPTY, shareReplay, catchError, of, Observable, forkJoin, map, first, combineLatest } from 'rxjs';
+import { Apollo, gql } from 'apollo-angular';
+import { NetworkStatus } from '@apollo/client/core';
+import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { takeWhile, map as map$1, switchMap as switchMap$1, filter, debounceTime as debounceTime$1, tap, shareReplay as shareReplay$1, startWith } from 'rxjs/operators';
+import * as i0 from '@angular/core';
+import { Injectable, inject } from '@angular/core';
+
+function formatIsoDate(date) {
+    if (!date) {
+        return null;
+    }
+    const y = date.getFullYear();
+    const m = date.getMonth() + 1;
+    const d = date.getDate();
+    return y + '-' + (m < 10 ? '0' : '') + m + '-' + (d < 10 ? '0' : '') + d;
+}
+/**
+ * Format a date and time in a way that will preserve the local time zone.
+ * This allows the server side to know the day (without time) that was selected on client side.
+ *
+ * So something like: "2021-09-23T17:57:16+09:00"
+ */
+function formatIsoDateTime(date) {
+    const timezoneOffsetInMinutes = date.getTimezoneOffset();
+    const timezoneOffsetInHours = -Math.trunc(timezoneOffsetInMinutes / 60); // UTC minus local time
+    const sign = timezoneOffsetInHours >= 0 ? '+' : '-';
+    const hoursLeadingZero = Math.abs(timezoneOffsetInHours) < 10 ? '0' : '';
+    const remainderMinutes = -(timezoneOffsetInMinutes % 60);
+    const minutesLeadingZero = Math.abs(remainderMinutes) < 10 ? '0' : '';
+    // It's a bit unfortunate that we need to construct a new Date instance,
+    // but we don't want the original Date instance to be modified
+    const correctedDate = new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+    correctedDate.setHours(date.getHours() + timezoneOffsetInHours);
+    const iso = correctedDate
+        .toISOString()
+        .replace(/\.\d{3}Z/, '')
+        .replace('Z', '');
+    return (iso +
+        sign +
+        hoursLeadingZero +
+        Math.abs(timezoneOffsetInHours).toString() +
+        ':' +
+        minutesLeadingZero +
+        remainderMinutes);
+}
+/**
+ * Relations to full objects are converted to their IDs only.
+ *
+ * So {user: {id: 123}} becomes {user: 123}
+ */
+function relationsToIds(object) {
+    const newObj = {};
+    Object.keys(object).forEach(key => {
+        let value = object[key];
+        if (value === null || value === undefined) {
+            // noop
+        }
+        else if (hasId(value)) {
+            value = value.id;
+        }
+        else if (Array.isArray(value)) {
+            value = value.map((i) => (hasId(i) ? i.id : i));
+        }
+        else if (typeof value === 'object' && !(value instanceof File) && !(value instanceof Date)) {
+            value = pickBy(value, (v, k) => k !== '__typename'); // omit(value, ['__typename']) ?
+        }
+        newObj[key] = value;
+    });
+    return newObj;
+}
+function hasId(value) {
+    return !!value && typeof value === 'object' && 'id' in value && !!value.id;
+}
+/**
+ * Returns the plural form of the given name
+ *
+ * This is **not** necessarily valid english grammar. Its only purpose is for internal usage, not for humans.
+ *
+ * This **MUST** be kept in sync with `\Ecodev\Felix\Api\Plural:make()`.
+ *
+ * This is a bit performance-sensitive, so we should keep it fast and only cover cases that we actually need.
+ */
+function makePlural(name) {
+    // Words ending in a y preceded by a vowel form their plurals by adding -s:
+    if (/[aeiou]y$/.exec(name)) {
+        return name + 's';
+    }
+    const plural = name + 's';
+    return plural.replace(/ys$/, 'ies').replace(/ss$/, 'ses').replace(/xs$/, 'xes');
+}
+/**
+ * Returns the string with the first letter as capital
+ */
+function upperCaseFirstLetter(term) {
+    return term.charAt(0).toUpperCase() + term.slice(1);
+}
+/**
+ * Replace all attributes of first object with the ones provided by the second, but keeps the reference
+ */
+function replaceObjectKeepingReference(obj, newObj) {
+    if (!obj || !newObj) {
+        return;
+    }
+    Object.keys(obj).forEach(key => {
+        delete obj[key];
+    });
+    Object.keys(newObj).forEach(key => {
+        obj[key] = newObj[key];
+    });
+}
+/**
+ * Get contrasted color for text in the slider thumb
+ * @param hexBgColor string in hexadecimals representing the background color
+ */
+function getForegroundColor(hexBgColor) {
+    const rgb = hexToRgb(hexBgColor.slice(0, 7)); // splice remove alpha and consider only "visible" color at 100% alpha
+    const o = Math.round((rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000);
+    return o > 125 ? 'black' : 'white';
+}
+function hexToRgb(hex) {
+    // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+    const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+    hex = hex.replace(shorthandRegex, (m, r, g, b) => {
+        return r + r + g + g + b + b;
+    });
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : {
+            r: 0,
+            g: 0,
+            b: 0,
+        };
+}
+/**
+ * Convert RGB color to hexadecimal color
+ *
+ * ```ts
+ * rgbToHex('rgb(255, 00, 255)'); // '#FF00FF'
+ * ```
+ */
+function rgbToHex(rgb) {
+    const m = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/.exec(rgb);
+    if (!m) {
+        return rgb;
+    }
+    return '#' + [m[1], m[2], m[3]].map(x => parseInt(x).toString(16).toUpperCase().padStart(2, '0')).join('');
+}
+/**
+ * During lodash.mergeWith, overrides arrays
+ */
+function mergeOverrideArray(destValue, source) {
+    if (Array.isArray(source)) {
+        return source;
+    }
+}
+/**
+ * Copy text to clipboard.
+ * Accepts line breaks `\n` as textarea do.
+ */
+function copyToClipboard(document, text) {
+    const input = document.createElement('textarea');
+    document.body.append(input);
+    input.value = text;
+    input.select();
+    document.execCommand('copy');
+    document.body.removeChild(input);
+}
+function deepFreeze(o) {
+    Object.values(o).forEach(v => Object.isFrozen(v) || deepFreeze(v));
+    return Object.freeze(o);
+}
+/**
+ * Return a valid PaginationInput from whatever is available from data. Invalid properties/types will be dropped.
+ */
+function validatePagination(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return null;
+    }
+    const pagination = {};
+    if ('offset' in data && (data.offset === null || typeof data.offset === 'number')) {
+        pagination.offset = data.offset;
+    }
+    if ('pageIndex' in data && (data.pageIndex === null || typeof data.pageIndex === 'number')) {
+        pagination.pageIndex = data.pageIndex;
+    }
+    if ('pageSize' in data && (data.pageSize === null || typeof data.pageSize === 'number')) {
+        pagination.pageSize = data.pageSize;
+    }
+    return pagination;
+}
+/**
+ * Return a valid Sortings from whatever is available from data. Invalid properties/types will be dropped.
+ */
+function validateSorting(data) {
+    if (!Array.isArray(data)) {
+        return null;
+    }
+    const result = [];
+    data.forEach(s => {
+        const r = validateOneSorting(s);
+        if (r) {
+            result.push(r);
+        }
+    });
+    return result;
+}
+function validateOneSorting(data) {
+    if (!data || typeof data !== 'object' || !('field' in data)) {
+        return null;
+    }
+    const sorting = { field: data.field };
+    if ('order' in data &&
+        (data.order === SortingOrder.ASC || data.order === SortingOrder.DESC || data.order === null)) {
+        sorting.order = data.order;
+    }
+    if ('nullAsHighest' in data && (data.nullAsHighest === null || typeof data.nullAsHighest === 'boolean')) {
+        sorting.nullAsHighest = data.nullAsHighest;
+    }
+    if ('emptyStringAsHighest' in data &&
+        (data.emptyStringAsHighest === null || typeof data.emptyStringAsHighest === 'boolean')) {
+        sorting.emptyStringAsHighest = data.emptyStringAsHighest;
+    }
+    return sorting;
+}
+/**
+ * Return valid columns from whatever is available from data. Invalid properties/types will be dropped.
+ */
+function validateColumns(data) {
+    if (typeof data !== 'string') {
+        return null;
+    }
+    return data.split(',').filter(string => string);
+}
+
+// Basic; loosely typed structure for graphql-doctrine filters
+// Logical operator to be used in conditions
+var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["AND"] = "AND";
+    LogicalOperator["OR"] = "OR";
+})(LogicalOperator || (LogicalOperator = {}));
+// Join types to be used in DQL
+var JoinType;
+(function (JoinType) {
+    JoinType["innerJoin"] = "innerJoin";
+    JoinType["leftJoin"] = "leftJoin";
+})(JoinType || (JoinType = {}));
+
+function hasMixedGroupLogic(groups) {
+    // Complete lack of definition by fallback on AND operator
+    const completedGroups = cloneDeep(groups).map(group => {
+        if (!group.groupLogic) {
+            group.groupLogic = LogicalOperator.AND;
+        }
+        return group;
+    });
+    const groupLogics = uniq(Object.keys(groupBy(completedGroups.slice(1), 'groupLogic')));
+    return groupLogics.length > 1;
+}
+
+var SortingOrder;
+(function (SortingOrder) {
+    SortingOrder["ASC"] = "ASC";
+    SortingOrder["DESC"] = "DESC";
+})(SortingOrder || (SortingOrder = {}));
+/**
+ * During lodash merge, concat arrays
+ */
+function mergeConcatArray(destValue, source) {
+    if (Array.isArray(source)) {
+        if (destValue) {
+            return destValue.concat(source);
+        }
+        else {
+            return source;
+        }
+    }
+}
+/**
+ * Filter manager stores a set of channels that contain a variable object and exposes an observable "variables" that updates with the result
+ * of all channels merged together.
+ *
+ * A channel is supposed to be used by a given aspect of the GUI (pagination, sorting, search, others ?).
+ *
+ * ```ts
+ * const fm = new QueryVariablesManager();
+ * fm.merge('componentA-variables', {a : [1, 2, 3]});
+ * ```
+ *
+ * Variables attributes is a BehaviorSubject. That mean it's not mandatory to subscribe, we can just call getValue or value attributes on
+ * it :
+ *
+ * ```ts
+ * console.log(fm.variables.value); // {a : [1, 2, 3]}
+ * ```
+ *
+ * Set new variables for 'componentA-variables':
+ *
+ * ```ts
+ * fm.merge('componentA-variables', {a : [1, 2]});
+ * console.log(fm.variables.value); // {a : [1, 2, 3]}
+ * ```
+ *
+ * Set new variables for new channel:
+ *
+ * ```ts
+ * fm.merge('componentB-variables', {a : [3, 4]});
+ * console.log(fm.variables.value); // {a : [1, 2, 3, 4]}
+ * ```
+ */
+class NaturalQueryVariablesManager {
+    variables = new BehaviorSubject(undefined);
+    channels = new Map();
+    constructor(queryVariablesManager) {
+        if (queryVariablesManager) {
+            this.channels = queryVariablesManager.getChannelsCopy();
+            this.updateVariables();
+        }
+    }
+    /**
+     * Set or override all the variables that may exist in the given channel
+     */
+    set(channelName, variables) {
+        // cloneDeep to change reference and prevent some interactions when merge
+        if (variables) {
+            this.channels.set(channelName, cloneDeep(variables));
+        }
+        else {
+            this.channels.delete(channelName);
+        }
+        this.updateVariables();
+    }
+    /**
+     * Return a deep clone of the variables for the given channel name.
+     *
+     * Avoid returning the same reference to prevent an attribute change, then another channel update that would
+     * used this changed attribute without having explicitly asked QueryVariablesManager to update it.
+     */
+    get(channelName) {
+        return cloneDeep(this.channels.get(channelName));
+    }
+    /**
+     * Merge variable into a channel, overriding arrays in same channel / key
+     */
+    merge(channelName, newVariables) {
+        const variables = this.channels.get(channelName);
+        if (variables) {
+            mergeWith(variables, cloneDeep(newVariables), mergeOverrideArray); // merge preserves references, cloneDeep prevent that
+            this.updateVariables();
+        }
+        else {
+            this.set(channelName, newVariables);
+        }
+    }
+    /**
+     * Apply default values to a channel
+     * Note : lodash defaults only defines values on destinations keys that are undefined
+     */
+    defaults(channelName, newVariables) {
+        const variables = this.channels.get(channelName);
+        if (variables) {
+            defaultsDeep(variables, newVariables);
+            this.updateVariables();
+        }
+        else {
+            this.set(channelName, newVariables);
+        }
+    }
+    getChannelsCopy() {
+        return new Map(this.channels);
+    }
+    /**
+     * Merge channels in a single object
+     * Arrays are concatenated
+     * Filter groups are combined smartly (see mergeGroupList)
+     */
+    updateVariables() {
+        const merged = {};
+        this.channels.forEach(channelVariables => {
+            if (channelVariables.filter) {
+                // Merge filter's groups first
+                const groups = this.mergeGroupList(merged.filter?.groups ? merged.filter.groups : [], channelVariables.filter.groups || []);
+                // Merge filter key (that contain groups)
+                if (groups?.length) {
+                    if (merged.filter) {
+                        merged.filter.groups = groups;
+                    }
+                    else {
+                        merged.filter = { groups: groups };
+                    }
+                }
+                else {
+                    mergeWith(merged, { filter: channelVariables.filter }, mergeConcatArray);
+                }
+            }
+            // Merge other attributes than filter
+            mergeWith(merged, omit(channelVariables, 'filter'), mergeConcatArray);
+        });
+        this.variables.next(merged);
+    }
+    /**
+     * Cross merge two filters
+     * Only accepts groups with same groupLogic (ignores the first one, because there is no groupLogic in this one)
+     * @throws In case two non-empty lists of groups are given and at one of them mix groupLogic value, throws an error
+     */
+    mergeGroupList(groupsA, groupsB) {
+        if (groupsA.length === 0 && groupsB.length === 0) {
+            return []; // empty listings, return empty lists
+        }
+        if (groupsA.length === 0 && groupsB.length > 0) {
+            return groupsB; // One list is empty, return the one that is not
+        }
+        if (groupsB.length === 0 && groupsA.length > 0) {
+            return groupsA; // One list is empty, return the one that is not
+        }
+        const groups = [];
+        if (hasMixedGroupLogic(groupsA) || hasMixedGroupLogic(groupsB)) {
+            throw Error('QueryVariables groups contain mixed group logics');
+        }
+        groupsA.forEach(groupA => {
+            groupsB.forEach(groupB => {
+                groups.push(mergeWith(cloneDeep(groupA), groupB, mergeConcatArray));
+            });
+        });
+        return groups;
+    }
+}
+
+function bufferToHexa(hashBuffer) {
+    const hashArray = new Uint8Array(hashBuffer); // convert buffer to byte array
+    return hashArray.reduce((result, byte) => result + byte.toString(16).padStart(2, '0'), ''); // convert bytes to hex string
+}
+/**
+ * Thin wrapper around browsers' native SubtleCrypto for convenience of use
+ */
+async function sha256(message) {
+    const msgUint8 = new TextEncoder().encode(message); // encode as (utf-8) Uint8Array
+    const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8); // hash the message
+    return bufferToHexa(hashBuffer);
+}
+/**
+ * Thin wrapper around browsers' native SubtleCrypto for convenience of use
+ */
+async function hmacSha256(secret, payload) {
+    const encoder = new TextEncoder();
+    const algorithm = { name: 'HMAC', hash: 'SHA-256' };
+    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), algorithm, false, ['sign']);
+    const signature = await crypto.subtle.sign(algorithm.name, key, encoder.encode(payload));
+    return bufferToHexa(signature);
+}
+
+function getOperations(req) {
+    if (req.body instanceof FormData) {
+        const operations = req.body.get('operations');
+        if (typeof operations !== 'string') {
+            throw new Error('Cannot sign a GraphQL query that is using FormData but that is missing the key `operations`');
+        }
+        return operations;
+    }
+    else {
+        return JSON.stringify(req.body);
+    }
+}
+/**
+ * Sign all HTTP POST requests that are GraphQL queries against `/graphql` endpoint with a custom signature.
+ *
+ * The server will validate the signature before executing the GraphQL query.
+ */
+function graphqlQuerySigner(key) {
+    return (req, next) => {
+        const mustSign = req.method === 'POST' && /\/graphql(\?|$)/.exec(req.url);
+        if (!mustSign) {
+            return next(req);
+        }
+        const operations = getOperations(req);
+        const timestamp = Math.round(Date.now() / 1000);
+        const payload = timestamp + operations;
+        return from(hmacSha256(key, payload)).pipe(switchMap(hash => {
+            const header = `v1.${timestamp}.${hash}`;
+            const signedRequest = req.clone({
+                headers: req.headers.set('X-Signature', header),
+            });
+            return next(signedRequest);
+        }));
+    };
+}
+
+/**
+ * Debounce subscriptions to update mutations, with the possibility to cancel one, flush one, or flush all of them.
+ *
+ * `modelService` is also used to separate objects by their types. So User with ID 1 is not confused with Product with ID 1.
+ *
+ * `id` must be the ID of the object that will be updated.
+ */
+class NaturalDebounceService {
+    /**
+     * Stores the debounced update function
+     */
+    allDebouncedUpdateCache = new Map();
+    /**
+     * Debounce the `modelService.updateNow()` mutation for a short time. If called multiple times with the same
+     * modelService and id, it will postpone the subscription to the mutation.
+     *
+     * All input variables for the same object (same service and ID) will be cumulated over time. So it is possible
+     * to update `field1`, then `field2`, and they will be batched into a single XHR including `field1` and `field2`.
+     *
+     * But it will always keep the same debouncing timeline.
+     */
+    debounce(modelService, id, object) {
+        const debouncedUpdateCache = this.getMap(modelService);
+        let debounced = debouncedUpdateCache.get(id);
+        if (debounced) {
+            debounced.object = {
+                ...debounced.object,
+                ...object,
+            };
+        }
+        else {
+            const debouncer = new ReplaySubject(1);
+            let wasCancelled = false;
+            const canceller = new Subject();
+            canceller.subscribe(() => {
+                wasCancelled = true;
+                debouncer.complete();
+                canceller.complete();
+                this.delete(modelService, id);
+            });
+            const flusher = new Subject();
+            debounced = {
+                object,
+                debouncer,
+                canceller,
+                flusher,
+                modelService: modelService,
+                result: debouncer.pipe(debounceTime(2000), // Wait 2 seconds...
+                raceWith(flusher), // ...unless flusher is triggered
+                take(1), mergeMap(() => {
+                    this.delete(modelService, id);
+                    if (wasCancelled || !debounced) {
+                        return EMPTY;
+                    }
+                    return modelService.updateNow(debounced.object);
+                }), shareReplay()),
+            };
+            debouncedUpdateCache.set(id, debounced);
+        }
+        // Notify our debounced update each time we ask to update
+        debounced.debouncer.next();
+        // Return and observable that is updated when mutation is done
+        return debounced.result;
+    }
+    cancelOne(modelService, id) {
+        const debounced = this.allDebouncedUpdateCache.get(modelService)?.get(id);
+        debounced?.canceller.next();
+    }
+    /**
+     * Immediately execute the pending update, if any.
+     *
+     * It should typically be called before resolving the object, to mutate it before re-fetching it from server.
+     *
+     * The returned observable will complete when the update completes, even if it errors.
+     */
+    flushOne(modelService, id) {
+        const debounced = this.allDebouncedUpdateCache.get(modelService)?.get(id);
+        return this.internalFlush(debounced ? [debounced] : []);
+    }
+    /**
+     * Immediately execute all pending updates.
+     *
+     * It should typically be called before login out.
+     *
+     * The returned observable will complete when all updates complete, even if some of them error.
+     */
+    flush() {
+        const all = [];
+        this.allDebouncedUpdateCache.forEach(map => map.forEach(debounced => all.push(debounced)));
+        return this.internalFlush(all);
+    }
+    internalFlush(debounceds) {
+        const all = [];
+        const allFlusher = [];
+        debounceds.forEach(debounced => {
+            all.push(debounced.result.pipe(catchError(() => of(undefined))));
+            allFlusher.push(debounced.flusher);
+        });
+        if (!all.length) {
+            all.push(of(undefined));
+        }
+        return new Observable(subscriber => {
+            const subscription = forkJoin(all)
+                .pipe(map(() => undefined))
+                .subscribe(subscriber);
+            // Flush only after subscription process is finished
+            allFlusher.forEach(flusher => flusher.next());
+            return subscription;
+        });
+    }
+    /**
+     * Count of pending updates
+     */
+    get count() {
+        let count = 0;
+        this.allDebouncedUpdateCache.forEach(map => (count += map.size));
+        return count;
+    }
+    getMap(modelService) {
+        let debouncedUpdateCache = this.allDebouncedUpdateCache.get(modelService);
+        if (!debouncedUpdateCache) {
+            debouncedUpdateCache = new Map();
+            this.allDebouncedUpdateCache.set(modelService, debouncedUpdateCache);
+        }
+        return debouncedUpdateCache;
+    }
+    delete(modelService, id) {
+        const map = this.allDebouncedUpdateCache.get(modelService);
+        if (!map) {
+            return;
+        }
+        map.delete(id);
+        if (!map.size) {
+            this.allDebouncedUpdateCache.delete(modelService);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NaturalDebounceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NaturalDebounceService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NaturalDebounceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Lookup a facet by its `name` and then by its `field`, or return null if not found
+ */
+function getFacetFromSelection(facets, selection) {
+    if (!facets) {
+        return null;
+    }
+    return (facets.find(facet => facet.name != null && facet.name === selection.name) ||
+        facets.find(facet => facet.field === selection.field) ||
+        null);
+}
+/**
+ * Deep clone a literal via JSON serializing/unserializing
+ *
+ * It will **not** work with:
+ *
+ *     - functions (will be removed)
+ *     - `undefined` (will be removed)
+ *     - cyclic references (will crash)
+ *     - objects (will be converted to `{}`)
+ */
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+class NaturalAbstractModelService {
+    name;
+    oneQuery;
+    allQuery;
+    createMutation;
+    updateMutation;
+    deleteMutation;
+    createName;
+    updateName;
+    deleteName;
+    /**
+     * Store the creation mutations that are pending
+     */
+    creatingCache = new Map();
+    apollo = inject(Apollo);
+    naturalDebounceService = inject(NaturalDebounceService);
+    plural;
+    /**
+     *
+     * @param name service and single object query name (eg. userForFront or user).
+     * @param oneQuery GraphQL query to fetch a single object from ID (eg. userForCrudQuery).
+     * @param allQuery GraphQL query to fetch a filtered list of objects (eg. usersForCrudQuery).
+     * @param createMutation GraphQL mutation to create an object.
+     * @param updateMutation GraphQL mutation to update an object.
+     * @param deleteMutation GraphQL mutation to delete a list of objects.
+     * @param plural list query name (eg. usersForFront or users).
+     * @param createName create object mutation name (eg. createUser).
+     * @param updateName update object mutation name (eg. updateUser).
+     * @param deleteName delete object mutation name (eg. deleteUsers).
+     */
+    constructor(name, oneQuery, allQuery, createMutation, updateMutation, deleteMutation, plural = null, createName = null, updateName = null, deleteName = null) {
+        this.name = name;
+        this.oneQuery = oneQuery;
+        this.allQuery = allQuery;
+        this.createMutation = createMutation;
+        this.updateMutation = updateMutation;
+        this.deleteMutation = deleteMutation;
+        this.createName = createName;
+        this.updateName = updateName;
+        this.deleteName = deleteName;
+        this.plural = plural ?? makePlural(this.name);
+    }
+    /**
+     * List of individual fields validators
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getFormValidators(model) {
+        return {};
+    }
+    /**
+     * List of individual async fields validators
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getFormAsyncValidators(model) {
+        return {};
+    }
+    /**
+     * List of grouped fields validators (like password + confirm password)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getFormGroupValidators(model) {
+        return [];
+    }
+    /**
+     * List of async group fields validators (like unique constraint on multiple columns)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getFormGroupAsyncValidators(model) {
+        return [];
+    }
+    getFormConfig(model) {
+        const values = { ...this.getDefaultForServer(), ...this.getFormExtraFieldDefaultValues() };
+        const validators = this.getFormValidators(model);
+        const asyncValidators = this.getFormAsyncValidators(model);
+        const controls = {};
+        const disabled = model.permissions ? !model.permissions.update : false;
+        if (model.id) {
+            controls.id = new UntypedFormControl({ value: model.id, disabled: true });
+        }
+        // Configure form for each field of model
+        for (const key of Object.keys(values)) {
+            const value = model[key] !== undefined ? model[key] : values[key];
+            const formState = {
+                value: value,
+                disabled: disabled,
+            };
+            const validator = typeof validators[key] !== 'undefined' ? validators[key] : null;
+            const asyncValidator = typeof asyncValidators[key] !== 'undefined' ? asyncValidators[key] : null;
+            controls[key] = new UntypedFormControl(formState, validator, asyncValidator);
+        }
+        // Configure form for extra validators that are not on a specific field
+        for (const key of Object.keys(validators)) {
+            if (!controls[key]) {
+                const formState = {
+                    value: model[key] ? model[key] : null,
+                    disabled: disabled,
+                };
+                controls[key] = new UntypedFormControl(formState, validators[key]);
+            }
+        }
+        for (const key of Object.keys(asyncValidators)) {
+            if (controls[key] && asyncValidators[key]) {
+                controls[key].setAsyncValidators(asyncValidators[key]);
+            }
+            else {
+                const formState = {
+                    value: model[key] ? model[key] : null,
+                    disabled: disabled,
+                };
+                controls[key] = new UntypedFormControl(formState, null, asyncValidators[key]);
+            }
+        }
+        return controls;
+    }
+    /**
+     * Create the final FormGroup for the object, including all validators
+     *
+     * This method should **not** be overridden, but instead `getFormConfig`,
+     * `getFormGroupValidators`, `getFormGroupAsyncValidators` might be.
+     */
+    getFormGroup(model) {
+        const formConfig = this.getFormConfig(deepClone(model));
+        return new UntypedFormGroup(formConfig, {
+            validators: this.getFormGroupValidators(model),
+            asyncValidators: this.getFormGroupAsyncValidators(model),
+        });
+    }
+    /**
+     * Get a single object
+     *
+     * If available it will emit object from cache immediately, then it
+     * will **always** fetch from network and then the observable will be completed.
+     *
+     * You must subscribe to start getting results (and fetch from network).
+     */
+    getOne(id) {
+        return this.prepareOneQuery(id, 'cache-and-network').pipe(takeWhile(result => result.networkStatus !== NetworkStatus.ready, true), map$1(result => result.data[this.name]));
+    }
+    /**
+     * Watch a single object
+     *
+     * If available it will emit object from cache immediately, then it
+     * will **always** fetch from network, and then keep watching the cache forever.
+     *
+     * You must subscribe to start getting results (and fetch from network).
+     *
+     * You **MUST** unsubscribe.
+     */
+    watchOne(id, fetchPolicy = 'cache-and-network') {
+        return this.prepareOneQuery(id, fetchPolicy).pipe(map$1(result => result.data[this.name]));
+    }
+    prepareOneQuery(id, fetchPolicy) {
+        this.throwIfObservable(id);
+        this.throwIfNotQuery(this.oneQuery);
+        return this.getVariablesForOne(id).pipe(switchMap$1(variables => {
+            this.throwIfNotQuery(this.oneQuery);
+            return this.apollo.watchQuery({
+                query: this.oneQuery,
+                variables: variables,
+                fetchPolicy: fetchPolicy,
+                nextFetchPolicy: 'cache-only',
+            }).valueChanges;
+        }), filter(result => !!result.data));
+    }
+    /**
+     * Get a collection of objects
+     *
+     * It will **always** fetch from network and then the observable will be completed.
+     * No cache is ever used, so it's slow but correct.
+     */
+    getAll(queryVariablesManager) {
+        this.throwIfNotQuery(this.allQuery);
+        return this.getPartialVariablesForAll().pipe(first(), switchMap$1(partialVariables => {
+            this.throwIfNotQuery(this.allQuery);
+            // Copy manager to prevent to apply internal variables to external QueryVariablesManager
+            const manager = new NaturalQueryVariablesManager(queryVariablesManager);
+            manager.merge('partial-variables', partialVariables);
+            return this.apollo.query({
+                query: this.allQuery,
+                variables: manager.variables.value,
+                fetchPolicy: 'network-only',
+            });
+        }), this.mapAll());
+    }
+    /**
+     * Get a collection of objects
+     *
+     * Every time the observable variables change, and they are not undefined,
+     * it will return result from cache, then it will **always** fetch from network,
+     * and then keep watching the cache forever.
+     *
+     * You must subscribe to start getting results (and fetch from network).
+     *
+     * You **MUST** unsubscribe.
+     */
+    watchAll(queryVariablesManager, fetchPolicy = 'cache-and-network') {
+        this.throwIfNotQuery(this.allQuery);
+        return combineLatest({
+            variables: queryVariablesManager.variables.pipe(
+            // Ignore very fast variable changes
+            debounceTime$1(20), 
+            // Wait for variables to be defined to prevent duplicate query: with and without variables
+            // Null is accepted value for "no variables"
+            filter(variables => typeof variables !== 'undefined')),
+            partialVariables: this.getPartialVariablesForAll(),
+        }).pipe(switchMap$1(result => {
+            // Apply partial variables from service
+            // Copy manager to prevent to apply internal variables to external QueryVariablesManager
+            const manager = new NaturalQueryVariablesManager(queryVariablesManager);
+            manager.merge('partial-variables', result.partialVariables);
+            this.throwIfNotQuery(this.allQuery);
+            return this.apollo
+                .watchQuery({
+                query: this.allQuery,
+                variables: manager.variables.value,
+                fetchPolicy: fetchPolicy,
+            })
+                .valueChanges.pipe(catchError(() => EMPTY), filter(r => !!r.data), this.mapAll());
+        }));
+    }
+    /**
+     * This functions allow to quickly create or update objects.
+     *
+     * Manages a "creation is pending" status, and update when creation is ready.
+     * Uses regular update/updateNow and create methods.
+     * Used mainly when editing multiple objects in same controller (like in editable arrays)
+     */
+    createOrUpdate(object, now = false) {
+        this.throwIfObservable(object);
+        this.throwIfNotQuery(this.createMutation);
+        this.throwIfNotQuery(this.updateMutation);
+        // If creation is pending, listen to creation observable and when ready, fire update
+        const pendingCreation = this.creatingCache.get(object);
+        if (pendingCreation) {
+            return pendingCreation.pipe(switchMap$1(created => {
+                return this.update({
+                    id: created.id,
+                    ...object,
+                });
+            }));
+        }
+        // If object has Id, just save it
+        if ('id' in object && object.id) {
+            if (now) {
+                // used mainly for tests, because lodash debounced used in update() does not work fine with fakeAsync and tick()
+                return this.updateNow(object);
+            }
+            else {
+                return this.update(object);
+            }
+        }
+        // If object was not saving, and has no ID, create it
+        const creation = this.create(object).pipe(tap(() => {
+            this.creatingCache.delete(object); // remove from cache
+        }));
+        // stores creating observable in a cache replayable version of the observable,
+        // so several update() can subscribe to the same creation
+        this.creatingCache.set(object, creation.pipe(shareReplay$1()));
+        return creation;
+    }
+    /**
+     * Create an object in DB and then refetch the list of objects
+     */
+    create(object) {
+        this.throwIfObservable(object);
+        this.throwIfNotQuery(this.createMutation);
+        const variables = merge({}, { input: this.getInput(object, true) }, this.getPartialVariablesForCreation(object));
+        return this.apollo
+            .mutate({
+            mutation: this.createMutation,
+            variables: variables,
+        })
+            .pipe(map$1(result => {
+            this.apollo.client.reFetchObservableQueries();
+            return this.mapCreation(result);
+        }));
+    }
+    /**
+     * Update an object, after a short debounce
+     */
+    update(object) {
+        this.throwIfObservable(object);
+        this.throwIfNotQuery(this.updateMutation);
+        // Keep a single instance of the debounced update function
+        const id = object.id;
+        return this.naturalDebounceService.debounce(this, id, object);
+    }
+    /**
+     * Update an object immediately when subscribing
+     */
+    updateNow(object) {
+        this.throwIfObservable(object);
+        this.throwIfNotQuery(this.updateMutation);
+        const variables = merge({
+            id: object.id,
+            input: this.getInput(object, false),
+        }, this.getPartialVariablesForUpdate(object));
+        return this.apollo
+            .mutate({
+            mutation: this.updateMutation,
+            variables: variables,
+        })
+            .pipe(map$1(result => {
+            this.apollo.client.reFetchObservableQueries();
+            return this.mapUpdate(result);
+        }));
+    }
+    /**
+     * Delete objects and then refetch the list of objects
+     */
+    delete(objects) {
+        this.throwIfObservable(objects);
+        this.throwIfNotQuery(this.deleteMutation);
+        const ids = objects.map(o => {
+            // Cancel pending update
+            this.naturalDebounceService.cancelOne(this, o.id);
+            return o.id;
+        });
+        const variables = merge({
+            ids: ids,
+        }, this.getPartialVariablesForDelete(objects));
+        return this.apollo
+            .mutate({
+            mutation: this.deleteMutation,
+            variables: variables,
+        })
+            .pipe(
+        // Delay the observable until Apollo refetch is completed
+        switchMap$1(result => {
+            const mappedResult = this.mapDelete(result);
+            return from(this.apollo.client.reFetchObservableQueries()).pipe(map$1(() => mappedResult));
+        }));
+    }
+    /**
+     * If the id is provided, resolves an observable model. The observable model will only be emitted after we are sure
+     * that Apollo cache is fresh and warm. Then the component can subscribe to the observable model to get the model
+     * immediately from Apollo cache and any subsequents future mutations that may happen to Apollo cache.
+     *
+     * Without id, returns default values, in order to show a creation form.
+     */
+    resolve(id) {
+        if (id) {
+            const onlyNetwork = this.watchOne(id, 'network-only').pipe(first());
+            const onlyCache = this.watchOne(id, 'cache-first');
+            // In theory, we can rely on Apollo Cache to return a result instantly. It is very fast indeed,
+            // but it is still asynchronous, so there may be a very short time when we don't have the model
+            // available. To fix that, we can rely on RxJS, which is able to emit synchronously the value we just
+            // got from server. Once Apollo Client moves to RxJS (https://github.com/apollographql/apollo-feature-requests/issues/375),
+            // we could try to remove `startWith()`.
+            return onlyNetwork.pipe(map$1(firstValue => onlyCache.pipe(startWith(firstValue))));
+        }
+        else {
+            return of(of(this.getDefaultForServer()));
+        }
+    }
+    /**
+     * Return an object that match the GraphQL input type.
+     * It creates an object with manually filled data and add uncompleted data (like required attributes that can be empty strings)
+     */
+    getInput(object, forCreation) {
+        // Convert relations to their IDs for mutation
+        object = relationsToIds(object);
+        // Pick only attributes that we can find in the empty object
+        // In other words, prevent to select data that has unwanted attributes
+        const emptyObject = this.getDefaultForServer();
+        let input = pick(object, Object.keys(emptyObject));
+        // Complete a potentially uncompleted object with default values
+        if (forCreation) {
+            input = defaults(input, emptyObject);
+        }
+        return input;
+    }
+    /**
+     * Return the number of objects matching the query. It may never complete.
+     *
+     * This is used for the unique validator
+     */
+    count(queryVariablesManager) {
+        const queryName = 'Count' + upperCaseFirstLetter(this.plural);
+        const filterType = upperCaseFirstLetter(this.name) + 'Filter';
+        const query = gql `
+            query ${queryName} ($filter: ${filterType}) {
+            count: ${this.plural} (filter: $filter, pagination: {pageSize: 0, pageIndex: 0}) {
+            length
+            }
+            }`;
+        return this.getPartialVariablesForAll().pipe(switchMap$1(partialVariables => {
+            // Copy manager to prevent to apply internal variables to external QueryVariablesManager
+            const manager = new NaturalQueryVariablesManager(queryVariablesManager);
+            manager.merge('partial-variables', partialVariables);
+            return this.apollo.query({
+                query: query,
+                variables: manager.variables.value,
+                fetchPolicy: 'network-only',
+            });
+        }), map$1(result => result.data.count.length));
+    }
+    /**
+     * Return empty object with some default values from server perspective
+     *
+     * This is typically useful when showing a form for creation
+     */
+    getDefaultForServer() {
+        return {};
+    }
+    /**
+     * You probably **should not** use this.
+     *
+     * If you are trying to *call* this method, instead you probably want to call `getDefaultForServer()` to get default
+     * values for a model, or `getFormConfig()` to get a configured form that includes extra form fields.
+     *
+     * If you are trying to *override* this method, instead you probably want to override `getDefaultForServer()`.
+     *
+     * The only and **very rare** reason to override this method is if the client needs extra form fields that cannot be
+     * accepted by the server (not part of `XXXInput` type) and that are strictly for the client form needs. In that case,
+     * then you can return default values for those extra form fields, and the form returned by `getFormConfig()` will
+     * include those extra fields.
+     */
+    getFormExtraFieldDefaultValues() {
+        return {};
+    }
+    /**
+     * This is used to extract only the array of fetched objects out of the entire fetched data
+     */
+    mapAll() {
+        return map$1(result => result.data[this.plural]); // See https://github.com/apollographql/apollo-client/issues/5662
+    }
+    /**
+     * This is used to extract only the created object out of the entire fetched data
+     */
+    mapCreation(result) {
+        const name = this.createName ?? 'create' + upperCaseFirstLetter(this.name);
+        return result.data[name]; // See https://github.com/apollographql/apollo-client/issues/5662
+    }
+    /**
+     * This is used to extract only the updated object out of the entire fetched data
+     */
+    mapUpdate(result) {
+        const name = this.updateName ?? 'update' + upperCaseFirstLetter(this.name);
+        return result.data[name]; // See https://github.com/apollographql/apollo-client/issues/5662
+    }
+    /**
+     * This is used to extract only flag when deleting an object
+     */
+    mapDelete(result) {
+        const name = this.deleteName ?? 'delete' + upperCaseFirstLetter(this.plural);
+        return result.data[name]; // See https://github.com/apollographql/apollo-client/issues/5662
+    }
+    /**
+     * Returns additional variables to be used when getting a single object
+     *
+     * This is typically a site or state ID, and is needed to get appropriate access rights
+     */
+    getPartialVariablesForOne() {
+        return of({});
+    }
+    /**
+     * Returns additional variables to be used when getting multiple objects
+     *
+     * This is typically a site or state ID, but it could be something else to further filter the query
+     */
+    getPartialVariablesForAll() {
+        return of({});
+    }
+    /**
+     * Returns additional variables to be used when creating an object
+     *
+     * This is typically a site or state ID
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getPartialVariablesForCreation(object) {
+        return {};
+    }
+    /**
+     * Returns additional variables to be used when updating an object
+     *
+     * This is typically a site or state ID
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getPartialVariablesForUpdate(object) {
+        return {};
+    }
+    /**
+     * Return additional variables to be used when deleting an object
+     *
+     * This is typically a site or state ID
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getPartialVariablesForDelete(objects) {
+        return {};
+    }
+    /**
+     * Throw exception to prevent executing queries with invalid variables
+     */
+    throwIfObservable(value) {
+        if (value instanceof Observable) {
+            throw new Error('Cannot use Observable as variables. Instead you should use .subscribe() to call the method with a real value');
+        }
+    }
+    /**
+     * Merge given ID with additional partial variables if there is any
+     */
+    getVariablesForOne(id) {
+        return this.getPartialVariablesForOne().pipe(map$1(partialVariables => merge({}, { id: id }, partialVariables)));
+    }
+    /**
+     * Throw exception to prevent executing null queries
+     */
+    throwIfNotQuery(query) {
+        if (!query) {
+            throw new Error('GraphQL query for this method was not configured in this service constructor');
+        }
+    }
+}
+
+/**
+ * **DO NOT MODIFY UNLESS STRICTLY REQUIRED FOR VANILLA**
+ *
+ * This is a minimal service specialized for Vanilla and any modification,
+ * including adding `import` in this file, might break https://navigations.ichtus.club.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NaturalAbstractModelService, NaturalQueryVariablesManager, formatIsoDateTime, graphqlQuerySigner };
+//# sourceMappingURL=ecodev-natural-vanilla.mjs.map