ngrx-entity-crud 12.0.6-beta.2

package/fesm2015/ngrx-entity-crud.js

@@ -0,0 +1,1367 @@
+import { createEntityAdapter } from '@ngrx/entity';
+import { createSelector, createAction, props, on, createReducer } from '@ngrx/store';
+import { filter, switchMap, map, catchError, repeat, concatMap, mergeMap } from 'rxjs/operators';
+import * as i0 from '@angular/core';
+import { isDevMode, Injectable } from '@angular/core';
+import { ofType } from '@ngrx/effects';
+import { from, of } from 'rxjs';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpClient } from '@angular/common/http';
+
+var CrudEnum;
+(function (CrudEnum) {
+    CrudEnum["SEARCH"] = "Search";
+    CrudEnum["DELETE"] = "Delete";
+    CrudEnum["CREATE"] = "Create";
+    CrudEnum["EDIT"] = "Edit";
+    CrudEnum["SELECT"] = "Select";
+    CrudEnum["RESET"] = "Reset";
+})(CrudEnum || (CrudEnum = {}));
+var ActionEnum;
+(function (ActionEnum) {
+    ActionEnum["RESPONSE"] = "Response";
+    ActionEnum["REQUEST"] = "Request";
+    ActionEnum["FAILURE"] = "Failure";
+    ActionEnum["SUCCESS"] = "Success";
+})(ActionEnum || (ActionEnum = {}));
+
+function getInitialEntityCrudState() {
+    return {
+        ids: [],
+        entities: {},
+        isLoading: false,
+        isLoaded: false,
+        error: null,
+        filters: {},
+        lastCriteria: null,
+        entitiesSelected: {},
+        idsSelected: [],
+        itemSelected: null,
+        idSelected: null,
+        responses: []
+    };
+}
+function createInitialCrudStateFactory() {
+    function getInitialCrudState(additionalState = {}) {
+        return Object.assign(getInitialEntityCrudState(), additionalState);
+    }
+    return { getInitialCrudState };
+}
+
+const isEmpty = (obj) => {
+    return obj === null || undefined
+        ? true
+        : (() => {
+            for (const prop in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+                    return false;
+                }
+            }
+            return true;
+        })();
+};
+function jNgrxFilter(items, filters) {
+    return new JNgrxFilter().jNgrxFilter(items, filters);
+}
+class JNgrxFilter {
+    constructor() {
+        this.filterConstraints = {
+            startsWith(value, filter) {
+                if (filter === undefined || filter === null || filter.trim() === '') {
+                    return true;
+                }
+                if (value === undefined || value === null) {
+                    return false;
+                }
+                const filterValue = filter.toLowerCase();
+                return value.toString().toLowerCase().slice(0, filterValue.length) === filterValue;
+            },
+            contains(value, filter) {
+                if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
+                    return true;
+                }
+                if (value === undefined || value === null) {
+                    return false;
+                }
+                return value.toString().toLowerCase().indexOf(filter.toLowerCase()) !== -1;
+            },
+            endsWith(value, filter) {
+                if (filter === undefined || filter === null || filter.trim() === '') {
+                    return true;
+                }
+                if (value === undefined || value === null) {
+                    return false;
+                }
+                const filterValue = filter.toString().toLowerCase();
+                return value.toString().toLowerCase().indexOf(filterValue, value.toString().length - filterValue.length) !== -1;
+            },
+            equals(value, filter) {
+                if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
+                    return true;
+                }
+                if (value === undefined || value === null) {
+                    return false;
+                }
+                return value.toString().toLowerCase() === filter.toString().toLowerCase();
+            },
+            notEquals(value, filter) {
+                if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
+                    return false;
+                }
+                if (value === undefined || value === null) {
+                    return true;
+                }
+                return value.toString().toLowerCase() !== filter.toString().toLowerCase();
+            },
+            in(value, filters) {
+                if (filters === undefined || filters === null || filters.length === 0) {
+                    return true;
+                }
+                if (value === undefined || value === null) {
+                    return false;
+                }
+                filters.forEach(filter => {
+                    if (filter === value) {
+                        return true;
+                    }
+                });
+                return false;
+            }
+        };
+        this.isFunction = (obj) => !!(obj && obj.constructor && obj.call && obj.apply);
+    }
+    jNgrxFilter(items, filters) {
+        if (isEmpty(filters)) {
+            return items;
+        }
+        const filteredValue = [];
+        items.forEach((item) => {
+            let localMatch = false;
+            // tslint:disable-next-line:forin
+            for (const filterField in filters) {
+                const filterValue = filters[filterField].value;
+                const filterMatchMode = filters[filterField].matchMode || 'startsWith';
+                const filterConstraint = this.filterConstraints[filterMatchMode];
+                const renderFunction = filters[filterField].renderFunction;
+                const dataFieldValue = this.isFunction(renderFunction) ? renderFunction(this.resolveFieldData(item, filterField)) : this.resolveFieldData(item, filterField);
+                if (filterConstraint(dataFieldValue, filterValue)) {
+                    localMatch = true;
+                    break;
+                }
+            }
+            if (localMatch) {
+                filteredValue.push(item);
+            }
+        });
+        return filteredValue;
+    }
+    resolveFieldData(data, field) {
+        if (data && field) {
+            if (this.isFunction(field)) {
+                return field(data);
+            }
+            else if (field.indexOf('.') === -1) {
+                return data[field];
+            }
+            else {
+                const fields = field.split('.');
+                let value = data;
+                for (let i = 0, len = fields.length; i < len; ++i) {
+                    if (value == null) {
+                        return null;
+                    }
+                    value = value[fields[i]];
+                }
+                return value;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+}
+
+function createCrudSelectorsFactory(adapter) {
+    function getCrudSelectors(selectState) {
+        const getError = (state) => state.error;
+        const getIsLoading = (state) => state.isLoading;
+        const getIsLoaded = (state) => state.isLoaded;
+        const getFilters = (state) => state.filters;
+        const getLastCriteria = (state) => state.lastCriteria;
+        const getItemSelected = (state) => state.itemSelected;
+        const getIdSelected = (state) => state.idSelected;
+        // const getItemsSelected = (state: CrudState<T>): T[] => state.itemsSelected;
+        const getEntitiesSelected = (state) => state.entitiesSelected;
+        const getIdsSelected = (state) => state.idsSelected;
+        const getRespones = (state) => state.responses;
+        const selectError = createSelector(selectState, getError);
+        const selectIsLoading = createSelector(selectState, getIsLoading);
+        const selectIsLoaded = createSelector(selectState, getIsLoaded);
+        const selectFilters = createSelector(selectState, getFilters);
+        const selectLastCriteria = createSelector(selectState, getLastCriteria);
+        const selectItemSelected = createSelector(selectState, getItemSelected);
+        const selectEntitiesSelected = createSelector(selectState, getEntitiesSelected);
+        const selectItemsSelected = createSelector(selectEntitiesSelected, (entities) => Object.values(entities));
+        const selectIdSelected = createSelector(selectState, getIdSelected);
+        const selectIdsSelected = createSelector(selectState, getIdsSelected);
+        const selectResponses = createSelector(selectState, getRespones);
+        const { selectAll, selectEntities, selectIds, selectTotal } = adapter.getSelectors(selectState);
+        const selectItemsSelectedOrigin = createSelector(selectIdsSelected, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
+        const selectItemSelectedOrigin = createSelector(selectIdSelected, selectEntities, (id, entities) => entities[id]);
+        const selectFilteredItems = createSelector([selectAll, selectFilters], (allTasks, filters) => {
+            return jNgrxFilter(allTasks, filters);
+        });
+        return {
+            selectError,
+            selectIsLoading,
+            selectIsLoaded,
+            selectFilters,
+            selectFilteredItems,
+            selectAll,
+            selectEntities,
+            selectIds,
+            selectTotal,
+            selectLastCriteria,
+            selectIdSelected,
+            selectItemSelected,
+            selectItemSelectedOrigin,
+            selectIdsSelected,
+            selectItemsSelected,
+            selectEntitiesSelected,
+            selectItemsSelectedOrigin,
+            selectResponses,
+        };
+    }
+    return { getCrudSelectors };
+}
+
+function createCrudActionsFactory() {
+    function createCrudActions(name) {
+        // tslint:disable:variable-name
+        /**
+         * mode:
+         *  comportamento predefinito, il dato attualmente presente viene cancellato e ripopolato al result della chiamata
+         *  REFRESH => il dato viene sostituito al result della chiamata.
+         */
+        const Response = createAction(`[${name}] ${ActionEnum.RESPONSE}`, props());
+        const ResetResponses = createAction(`[${name}] ${CrudEnum.RESET} ${ActionEnum.RESPONSE}`);
+        const SearchRequest = createAction(`[${name}] ${CrudEnum.SEARCH} ${ActionEnum.REQUEST}`, props());
+        const SearchFailure = createAction(`[${name}] ${CrudEnum.SEARCH} ${ActionEnum.FAILURE}`, props());
+        const SearchSuccess = createAction(`[${name}] ${CrudEnum.SEARCH} ${ActionEnum.SUCCESS}`, props());
+        const DeleteRequest = createAction(`[${name}] ${CrudEnum.DELETE} ${ActionEnum.REQUEST}`, props());
+        const DeleteFailure = createAction(`[${name}] ${CrudEnum.DELETE} ${ActionEnum.FAILURE}`, props());
+        const DeleteSuccess = createAction(`[${name}] ${CrudEnum.DELETE} ${ActionEnum.SUCCESS}`, props());
+        const DeleteManyRequest = createAction(`[${name}] ${CrudEnum.DELETE} many ${ActionEnum.REQUEST}`, props());
+        const DeleteManyFailure = createAction(`[${name}] ${CrudEnum.DELETE} many ${ActionEnum.FAILURE}`, props());
+        const DeleteManySuccess = createAction(`[${name}] ${CrudEnum.DELETE} many ${ActionEnum.SUCCESS}`, props());
+        const CreateRequest = createAction(`[${name}] ${CrudEnum.CREATE} ${ActionEnum.REQUEST}`, props());
+        const CreateFailure = createAction(`[${name}] ${CrudEnum.CREATE} ${ActionEnum.FAILURE}`, props());
+        const CreateSuccess = createAction(`[${name}] ${CrudEnum.CREATE} ${ActionEnum.SUCCESS}`, props());
+        const CreateManyRequest = createAction(`[${name}] ${CrudEnum.CREATE} many ${ActionEnum.REQUEST}`, props());
+        const CreateManyFailure = createAction(`[${name}] ${CrudEnum.CREATE} many ${ActionEnum.FAILURE}`, props());
+        const CreateManySuccess = createAction(`[${name}] ${CrudEnum.CREATE} many ${ActionEnum.SUCCESS}`, props());
+        const SelectRequest = createAction(`[${name}] ${CrudEnum.SELECT} ${ActionEnum.REQUEST}`, props());
+        const SelectFailure = createAction(`[${name}] ${CrudEnum.SELECT} ${ActionEnum.FAILURE}`, props());
+        const SelectSuccess = createAction(`[${name}] ${CrudEnum.SELECT} ${ActionEnum.SUCCESS}`, props());
+        const EditRequest = createAction(`[${name}] ${CrudEnum.EDIT} ${ActionEnum.REQUEST}`, props());
+        const EditFailure = createAction(`[${name}] ${CrudEnum.EDIT} ${ActionEnum.FAILURE}`, props());
+        const EditSuccess = createAction(`[${name}] ${CrudEnum.EDIT} ${ActionEnum.SUCCESS}`, props());
+        const EditManyRequest = createAction(`[${name}] ${CrudEnum.EDIT} many ${ActionEnum.REQUEST}`, props());
+        const EditManyFailure = createAction(`[${name}] ${CrudEnum.EDIT} many ${ActionEnum.FAILURE}`, props());
+        const EditManySuccess = createAction(`[${name}] ${CrudEnum.EDIT} many ${ActionEnum.SUCCESS}`, props());
+        const Reset = createAction(`[${name}] ${CrudEnum.RESET}`);
+        const Filters = createAction(`[${name}] Filters`, props());
+        const SelectItems = createAction(`[${name}] SelectItems`, props());
+        const AddManySelected = createAction(`[${name}] AddManySelected`, props());
+        const RemoveManySelected = createAction(`[${name}] RemoveManySelected`, props());
+        const RemoveAllSelected = createAction(`[${name}] RemoveAllSelected`);
+        const SelectItem = createAction(`[${name}] SelectItem`, props());
+        const Edit = createAction(`[${name}] ${CrudEnum.EDIT} `, props());
+        const Create = createAction(`[${name}] ${CrudEnum.CREATE}`, props());
+        const Delete = createAction(`[${name}] ${CrudEnum.DELETE} `, props());
+        return {
+            Response,
+            ResetResponses,
+            SearchRequest,
+            SearchFailure,
+            SearchSuccess,
+            DeleteRequest,
+            DeleteFailure,
+            DeleteSuccess,
+            DeleteManyRequest,
+            DeleteManyFailure,
+            DeleteManySuccess,
+            CreateRequest,
+            CreateFailure,
+            CreateSuccess,
+            CreateManyRequest,
+            CreateManyFailure,
+            CreateManySuccess,
+            SelectRequest,
+            SelectFailure,
+            SelectSuccess,
+            EditRequest,
+            EditFailure,
+            EditSuccess,
+            EditManyRequest,
+            EditManyFailure,
+            EditManySuccess,
+            Reset,
+            Filters,
+            SelectItems,
+            RemoveManySelected,
+            AddManySelected,
+            RemoveAllSelected,
+            SelectItem,
+            Edit,
+            Create,
+            Delete,
+        };
+    }
+    return { createCrudActions };
+}
+
+const ofFailure = () => {
+    return input$ => input$.pipe(filter(value => value.type.endsWith(ActionEnum.FAILURE)));
+};
+function selectIdValue(entity, selectId) {
+    const key = selectId(entity);
+    if (isDevMode() && key === undefined) {
+        console.warn('@ngrx/entity: The entity passed to the `selectId` implementation returned undefined.', 'You should probably provide your own `selectId` implementation.', 'The entity that was passed:', entity, 'The `selectId` implementation:', selectId.toString());
+    }
+    return key;
+}
+const toDictionary = (items, adapter) => items.reduce((prev, curr) => {
+    const key = selectIdValue(curr, adapter.selectId);
+    prev[key] = curr;
+    return prev;
+}, {});
+
+function evalData(fn, def = null) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        return def;
+    }
+}
+function createCrudOns(adapter, initialState, actions) {
+    const searchRequestOn = on(actions.SearchRequest, (state, criteria) => {
+        if (!criteria.path && !criteria.mode && !criteria.queryParams) {
+            throw new Error('It is not possible a search without payload, use :\'{criteria:{}}\'');
+        }
+        const { itemSelected, idSelected, entitiesSelected, idsSelected } = initialState;
+        if (criteria.mode === 'REFRESH' || criteria.mode === 'upsertMany') {
+            return Object.assign({}, state, {
+                isLoading: true,
+                error: initialState.error,
+                lastCriteria: criteria,
+                itemSelected,
+                idSelected,
+                entitiesSelected,
+                idsSelected
+            });
+        }
+        return adapter.removeAll(Object.assign({}, state, {
+            isLoading: true,
+            error: initialState.error,
+            lastCriteria: criteria,
+            itemSelected,
+            idSelected,
+            entitiesSelected,
+            idsSelected
+        }));
+    });
+    const deleteRequestOn = on(actions.DeleteRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const deleteManyRequestOn = on(actions.DeleteManyRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const editRequestOn = on(actions.EditRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const editManyRequestOn = on(actions.EditManyRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const createRequestOn = on(actions.CreateRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const createManyRequestOn = on(actions.CreateManyRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const selectRequestOn = on(actions.SelectRequest, (state, request) => {
+        return Object.assign({}, state, { isLoading: true, error: initialState.error });
+    });
+    const searchSuccessOn = on(actions.SearchSuccess, (state, { type, items, request }) => {
+        const mode = evalData(() => request.mode, null) || 'setAll';
+        let method;
+        switch (mode) {
+            case 'REFRESH': {
+                // console.log('REFRESH');
+                method = adapter.setAll;
+                break;
+            }
+            case 'upsertMany': {
+                // console.log('upsertMany');
+                method = adapter.upsertMany;
+                break;
+            }
+            case 'setAll': {
+                // console.log('setAll');
+                method = adapter.setAll;
+                break;
+            }
+            default: {
+                // console.log('default');
+                method = adapter.setAll;
+                break;
+            }
+        }
+        return method(items, Object.assign({}, state, {
+            isLoaded: true,
+            isLoading: false,
+            error: null
+        }));
+    });
+    const deleteSuccessOn = on(actions.DeleteSuccess, (state, { type, id }) => {
+        // tolgo dallo store.idsSelected l'elemento cancellato
+        const idsSelected = state.idsSelected.filter((idA) => idA === id);
+        const entitiesSelected = idsSelected.reduce((prev, curr) => {
+            prev[curr] = state.entitiesSelected[curr];
+            return prev;
+        }, {});
+        // se ho cancellato l'id seezionato, lo tolgo dallo store.
+        const idSelected = !!state.idSelected && state.idSelected === id ? null : state.idSelected;
+        const itemSelected = !idSelected ? null : state.itemSelected;
+        return adapter.removeOne(id, Object.assign({}, state, {
+            isLoaded: true,
+            isLoading: false,
+            error: null,
+            idSelected,
+            idsSelected,
+            itemSelected,
+            entitiesSelected
+        }));
+    });
+    const deleteManySuccessOn = on(actions.DeleteManySuccess, (state, { type, ids }) => {
+        // tolgo dallo store.idsSelected gli elementi che sono stati cancellati.
+        const idsSelected = state.idsSelected.filter((id) => !(id in ids));
+        const entitiesSelected = idsSelected.reduce((prev, curr) => {
+            prev[curr] = state.entitiesSelected[curr];
+            return prev;
+        }, {});
+        // se ho cancellato l'id seezionato, lo tolgo dallo store.
+        const idSelected = !!state.idSelected && state.idSelected in ids ? null : state.idSelected;
+        const itemSelected = !idSelected ? null : state.itemSelected;
+        return adapter.removeMany(ids, Object.assign({}, state, {
+            isLoaded: true,
+            isLoading: false,
+            error: null,
+            idSelected,
+            idsSelected,
+            itemSelected,
+            entitiesSelected
+        }));
+    });
+    const deleteOn = on(actions.Delete, (state, { type, id }) => {
+        // tolgo dallo store.idsSelected l'elemento cancellato
+        const idsSelected = state.idsSelected.filter((idA) => idA === id);
+        // se ho cancellato l'id seezionato, lo tolgo dallo store.
+        const idSelected = !!state.idSelected && state.idSelected === id ? null : state.idSelected;
+        return adapter.removeOne(id, Object.assign({}, state, {
+            isLoaded: true,
+            isLoading: false,
+            error: null,
+            idSelected,
+            idsSelected
+        }));
+    });
+    const responseOn = on(actions.Response, (state, response) => {
+        const responses = [...state.responses, response];
+        return Object.assign(Object.assign({}, state), { responses });
+    });
+    const resetResponsesOn = on(actions.ResetResponses, (state) => {
+        const responses = [];
+        return Object.assign(Object.assign({}, state), { responses });
+    });
+    const createSuccessOn = on(actions.CreateSuccess, (state, { type, item }) => adapter.addOne(item, Object.assign({}, state, {
+        isLoaded: true,
+        isLoading: false,
+        error: null
+    })));
+    const createManySuccessOn = on(actions.CreateManySuccess, (state, { type, items }) => adapter.addMany(items, Object.assign({}, state, {
+        isLoaded: true,
+        isLoading: false,
+        error: null
+    })));
+    const createOn = on(actions.Create, (state, { type, item }) => adapter.addOne(item, Object.assign({}, state, {
+        isLoaded: true,
+        isLoading: false,
+        error: null
+    })));
+    const editSuccessOn = on(actions.EditSuccess, (state, { item, type }) => adapter.upsertOne(item, Object.assign({}, state, {
+        isLoaded: true,
+        isLoading: false,
+        error: null
+    })));
+    const editManySuccessOn = on(actions.EditManySuccess, (state, { items, type }) => adapter.upsertMany(items, Object.assign({}, state, {
+        isLoaded: true,
+        isLoading: false,
+        error: null
+    })));
+    const editOn = on(actions.Edit, (state, { item, type }) => adapter.upsertOne(item, Object.assign({}, state, {
+        isLoaded: true,
+        isLoading: false,
+        error: null
+    })));
+    const filtersOn = on(actions.Filters, (state, { type, filters }) => Object.assign({}, state, { filters }));
+    const removeAllSelectedOn = on(actions.RemoveAllSelected, (state, { type }) => {
+        const result = Object.assign(Object.assign({}, state), { idsSelected: [], 
+            // itemsSelected: [], //todo: @deprecated da cancellare questo tipo di assegnazione.
+            entitiesSelected: {} });
+        return result;
+    });
+    const addManySelectedOn = on(actions.AddManySelected, (state, { type, items }) => {
+        const entitiesCurr = toDictionary(items, adapter);
+        const entitiesSelected = Object.assign(Object.assign({}, state.entitiesSelected), entitiesCurr);
+        const idsSelected = Object.keys(entitiesSelected);
+        const result = Object.assign(Object.assign({}, state), { idsSelected,
+            // itemsSelected: items, //todo: @deprecated da cancellare questo tipo di assegnazione.
+            entitiesSelected });
+        return result;
+    });
+    const removeManySelectedOn = on(actions.RemoveManySelected, (state, { type, ids }) => {
+        const idsAsString = ids.map(x => x + '');
+        const idsSelected = Object.keys(state.entitiesSelected).filter(id => !idsAsString.includes(id + ''));
+        const entitiesSelected = idsSelected.reduce((prec, curr) => (Object.assign(Object.assign({}, prec), { [curr]: state.entitiesSelected[curr] })), {});
+        // const itemsSelected = Object.values(entitiesSelected);
+        const result = Object.assign(Object.assign({}, state), { idsSelected,
+            // itemsSelected, //todo: @deprecated da cancellare questo tipo di assegnazione.
+            entitiesSelected });
+        return result;
+    });
+    const selectItemsOn = on(actions.SelectItems, (state, { type, items }) => {
+        const entitiesSelected = toDictionary(items, adapter);
+        const idsSelected = Object.keys(entitiesSelected);
+        const result = Object.assign(Object.assign({}, state), { idsSelected,
+            // itemsSelected: items,
+            entitiesSelected });
+        return result;
+    });
+    const selectItemOn = on(actions.SelectItem, (state, { type, item }) => {
+        const idSelected = selectIdValue(item, adapter.selectId);
+        const result = Object.assign(Object.assign({}, state), { idSelected, itemSelected: item });
+        return result;
+    });
+    const selectSuccessOn = on(actions.SelectSuccess, (state, { type, item }) => {
+        const idSelected = selectIdValue(item, adapter.selectId);
+        const result = Object.assign(Object.assign({}, state), { idSelected, itemSelected: item, isLoaded: true, isLoading: false, error: null });
+        return result;
+    });
+    const searchFailureOn = on(actions.SearchFailure, (state, { type, error }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const deleteFailureOn = on(actions.DeleteFailure, (state, { type, error }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const deleteManyFailureOn = on(actions.DeleteManyFailure, (state, { type, error }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const createFailureOn = on(actions.CreateFailure, (state, { type, error }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const createManyFailureOn = on(actions.CreateManyFailure, (state, { type, error }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const editFailureOn = on(actions.EditFailure, (state, { error, type }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const editManyFailureOn = on(actions.EditManyFailure, (state, { error, type }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const selectFailureOn = on(actions.SelectFailure, (state, { error, type }) => Object.assign({}, state, {
+        isLoaded: false,
+        isLoading: false,
+        error
+    }));
+    const resetOn = on(actions.Reset, (state) => (Object.assign(Object.assign({}, state), initialState)));
+    return {
+        responseOn,
+        resetResponsesOn,
+        searchRequestOn,
+        deleteRequestOn,
+        deleteManyRequestOn,
+        editRequestOn,
+        editManyRequestOn,
+        createRequestOn,
+        createManyRequestOn,
+        selectRequestOn,
+        searchSuccessOn,
+        deleteSuccessOn,
+        deleteManySuccessOn,
+        createSuccessOn,
+        createManySuccessOn,
+        selectSuccessOn,
+        editSuccessOn,
+        editManySuccessOn,
+        searchFailureOn,
+        deleteFailureOn,
+        deleteManyFailureOn,
+        createFailureOn,
+        createManyFailureOn,
+        selectFailureOn,
+        editFailureOn,
+        editManyFailureOn,
+        resetOn,
+        filtersOn,
+        selectItemsOn,
+        removeAllSelectedOn,
+        addManySelectedOn,
+        removeManySelectedOn,
+        selectItemOn,
+        editOn,
+        createOn,
+        deleteOn
+    };
+}
+function createCrudReducerFactory(adapter) {
+    function createCrudReducer(initialState, actions, ...ons) {
+        const { responseOn, resetResponsesOn, searchRequestOn, deleteRequestOn, deleteManyRequestOn, editRequestOn, editManyRequestOn, createRequestOn, createManyRequestOn, selectRequestOn, searchSuccessOn, deleteSuccessOn, deleteManySuccessOn, createSuccessOn, createManySuccessOn, selectSuccessOn, editSuccessOn, editManySuccessOn, searchFailureOn, deleteFailureOn, deleteManyFailureOn, createFailureOn, createManyFailureOn, selectFailureOn, editFailureOn, editManyFailureOn, resetOn, filtersOn, selectItemsOn, removeAllSelectedOn, addManySelectedOn, removeManySelectedOn, selectItemOn, editOn, createOn, deleteOn } = createCrudOns(adapter, initialState, actions);
+        const totalOns = [
+            ...ons,
+            responseOn,
+            resetResponsesOn,
+            searchRequestOn,
+            deleteRequestOn,
+            deleteManyRequestOn,
+            editRequestOn,
+            editManyRequestOn,
+            createRequestOn,
+            createManyRequestOn,
+            selectRequestOn,
+            searchSuccessOn,
+            deleteSuccessOn,
+            deleteManySuccessOn,
+            createSuccessOn,
+            createManySuccessOn,
+            selectSuccessOn,
+            editSuccessOn,
+            editManySuccessOn,
+            searchFailureOn,
+            deleteFailureOn,
+            deleteManyFailureOn,
+            createFailureOn,
+            createManyFailureOn,
+            selectFailureOn,
+            editFailureOn,
+            editManyFailureOn,
+            resetOn,
+            filtersOn,
+            selectItemsOn,
+            removeAllSelectedOn,
+            addManySelectedOn,
+            removeManySelectedOn,
+            selectItemOn,
+            editOn,
+            createOn,
+            deleteOn
+        ];
+        return createReducer(initialState, ...totalOns);
+    }
+    return {
+        createCrudReducer
+    };
+}
+
+function createCrudEntityAdapter(options) {
+    const adapter = createEntityAdapter(options);
+    const stateFactory = createInitialCrudStateFactory();
+    const selectorsFactory = createCrudSelectorsFactory(adapter);
+    const actionsFactory = createCrudActionsFactory();
+    const reducerFactory = createCrudReducerFactory(adapter);
+    return Object.assign({}, adapter, stateFactory, selectorsFactory, actionsFactory, reducerFactory);
+}
+
+const searchCall = (service) => {
+    return input$ => input$.pipe(switchMap(payload => service.search(payload).pipe(map((response) => ({ response, payload })))));
+};
+const searchResponse = (actions, optEffect) => {
+    return input$ => input$.pipe(switchMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.SearchFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            result.push(actions.SearchSuccess({ items: response.data, request: payload }));
+            result.push(actions.Filters({ filters: {} }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const searchCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.SearchFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const searchRequest = (actions, service, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.SearchRequest), searchCall(service), searchResponse(actions, optEffect), searchCatchError(actions), repeat());
+};
+/**
+ * @deprecated use:
+ *
+ * actions$.pipe(
+ *   searchRequest(actions, service, clazz, optEffect)
+ * );
+ *
+ * or:
+ *
+ * actions$.pipe(
+ *  ofType(actions.SearchRequest),
+ *  searchCall(service),
+ *  searchResponse(actions, optEffect),
+ *  searchCatchError(actions),
+ *  repeat()
+ *  );
+ *
+ */
+const searchRequestEffect = (actions$, actions, service, optEffect) => actions$.pipe(searchRequest(actions, service, optEffect));
+const deleteCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.delete(payload).pipe(map((response) => ({ response, payload })))));
+};
+const deleteResponse = (actions, clazz, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.DeleteFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            if (!clazz.selectId) {
+                throw Error('the selectId method is not present in the managed entity.');
+            }
+            const id = clazz.selectId(payload.mutationParams);
+            result.push(actions.DeleteSuccess({ id }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const deleteCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.EditFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const deleteRequest = (actions, service, clazz, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.DeleteRequest), deleteCall(service), deleteResponse(actions, clazz, optEffect), deleteCatchError(actions), repeat());
+};
+/**
+ * @deprecated use:
+ *
+ * actions$.pipe(
+ *   deleteRequest(actions, service, clazz, optEffect)
+ * );
+ *
+ * or:
+ *
+ * actions$.pipe(
+ *  ofType(actions.DeleteRequest),
+ *  deleteCall(service),
+ *  deleteResponse(actions, clazz, optEffect),
+ *  deleteCatchError(actions),
+ *  repeat()
+ *  );
+ *
+ */
+const deleteRequestEffect = (actions$, actions, service, clazz, optEffect) => actions$.pipe(deleteRequest(actions, service, clazz, optEffect));
+const deleteManyCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.deleteMany((payload)).pipe(map((response) => ({ response, payload })))));
+};
+const deleteManyResponse = (actions, clazz, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.DeleteManyFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            if (!clazz.selectId) {
+                throw Error('the selectId method is not present in the managed entity.');
+            }
+            const ids = payload.mutationParams.map(id => clazz.selectId(id));
+            result.push(actions.DeleteManySuccess({ ids }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const deleteManyCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.DeleteManyFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const deleteManyRequest = (actions, service, clazz, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.DeleteManyRequest), deleteManyCall(service), deleteManyResponse(actions, clazz, optEffect), deleteManyCatchError(actions), repeat());
+};
+const createCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.create(payload).pipe(map((response) => ({ response, payload })))));
+};
+const createResponse = (actions, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.CreateFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            const item = response.data;
+            result.push(actions.CreateSuccess({ item }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const createCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.CreateFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const createRequest = (actions, service, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.CreateRequest), createCall(service), createResponse(actions, optEffect), createCatchError(actions), repeat());
+};
+/**
+ * @deprecated use:
+ *
+ * actions$.pipe(
+ *   createRequest(actions, service, optEffect)
+ * );
+ *
+ * or:
+ *
+ * actions$.pipe(
+ *  ofType(actions.DeleteRequest),
+ *  createCall(service),
+ *  createResponse(actions, optEffect),
+ *  createCatchError(actions),
+ *  repeat()
+ *  );
+ *
+ */
+const createRequestEffect = (actions$, actions, service, optEffect) => actions$.pipe(createRequest(actions, service, optEffect));
+const createManyCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.createMany(payload).pipe(map((response) => ({ response, payload })))));
+};
+const createManyResponse = (actions, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.CreateManyFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            const items = response.data;
+            result.push(actions.CreateManySuccess({ items }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const createManyCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.EditManyFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const createManyRequest = (actions, service, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.CreateManyRequest), createManyCall(service), createManyResponse(actions, optEffect), createManyCatchError(actions), repeat());
+};
+const editCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.update(payload).pipe(map((response) => ({ response, payload })))));
+};
+const editResponse = (actions, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.EditFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            const item = response.data;
+            result.push(actions.EditSuccess({ item }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const editCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.EditFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const editRequest = (actions, service, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.EditRequest), editCall(service), editResponse(actions, optEffect), editCatchError(actions), repeat());
+};
+/**
+ * @deprecated use:
+ *
+ * actions$.pipe(
+ *   editRequest(actions, service, optEffect)
+ * );
+ *
+ * or:
+ *
+ * actions$.pipe(
+ *  ofType(actions.EditRequest),
+ *  editCall(service),
+ *  editResponse(actions, optEffect),
+ *  editCatchError(actions),
+ *  repeat()
+ *  );
+ *
+ */
+const editRequestEffect = (actions$, actions, service, optEffect) => actions$.pipe(editRequest(actions, service, optEffect));
+const editManyCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.updateMany(payload).pipe(map((response) => ({ response, payload })))));
+};
+const editManyResponse = (actions, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.EditManyFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            const items = response.data;
+            result.push(actions.EditManySuccess({ items }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const editManyCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.EditManyFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const editManyRequest = (actions, service, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.EditManyRequest), editManyCall(service), editManyResponse(actions, optEffect), editManyCatchError(actions), repeat());
+};
+const selectCall = (service) => {
+    return input$ => input$.pipe(concatMap(payload => service.select(payload).pipe(
+    // @ts-ignore
+    map((response) => ({ response, payload })))));
+};
+const selectResponse = (actions, optEffect) => {
+    return input$ => input$.pipe(concatMap(({ response, payload }) => {
+        const result = [];
+        if (response.hasError) {
+            result.push(actions.SelectFailure({ error: response.message }));
+            if (payload.onFault) {
+                result.push(...payload.onFault);
+            }
+        }
+        else {
+            const item = response.data;
+            result.push(actions.SelectSuccess({ item }));
+            if (payload.onResult) {
+                const onResults = payload.onResult.map(a => a.newAction ? a.newAction(response, payload) : a);
+                result.push(...onResults);
+            }
+        }
+        if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+            result.push(actions.Response({
+                actionType: payload.type,
+                request: payload,
+                response
+            }));
+        }
+        return result;
+    }));
+};
+const selectCatchError = (actions) => {
+    return input$ => input$.pipe(catchError((error, caught) => {
+        const response = [];
+        response.push(actions.EditFailure({ error }));
+        response.push(actions.Response({
+            actionType: 'Failure',
+            request: null,
+            response: { hasError: true, message: error.message, data: null }
+        }));
+        return from(response);
+    }));
+};
+const selectRequest = (actions, service, optEffect) => {
+    return input$ => input$.pipe(ofType(actions.SelectRequest), selectCall(service), selectResponse(actions, optEffect), selectCatchError(actions), repeat());
+};
+/**
+ * @deprecated use:
+ *
+ * actions$.pipe(
+ *   selectRequest(actions, service, clazz, optEffect)
+ * );
+ *
+ * or:
+ *
+ * actions$.pipe(
+ *  ofType(actions.SelectRequest),
+ *  selectCall(service),
+ *  selectResponse(actions, optEffect),
+ *  selectCatchError(actions),
+ *  repeat()
+ *  );
+ *
+ */
+const selectRequestEffect = (actions$, actions, service, optEffect) => actions$.pipe(selectRequest(actions, service, optEffect));
+
+class BaseCrudService {
+    constructor(http) {
+        this.http = http;
+        this.service = '';
+        this.id = 'id';
+        this.debug = false;
+        this.httpOptions = () => {
+            return {
+                headers: new HttpHeaders({ 'Content-Type': 'application/json' })
+            };
+        };
+        this.searchMap = res => res;
+        this.getId = (value) => value[this.id];
+    }
+    debugMode() {
+        this.debug = true;
+    }
+    create(opt) {
+        if (typeof (console) !== 'undefined' && this.debug) {
+            console.log('%c BaseCrudService.create()', 'color: #777777');
+            console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+        }
+        const path = !!opt && !!opt.path ? opt.path : null;
+        return this.http.post(`${this.getUrl(path)}`, opt.mutationParams, this.httpOptions());
+    }
+    createMany(opt) {
+        this.checkOptRequest(opt);
+        const result = opt.mutationParams.map(mutationParams => {
+            const optB = Object.assign(Object.assign({}, opt), { mutationParams });
+            return this.create(optB).pipe(map(value => (Object.assign(Object.assign({}, value), { data: [value.data] }))) // trasformo la singola risposta da {data:T} in {data:T[]}
+            );
+        });
+        return of(...result).pipe(mergeMap(value => value));
+    }
+    /**
+     * metodo introdotto per la verifica di OptRequest
+     * nella nuova versione è stato sostituito opt.item e opt.items con opt.mutationParams
+     * in modo da renderlo compatibile come nomenclatura a graphql
+     * @param opt
+     */
+    checkOptRequest(opt) {
+        if (opt && opt.hasOwnProperty('item') && !!opt.item) {
+            throw new Error('Error, in new versions of the library the "items" or "item" attribute have been replaced by "mutationParams". all project attributes must be renamed.');
+        }
+        if (opt && opt.hasOwnProperty('items') && !!opt.items) {
+            throw new Error('Error, in new versions of the library the "items" or "item" attribute have been replaced by "mutationParams". all project attributes must be renamed.');
+        }
+        return true;
+    }
+    search(value) {
+        if (typeof (console) !== 'undefined' && this.debug) {
+            console.log('BaseCrudService.search()');
+            console.log('Extended from: ' + this.constructor.name);
+        }
+        const url = value && value.hasOwnProperty('path') && !!value.path ? value.path.join('/') : '';
+        let httpOptions = this.httpOptions();
+        if (value && value.hasOwnProperty('queryParams') && !!value.queryParams) {
+            httpOptions = (Object.assign(Object.assign({}, httpOptions), { params: value.queryParams }));
+        }
+        return this.http.get(this.getUrl() + url, httpOptions).pipe(map(this.searchMap));
+    }
+    select(opt) {
+        if (typeof (console) !== 'undefined' && this.debug) {
+            console.log('%c BaseCrudService.select()', 'color: #777777');
+            console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+        }
+        const id = this.getId(opt.queryParams);
+        const path = !!opt && !!opt.path ? opt.path : null;
+        return this
+            .http
+            .get(`${this.getUrl(path)}/${id}`, this.httpOptions());
+    }
+    update(opt) {
+        this.checkOptRequest(opt);
+        if (typeof (console) !== 'undefined' && this.debug) {
+            console.log('%c BaseCrudService.update()', 'color: #777777');
+            console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+        }
+        const id = this.getId(opt.mutationParams);
+        const path = !!opt && !!opt.path ? opt.path : null;
+        return this.http.put(`${this.getUrl(path)}/${id}`, opt.mutationParams, this.httpOptions());
+    }
+    updateMany(opt) {
+        this.checkOptRequest(opt);
+        const result = opt.mutationParams.map(mutationParams => {
+            const optB = Object.assign(Object.assign({}, opt), { mutationParams });
+            return this.update(optB).pipe(map(value => (Object.assign(Object.assign({}, value), { data: [value.data] }))) // trasformo la singola risposta da {data:T} in {data:T[]}
+            );
+        });
+        return of(...result).pipe(mergeMap(value => value));
+    }
+    delete(opt) {
+        this.checkOptRequest(opt);
+        if (typeof (console) !== 'undefined' && this.debug) {
+            console.log('%c BaseCrudService.delete()', 'color: #777777');
+            console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+        }
+        const id = this.getId(opt.mutationParams);
+        const path = !!opt && !!opt.path ? opt.path : null;
+        return this.http.delete(`${this.getUrl(path)}/${id}`, this.httpOptions());
+    }
+    deleteMany(opt) {
+        this.checkOptRequest(opt);
+        const result = opt.mutationParams.map(mutationParams => {
+            const optB = Object.assign(Object.assign({}, opt), { mutationParams });
+            return this.delete(optB);
+        });
+        return of(...result).pipe(mergeMap(value => value));
+    }
+    getUrl(path) {
+        const result = !!path ? `${this.service}/${path.join('/')}` : this.service;
+        if (typeof (console) !== 'undefined' && this.debug) {
+            console.log('%c BaseCrudService.getUrl(path?:string[]): string', 'color: #777777');
+            console.log('%c path: ' + path, 'color: #777777');
+            console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+            console.log('%c result: ' + result, 'color: #777777');
+        }
+        return result;
+    }
+}
+BaseCrudService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseCrudService_Factory() { return new BaseCrudService(i0.ɵɵinject(i1.HttpClient)); }, token: BaseCrudService, providedIn: "root" });
+BaseCrudService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+BaseCrudService.ctorParameters = () => [
+    { type: HttpClient }
+];
+
+class BaseCrudGqlService {
+    search(value) {
+        return this.query(value);
+    }
+    select(opt) {
+        return this.mutate(opt);
+    }
+    create(opt) {
+        return this.mutate(opt);
+    }
+    createMany(opt) {
+        return this.mutate(opt);
+    }
+    update(opt) {
+        return this.mutate(opt);
+    }
+    updateMany(opt) {
+        return this.mutate(opt);
+    }
+    delete(opt) {
+        return this.mutate(opt);
+    }
+    deleteMany(opt) {
+        return this.mutate(opt);
+    }
+    //todo tolgo tipizzazione  MutationOptions mutateMany(opt: OptRequest<MutationOptions>): Observable<Response<string[]>> {
+    mutateMany(opt) {
+        return this.apollo.mutate(opt.mutationParams).pipe(map((response) => {
+            debugger;
+            return ({
+                message: '',
+                hasError: false,
+                data: response.data.allCoins
+            });
+        }));
+    }
+    //todo tolgo tipizzazione  MutationOptions mutate(opt: OptRequest<MutationOptions>): Observable<Response<string[]>> {
+    mutate(opt) {
+        return this.apollo.mutate(opt.mutationParams).pipe(map((response) => {
+            debugger;
+            return ({
+                message: '',
+                hasError: false,
+                data: response.data.allCoins
+            });
+        }));
+    }
+    //todo tolgo tipizzazione QueryOptions query(value?: ICriteria<QueryOptions>): Observable<Response<T[]>> {
+    query(value) {
+        console.log('CoinService.search()');
+        return this.apollo
+            .query(value.queryParams).pipe(map((response) => {
+            debugger;
+            return ({
+                message: '',
+                hasError: false,
+                data: response.data.allCoins
+            });
+        }));
+    }
+}
+BaseCrudGqlService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseCrudGqlService_Factory() { return new BaseCrudGqlService(); }, token: BaseCrudGqlService, providedIn: "root" });
+BaseCrudGqlService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActionEnum, BaseCrudGqlService, BaseCrudService, CrudEnum, createCall, createCatchError, createCrudEntityAdapter, createCrudOns, createManyCall, createManyCatchError, createManyRequest, createManyResponse, createRequest, createRequestEffect, createResponse, deleteCall, deleteCatchError, deleteManyCall, deleteManyCatchError, deleteManyRequest, deleteManyResponse, deleteRequest, deleteRequestEffect, deleteResponse, editCall, editCatchError, editManyCall, editManyCatchError, editManyRequest, editManyResponse, editRequest, editRequestEffect, editResponse, searchCall, searchCatchError, searchRequest, searchRequestEffect, searchResponse, selectCall, selectCatchError, selectRequest, selectRequestEffect, selectResponse };
+//# sourceMappingURL=ngrx-entity-crud.js.map