ng-qubee 1.0.11 → 2.0.2

package/{fesm2015/ng-qubee.js → fesm2022/ng-qubee.mjs}

@@ -1,25 +1,57 @@
-import { ɵɵdefineInjectable, Injectable, Inject, Optional, NgModule } from '@angular/core';
-import { stringify } from 'qs';
-import { createAction, createReducer } from '@reduxjs/toolkit';
-import { BehaviorSubject } from 'rxjs';
-import { filter } from 'rxjs/operators';
-import { createStore, combineReducers } from 'redux';
+import * as i0 from '@angular/core';
+import { signal, computed, Injectable, Inject, Optional, NgModule, makeEnvironmentProviders } from '@angular/core';
+import * as qs from 'qs';
+import { BehaviorSubject, filter } from 'rxjs';
 
-class QueryBuilderOptions {
-    constructor(options) {
-        this.appends = options.appends || 'append';
-        this.fields = options.fields || 'fields';
-        this.filters = options.filters || 'filter';
-        this.includes = options.includes || 'include';
-        this.limit = options.limit || 'limit';
-        this.page = options.page || 'page';
-        this.sort = options.sort || 'sort';
+class KeyNotFoundError extends Error {
+    constructor(key) {
+        super(`Cannot find the key ${key} inside the collection item: does it really exists?`);
     }
 }
 
-class UnselectableModelError extends Error {
-    constructor(model) {
-        super(`Unselectable Model: the selected model (${model}) is not present neither in the "model" property, nor in the includes object.`);
+class PaginatedCollection {
+    constructor(data, page, from, to, total, perPage, prevPageUrl, nextPageUrl, lastPage, firstPageUrl, lastPageUrl) {
+        this.data = data;
+        this.page = page;
+        this.from = from;
+        this.to = to;
+        this.total = total;
+        this.perPage = perPage;
+        this.prevPageUrl = prevPageUrl;
+        this.nextPageUrl = nextPageUrl;
+        this.lastPage = lastPage;
+        this.firstPageUrl = firstPageUrl;
+        this.lastPageUrl = lastPageUrl;
+        //
+    }
+    /**
+     * Normalize the collection to a paginated list of ids for state-managed applications.
+     *
+     * This method returns a single key object, where the key is the page number and the associated value is
+     * an array of ids. Each id is fetched by the collection items, looking up for the "id" key. If an id is supplied
+     * to this method, it will be used instead of the default "id" key.
+     *
+     * Please note that in case the key doesn't exist in the collection's item, a KeyNotFoundError is thrown
+     *
+     * @param k A key to use instead of the default "id": this will be searched inside each element of the collection
+     * @returns []
+     * @throws KeyNotFoundItem
+     */
+    normalize(id) {
+        return {
+            [this.page]: this.data.reduce((ids, value) => {
+                if (id && id in value) {
+                    ids.push(value[id]);
+                }
+                else if (value.hasOwnProperty('id')) {
+                    ids.push(value['id']);
+                }
+                else {
+                    throw new KeyNotFoundError(id || 'id');
+                }
+                return ids;
+            }, [])
+        };
     }
 }
 
@@ -29,23 +61,25 @@ var SortEnum;
     SortEnum["DESC"] = "desc";
 })(SortEnum || (SortEnum = {}));
 
-// Interfaces
-const addFields = createAction('[Query Buillder] Add Fields');
-const addFilters = createAction('[Query Buillder] Add Filters');
-const addIncludes = createAction('[Query Buillder] Add Includes');
-const addSorts = createAction('[Query Buillder] Add Sorts');
-const deleteFields = createAction('[Query Buillder] Delete Fields');
-const deleteFilters = createAction('[Query Buillder] Delete Filters');
-const deleteIncludes = createAction('[Query Buillder] Delete Includes');
-const deleteSorts = createAction('[Query Buillder] Delete Sorts');
-const reset = createAction('[Query Builder] Reset');
-const setBaseUrl = createAction('[Query Buillder] Set Base URL');
-const setLimit = createAction('[Query Buillder] Set Limit');
-const setModel = createAction('[Query Builder] Set Model');
-const setPage = createAction('[Query Builder] Set Page');
-const updateUri = createAction('[Query Builder] Update URI');
+class UnselectableModelError extends Error {
+    constructor(model) {
+        super(`Unselectable Model: the selected model (${model}) is not present neither in the "model" property, nor in the includes object.`);
+    }
+}
 
-const initialState = {
+class QueryBuilderOptions {
+    constructor(options) {
+        this.appends = options.appends || 'append';
+        this.fields = options.fields || 'fields';
+        this.filters = options.filters || 'filter';
+        this.includes = options.includes || 'include';
+        this.limit = options.limit || 'limit';
+        this.page = options.page || 'page';
+        this.sort = options.sort || 'sort';
+    }
+}
+
+const INITIAL_STATE = {
     baseUrl: '',
     fields: {},
     filters: {},
@@ -53,71 +87,172 @@ const initialState = {
     limit: 15,
     model: '',
     page: 1,
-    sort: {},
-    uri: ''
-};
-const ɵ0 = builder => {
-    builder.addCase(addFields, (state, { payload: { fields } }) => (Object.assign(Object.assign({}, state), { fields: Object.assign(Object.assign({}, state.fields), fields) }))),
-        builder.addCase(addFilters, (state, { payload: { filters } }) => (Object.assign(Object.assign({}, state), { filters: Object.assign(Object.assign({}, state.filters), filters) }))),
-        builder.addCase(addIncludes, (state, { payload: { includes } }) => (Object.assign(Object.assign({}, state), { includes: [...state.includes, ...includes] }))),
-        builder.addCase(addSorts, (state, { payload: { sorts } }) => (Object.assign(Object.assign({}, state), { sort: Object.assign(Object.assign({}, state.sort), sorts) }))),
-        builder.addCase(deleteFields, (state, { payload: { fields } }) => {
-            const f = Object.assign({}, state.fields);
-            Object.keys(fields).forEach(k => {
-                if (!(k in state.fields)) {
-                    return;
-                }
-                f[k] = state.fields[k].filter(v => !fields[k].includes(v));
-            });
-            return Object.assign(Object.assign({}, state), { fields: f });
-        }),
-        builder.addCase(deleteFilters, (state, { payload: { filters } }) => {
-            const f = Object.assign({}, state.filters);
-            filters.forEach(k => delete f[k]);
-            return Object.assign(Object.assign({}, state), { filters: f });
-        }),
-        builder.addCase(deleteIncludes, (state, { payload: { includes } }) => {
-            return Object.assign(Object.assign({}, state), { includes: state.includes.filter(v => !includes.includes(v)) });
-        }),
-        builder.addCase(deleteSorts, (state, { payload: { sorts } }) => {
-            const s = Object.assign({}, state.sort);
-            sorts.forEach(v => delete s[v]);
-            return Object.assign(Object.assign({}, state), { sort: s });
-        }),
-        builder.addCase(reset, state => initialState),
-        builder.addCase(setBaseUrl, (state, { payload: { baseUrl } }) => (Object.assign(Object.assign({}, state), { baseUrl }))),
-        builder.addCase(setLimit, (state, { payload: { limit } }) => (Object.assign(Object.assign({}, state), { limit }))),
-        builder.addCase(setModel, (state, { payload: { model } }) => (Object.assign(Object.assign({}, state), { model }))),
-        builder.addCase(setPage, (state, { payload: { page } }) => (Object.assign(Object.assign({}, state), { page }))),
-        builder.addCase(updateUri, (state, { payload: { uri } }) => (Object.assign(Object.assign({}, state), { uri })));
+    sorts: []
 };
-const queryBuilderReducer = createReducer(initialState, ɵ0);
-
-class StoreService {
+class NestService {
     constructor() {
-        this._store = createStore(combineReducers({ nest: queryBuilderReducer }));
+        /**
+         * Private writable signal that holds the Query Builder state
+         *
+         * @type {IQueryBuilderState}
+         */
+        this._nest = signal(this._clone(INITIAL_STATE));
+        /**
+         * A computed signal that makes readonly the writable signal _nest
+         *
+         * @type {Signal<IQueryBuilderState>}
+         */
+        this.nest = computed(() => this._clone(this._nest()));
+        // Nothing to see here 👮🏻‍♀️
     }
-    get state() {
-        return this._store.getState();
+    set baseUrl(baseUrl) {
+        this._nest.update(nest => ({
+            ...nest,
+            baseUrl
+        }));
     }
-    dispatch(action) {
-        this._store.dispatch(action);
+    set limit(limit) {
+        this._nest.update(nest => ({
+            ...nest,
+            limit
+        }));
     }
-    subscribe(listener) {
-        this._store.subscribe(listener);
+    set model(model) {
+        this._nest.update(nest => ({
+            ...nest,
+            model
+        }));
     }
+    set page(page) {
+        this._nest.update(nest => ({
+            ...nest,
+            page
+        }));
+    }
+    _clone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    /**
+     * Add selectable fields for the given model to the request
+     *
+     * @param {IFields} fields
+     * @return {void}
+     * @todo Avoid duplicated fields
+     */
+    addFields(fields) {
+        this._nest.update(nest => ({
+            ...nest,
+            fields: { ...nest.fields, ...fields }
+        }));
+    }
+    /**
+     * Add filters to the request
+     *
+     * @param {IFilters} filters
+     * @todo Avoid duplicated filters
+     */
+    addFilters(filters) {
+        this._nest.update(nest => ({
+            ...nest,
+            filters: { ...nest.filters, ...filters }
+        }));
+    }
+    /**
+     * Add resources to include with the request
+     *
+     * @param {string[]} includes  models to include to the request
+     * @return {void}
+     * @todo Avoid duplicated includes
+     */
+    addIncludes(includes) {
+        this._nest.update(nest => ({
+            ...nest,
+            includes: [...nest.includes, ...includes]
+        }));
+    }
+    /**
+     * Add a field that should be used for sorting data
+     *
+     * @param {ISort} sort
+     * @return {void}
+     */
+    addSort(sort) {
+        this._nest.update(nest => ({
+            ...nest,
+            sorts: [...nest.sorts, sort]
+        }));
+    }
+    /**
+     * Remove fields for the given model
+     *
+     * @param {IFields} fields
+     */
+    deleteFields(fields) {
+        const f = Object.assign({}, this.nest().fields);
+        Object.keys(fields).forEach(k => {
+            if (!(k in f)) {
+                return;
+            }
+            f[k] = this._nest().fields[k].filter(v => !fields[k].includes(v));
+        });
+        this._nest.update(nest => ({
+            ...nest,
+            fields: f
+        }));
+    }
+    /**
+     *
+     * @param filters
+     * @todo Create a clone of the filter obj before assigning to f
+     */
+    deleteFilters(...filters) {
+        const f = Object.assign({}, this._nest().filters);
+        filters.forEach(k => delete f[k]);
+        this._nest.update(nest => ({
+            ...nest,
+            filters: f
+        }));
+    }
+    /**
+     *
+     * @param includes
+     */
+    deleteIncludes(...includes) {
+        this._nest.update(nest => ({
+            ...nest,
+            includes: nest.includes.filter(v => !includes.includes(v))
+        }));
+    }
+    /**
+     *
+     * @param sorts
+     */
+    deleteSorts(...sorts) {
+        const s = [...this._nest().sorts];
+        sorts.forEach(field => {
+            const p = this.nest().sorts.findIndex(sort => sort.field === field);
+            if (p > -1) {
+                s.splice(p, 1);
+            }
+        });
+        this._nest.update(nest => ({
+            ...nest,
+            sorts: s
+        }));
+    }
+    reset() {
+        this._nest.update(_ => this._clone(INITIAL_STATE));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NestService }); }
 }
-StoreService.ɵprov = ɵɵdefineInjectable({ factory: function StoreService_Factory() { return new StoreService(); }, token: StoreService, providedIn: "root" });
-StoreService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-StoreService.ctorParameters = () => [];
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NestService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
 
 class NgQubeeService {
-    constructor(_store, options = {}) {
-        this._store = _store;
+    constructor(_nestService, options = {}) {
+        this._nestService = _nestService;
         /**
          * This property serves as an accumulator for holding the composed string with each query param
          */
@@ -125,9 +260,6 @@ class NgQubeeService {
         this._uri$ = new BehaviorSubject('');
         this.uri$ = this._uri$.asObservable().pipe(filter(uri => !!uri));
         this._options = new QueryBuilderOptions(options);
-        this._store.subscribe(() => {
-            this._uri$.next(this._store.state.nest.uri);
-        });
     }
     _parseFields(s) {
         if (!Object.keys(s.fields).length) {
@@ -150,7 +282,7 @@ class NgQubeeService {
                 Object.assign(f, { [`${this._options.fields}[${k}]`]: s.fields[k].join(',') });
             }
         }
-        const param = `${this._prepend(s.model)}${stringify(f, { encode: false })}`;
+        const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;
         this._uri += param;
         return param;
     }
@@ -160,11 +292,11 @@ class NgQubeeService {
             return this._uri;
         }
         const f = {
-            [this._options.filters]: keys.reduce((acc, key) => {
+            [`${this._options.filters}`]: keys.reduce((acc, key) => {
                 return Object.assign(acc, { [key]: s.filters[key].join(',') });
             }, {})
         };
-        const param = `${this._prepend(s.model)}${stringify(f, { encode: false })}`;
+        const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;
         this._uri += param;
         return param;
     }
@@ -188,14 +320,13 @@ class NgQubeeService {
     }
     _parseSort(s) {
         let param = '';
-        const fields = Object.keys(s.sort);
-        if (!fields.length) {
+        if (!s.sorts.length) {
             return param;
         }
         param = `${this._prepend(s.model)}${this._options.sort}=`;
-        fields.forEach((field, idx) => {
-            param += `${s.sort[field] === SortEnum.DESC ? '-' : ''}${field}`;
-            if (idx < fields.length - 1) {
+        s.sorts.forEach((sort, idx) => {
+            param += `${sort.order === SortEnum.DESC ? '-' : ''}${sort.field}`;
+            if (idx < s.sorts.length - 1) {
                 param += ',';
             }
         });
@@ -206,17 +337,25 @@ class NgQubeeService {
         if (!s.model) {
             throw new Error('Set the model property BEFORE adding filters or calling the url() / get() methods');
         }
+        // Cleanup the previously generated URI
+        this._uri = '';
         this._parseIncludes(s);
         this._parseFields(s);
         this._parseFilters(s);
         this._parseLimit(s);
         this._parsePage(s);
         this._parseSort(s);
-        this._store.dispatch(updateUri({ uri: this._uri }));
+        return this._uri;
     }
     _prepend(model) {
         return this._uri ? '&' : `/${model}?`;
     }
+    // private _removeArgIfEmpty(arg: string): string {
+    //   const params = new URL(this._uri).searchParams;
+    //   if (!params.get(arg)) {
+    //     params.delete(arg);
+    //   }
+    // }
     /**
      * Add fields to the select statement for the given model
      *
@@ -228,11 +367,7 @@ class NgQubeeService {
         if (!fields.length) {
             return this;
         }
-        this._store.dispatch(addFields({
-            fields: {
-                [model]: fields
-            }
-        }));
+        this._nestService.addFields({ [model]: fields });
         return this;
     }
     /**
@@ -247,11 +382,9 @@ class NgQubeeService {
         if (!values.length) {
             return this;
         }
-        this._store.dispatch(addFilters({
-            filters: {
-                [field]: values
-            }
-        }));
+        this._nestService.addFilters({
+            [field]: values
+        });
         return this;
     }
     /**
@@ -261,41 +394,61 @@ class NgQubeeService {
      * @returns
      */
     addIncludes(...models) {
-        if (!models) {
+        if (!models.length) {
             return this;
         }
-        this._store.dispatch(addIncludes({
-            includes: models
-        }));
+        this._nestService.addIncludes(models);
         return this;
     }
     /**
      * Add a field with a sort criteria
      *
      * @param field Field to use for sorting
-     * @param {SortEnum} value A value from the SortEnum enumeration
+     * @param {SortEnum} order A value from the SortEnum enumeration
      * @returns {this}
      */
-    addSort(field, value) {
-        this._store.dispatch(addSorts({
-            sorts: {
-                [field]: value
-            }
-        }));
+    addSort(field, order) {
+        this._nestService.addSort({
+            field,
+            order
+        });
+        return this;
+    }
+    /**
+     * Delete selected fields for the given models in the current query builder state
+     *
+     * ```
+     * ngQubeeService.deleteFields({
+     *   users: ['email', 'password'],
+     *   address: ['zipcode']
+     * });
+     * ```
+     *
+     * @param {IFields} fields
+     * @returns
+     */
+    deleteFields(fields) {
+        this._nestService.deleteFields(fields);
         return this;
     }
     /**
      * Delete selected fields for the given model in the current query builder state
      *
+     * ```
+     * ngQubeeService.deleteFieldsByModel('users', 'email', 'password']);
+     * ```
+     *
      * @param model Model that holds the fields
      * @param {string[]} fields Fields to delete from the state
      * @returns {this}
      */
-    deleteFields(model, ...fields) {
+    deleteFieldsByModel(model, ...fields) {
         if (!fields.length) {
             return this;
         }
-        this._store.dispatch(deleteFields({ fields }));
+        this._nestService.deleteFields({
+            [model]: fields
+        });
         return this;
     }
     /**
@@ -308,7 +461,7 @@ class NgQubeeService {
         if (!filters.length) {
             return this;
         }
-        this._store.dispatch(deleteFilters({ filters }));
+        this._nestService.deleteFilters(...filters);
         return this;
     }
     /**
@@ -321,7 +474,7 @@ class NgQubeeService {
         if (!includes.length) {
             return this;
         }
-        this._store.dispatch(deleteIncludes({ includes }));
+        this._nestService.deleteIncludes(...includes);
         return this;
     }
     /**
@@ -331,7 +484,7 @@ class NgQubeeService {
      * @returns {this}
      */
     deleteSorts(...sorts) {
-        this._store.dispatch(deleteSorts({ sorts }));
+        this._nestService.deleteSorts(...sorts);
         return this;
     }
     /**
@@ -340,9 +493,7 @@ class NgQubeeService {
      * @returns {Observable<string>} An observable that emits the generated uri
      */
     generateUri() {
-        // Cleanup the previously generated URI
-        this._uri = '';
-        this._parse(this._store.state.nest);
+        this._uri$.next(this._parse(this._nestService.nest()));
         return this.uri$;
     }
     /**
@@ -351,7 +502,7 @@ class NgQubeeService {
      * @returns {this}
      */
     reset() {
-        this._store.dispatch(reset());
+        this._nestService.reset();
         return this;
     }
     /**
@@ -361,7 +512,7 @@ class NgQubeeService {
      * @returns {this}
      */
     setBaseUrl(baseUrl) {
-        this._store.dispatch(setBaseUrl({ baseUrl }));
+        this._nestService.baseUrl = baseUrl;
         return this;
     }
     /**
@@ -371,7 +522,7 @@ class NgQubeeService {
      * @returns {this}
      */
     setLimit(limit) {
-        this._store.dispatch(setLimit({ limit }));
+        this._nestService.limit = limit;
         return this;
     }
     /**
@@ -382,7 +533,7 @@ class NgQubeeService {
      * @returns {this}
      */
     setModel(model) {
-        this._store.dispatch(setModel({ model }));
+        this._nestService.model = model;
         return this;
     }
     /**
@@ -392,67 +543,20 @@ class NgQubeeService {
      * @returns {this}
      */
     setPage(page) {
-        this._store.dispatch(setPage({ page }));
+        this._nestService.page = page;
         return this;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeService, deps: [{ token: NestService }, { token: 'QUERY_PARAMS_CONFIG', optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeService }); }
 }
-NgQubeeService.decorators = [
-    { type: Injectable }
-];
-NgQubeeService.ctorParameters = () => [
-    { type: StoreService },
-    { type: undefined, decorators: [{ type: Inject, args: ['QUERY_PARAMS_CONFIG',] }, { type: Optional }] }
-];
-
-class KeyNotFoundError extends Error {
-    constructor(key) {
-        super(`Cannot find the key ${key} inside the collection item: does it really exists?`);
-    }
-}
-
-class PaginatedCollection {
-    constructor(data, page, from, to, total, perPage, prevPageUrl, nextPageUrl, lastPage, firstPageUrl, lastPageUrl) {
-        this.data = data;
-        this.page = page;
-        this.from = from;
-        this.to = to;
-        this.total = total;
-        this.perPage = perPage;
-        this.prevPageUrl = prevPageUrl;
-        this.nextPageUrl = nextPageUrl;
-        this.lastPage = lastPage;
-        this.firstPageUrl = firstPageUrl;
-        this.lastPageUrl = lastPageUrl;
-        //
-    }
-    /**
-     * Normalize the collection to a paginated list of ids for state-managed applciations.
-     *
-     * This method returns a single key object, where the key is the page number and the associated value is
-     * an array of ids. Each id is fetched by the collection items, looking up for the "id" key. If an id is supplied
-     * to this method, it will be used instead of the default "id" key.
-     *
-     * Please note that in case the key doesn't exist in the collection's item, the array will be empty
-     *
-     * @param k A key to use instead of the default "id": this will be searched inside each element of the collection
-     */
-    normalize(id) {
-        return {
-            [this.page]: this.data.reduce((ids, value) => {
-                if (id && value[id]) {
-                    ids.push(value[id]);
-                }
-                else if (value.hasOwnProperty('id')) {
-                    ids.push(value['id']);
-                }
-                else {
-                    throw new KeyNotFoundError(id || 'id');
-                }
-                return ids;
-            }, [])
-        };
-    }
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: NestService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['QUERY_PARAMS_CONFIG']
+                }, {
+                    type: Optional
+                }] }] });
 
 class ResponseOptions {
     constructor(options) {
@@ -478,41 +582,89 @@ class PaginationService {
     paginate(response) {
         return new PaginatedCollection(response[this._options.data], response[this._options.currentPage], response[this._options.from], response[this._options.to], response[this._options.total], response[this._options.perPage], response[this._options.prevPageUrl], response[this._options.nextPageUrl], response[this._options.lastPage], response[this._options.firstPageUrl], response[this._options.lastPageUrl]);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PaginationService, deps: [{ token: 'RESPONSE_OPTIONS', optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PaginationService }); }
 }
-PaginationService.decorators = [
-    { type: Injectable }
-];
-PaginationService.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: ['RESPONSE_OPTIONS',] }, { type: Optional }] }
-];
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PaginationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['RESPONSE_OPTIONS']
+                }, {
+                    type: Optional
+                }] }] });
 
-const ɵ0$1 = (store) => new NgQubeeService(store, {});
 // @dynamic
 class NgQubeeModule {
     static forRoot(config = {}) {
         return {
             ngModule: NgQubeeModule,
-            providers: [{
-                    deps: [StoreService],
+            providers: [
+                NestService,
+                {
+                    deps: [NestService],
                     provide: NgQubeeService,
-                    useFactory: (store) => new NgQubeeService(store, Object.assign({}, this._config.request, config.request))
+                    useFactory: (nestService) => new NgQubeeService(nestService, Object.assign({}, config.request))
                 }, {
                     provide: PaginationService,
-                    useFactory: () => new PaginationService(Object.assign({}, this._config.response, config.response))
-                }]
+                    useFactory: () => new PaginationService(Object.assign({}, config.response))
+                }
+            ]
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeModule, providers: [{
+                deps: [NestService],
+                provide: NgQubeeService,
+                useFactory: (nestService) => new NgQubeeService(nestService, {})
+            }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [{
+                            deps: [NestService],
+                            provide: NgQubeeService,
+                            useFactory: (nestService) => new NgQubeeService(nestService, {})
+                        }]
+                }]
+        }] });
+
+/**
+ * Sets up providers necessary to enable `NgQubee` functionality for the application.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can add NgQubee to your application:
+ * ```
+ * const config = {};
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideNgQubee(config)]
+ * });
+ * ```
+ *
+ * @publicApi
+ * @param config Configuration object compliant to the IConfig interface
+ * @returns A set of providers to setup NgQubee
+ */
+function provideNgQubee(config = {}) {
+    return makeEnvironmentProviders([
+        {
+            provide: NestService,
+            useClass: NestService
+        },
+        {
+            deps: [NestService],
+            provide: NgQubeeService,
+            useFactory: (nestService) => new NgQubeeService(nestService, Object.assign({}, config.request))
+        }, {
+            provide: PaginationService,
+            useFactory: () => new PaginationService(Object.assign({}, config.response))
+        }
+    ]);
 }
-NgQubeeModule._config = {};
-NgQubeeModule.decorators = [
-    { type: NgModule, args: [{
-                providers: [{
-                        deps: [StoreService],
-                        provide: NgQubeeService,
-                        useFactory: ɵ0$1
-                    }]
-            },] }
-];
 
 /*
  * Public API Surface of angular-query-builder
@@ -522,5 +674,5 @@ NgQubeeModule.decorators = [
  * Generated bundle index. Do not edit.
  */
 
-export { NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationService, ɵ0$1 as ɵ0, StoreService as ɵa };
-//# sourceMappingURL=ng-qubee.js.map
+export { NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationService, provideNgQubee };
+//# sourceMappingURL=ng-qubee.mjs.map