ng-qubee 1.0.9 → 2.0.2

package/esm2022/lib/services/nest.service.mjs

@@ -0,0 +1,173 @@
+import { Injectable, computed, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+const INITIAL_STATE = {
+    baseUrl: '',
+    fields: {},
+    filters: {},
+    includes: [],
+    limit: 15,
+    model: '',
+    page: 1,
+    sorts: []
+};
+export class NestService {
+    constructor() {
+        /**
+         * 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 👮🏻‍♀️
+    }
+    set baseUrl(baseUrl) {
+        this._nest.update(nest => ({
+            ...nest,
+            baseUrl
+        }));
+    }
+    set limit(limit) {
+        this._nest.update(nest => ({
+            ...nest,
+            limit
+        }));
+    }
+    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 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NestService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nest.service.js","sourceRoot":"","sources":["../../../../../projects/ng-qubee/src/lib/services/nest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Signal, WritableSignal, computed, signal } from '@angular/core';\nimport { IQueryBuilderState } from '../interfaces/query-builder-state.interface';\nimport { IFields } from '../interfaces/fields.interface';\nimport { IFilters } from '../interfaces/filters.interface';\nimport { ISort } from '../interfaces/sort.interface';\n\nconst INITIAL_STATE: IQueryBuilderState = {\n  baseUrl: '',\n  fields: {},\n  filters: {},\n  includes: [],\n  limit: 15,\n  model: '',\n  page: 1,\n  sorts: []\n};\n\n@Injectable()\nexport class NestService {\n\n  /**\n   * Private writable signal that holds the Query Builder state\n   * \n   * @type {IQueryBuilderState}\n   */\n  private _nest: WritableSignal<IQueryBuilderState> = signal(this._clone(INITIAL_STATE));\n\n  /**\n   * A computed signal that makes readonly the writable signal _nest\n   * \n   * @type {Signal<IQueryBuilderState>}\n   */\n  public nest: Signal<IQueryBuilderState> = computed(() => this._clone(this._nest()));\n\n  constructor() {\n    // Nothing to see here 👮🏻‍♀️\n  }\n\n  set baseUrl(baseUrl: string) {\n    this._nest.update(nest => ({\n      ...nest,\n      baseUrl\n    }));\n  }\n\n  set limit(limit: number) {\n    this._nest.update(nest => ({\n      ...nest,\n      limit\n    }));\n  }\n\n  set model(model: string) {\n    this._nest.update(nest => ({\n      ...nest,\n      model\n    }));\n  }\n\n  set page(page: number) {\n    this._nest.update(nest => ({\n      ...nest,\n      page\n    }));\n  }\n\n  private _clone<T>(obj: T): T {\n    return JSON.parse( JSON.stringify(obj) );\n  }\n\n  /**\n   * Add selectable fields for the given model to the request\n   * \n   * @param {IFields} fields \n   * @return {void}\n   * @todo Avoid duplicated fields\n   */\n  public addFields(fields: IFields): void {\n    this._nest.update(nest => ({\n      ...nest,\n      fields: { ...nest.fields, ...fields }\n    }));\n  }\n\n  /**\n   * Add filters to the request\n   * \n   * @param {IFilters} filters\n   * @todo Avoid duplicated filters\n   */\n  public addFilters(filters: IFilters): void {\n    this._nest.update(nest => ({\n      ...nest,\n      filters: { ...nest.filters, ...filters }\n    }));\n  }\n\n  /**\n   * Add resources to include with the request\n   * \n   * @param {string[]} includes  models to include to the request\n   * @return {void}\n   * @todo Avoid duplicated includes\n   */\n  public addIncludes(includes: string[]): void {\n    this._nest.update(nest => ({\n      ...nest,\n      includes: [...nest.includes, ...includes]\n    }))\n  }\n\n  /**\n   * Add a field that should be used for sorting data\n   * \n   * @param {ISort} sort\n   * @return {void}\n   */\n  public addSort(sort: ISort): void {\n    this._nest.update(nest => ({\n      ...nest,\n      sorts: [...nest.sorts, sort]\n    }));\n  }\n\n  /**\n   * Remove fields for the given model\n   * \n   * @param {IFields} fields \n   */\n  public deleteFields(fields: IFields): void {\n    const f = Object.assign({}, this.nest().fields);\n\n    Object.keys(fields).forEach(k => {\n      if (!(k in f)) {\n        return;\n      }\n\n      f[k] = this._nest().fields[k].filter(v => !fields[k].includes(v));\n    });\n\n    this._nest.update(nest => ({\n      ...nest,\n      fields: f\n    }));\n  }\n\n  /**\n   * \n   * @param filters \n   * @todo Create a clone of the filter obj before assigning to f\n   */\n  public deleteFilters(...filters: string[]): void {\n    const f = Object.assign({}, this._nest().filters);\n    \n    filters.forEach(k => delete f[k]);\n\n    this._nest.update(nest => ({\n      ...nest,\n      filters: f\n    }));\n  }\n\n  /**\n   * \n   * @param includes \n   */\n  public deleteIncludes(...includes: string[]): void {\n    this._nest.update(nest => ({\n      ...nest,\n      includes: nest.includes.filter(v => !includes.includes(v))\n    }));\n  }\n\n  /**\n   * \n   * @param sorts \n   */\n  public deleteSorts(...sorts: string[]): void {\n    const s = [...this._nest().sorts];\n    \n    sorts.forEach(field => {\n      const p = this.nest().sorts.findIndex(sort => sort.field === field);\n\n      if (p > -1) {\n        s.splice(p, 1);\n      }\n    });\n    \n    this._nest.update(nest => ({\n      ...nest,\n      sorts: s\n    }));\n  }\n\n  public reset(): void {\n    this._nest.update(_ => this._clone(INITIAL_STATE));\n  }\n}\n"]}

package/esm2022/lib/services/ng-qubee.service.mjs

@@ -0,0 +1,319 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import * as qs from 'qs';
+import { BehaviorSubject, filter } from 'rxjs';
+// Enums
+import { SortEnum } from '../enums/sort.enum';
+// Errors
+import { UnselectableModelError } from '../errors/unselectable-model.error';
+// Models
+import { QueryBuilderOptions } from '../models/query-builder-options';
+import * as i0 from "@angular/core";
+import * as i1 from "./nest.service";
+export class NgQubeeService {
+    constructor(_nestService, options = {}) {
+        this._nestService = _nestService;
+        /**
+         * This property serves as an accumulator for holding the composed string with each query param
+         */
+        this._uri = '';
+        this._uri$ = new BehaviorSubject('');
+        this.uri$ = this._uri$.asObservable().pipe(filter(uri => !!uri));
+        this._options = new QueryBuilderOptions(options);
+    }
+    _parseFields(s) {
+        if (!Object.keys(s.fields).length) {
+            return this._uri;
+        }
+        if (!s.model) {
+            throw new Error('While selecting fields, the -> model <- is required');
+        }
+        if (!(s.model in s.fields)) {
+            throw new Error(`Key ${s.model} is missing in the fields object`);
+        }
+        const f = {};
+        for (const k in s.fields) {
+            if (s.fields.hasOwnProperty(k)) {
+                // Check if the key is the model or is declared in "includes".
+                // If not, it means that has not been selected anywhere and that will cause an error on the API
+                if (k !== s.model && !s.includes.includes(k)) {
+                    throw new UnselectableModelError(k);
+                }
+                Object.assign(f, { [`${this._options.fields}[${k}]`]: s.fields[k].join(',') });
+            }
+        }
+        const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;
+        this._uri += param;
+        return param;
+    }
+    _parseFilters(s) {
+        const keys = Object.keys(s.filters);
+        if (!keys.length) {
+            return this._uri;
+        }
+        const f = {
+            [`${this._options.filters}`]: keys.reduce((acc, key) => {
+                return Object.assign(acc, { [key]: s.filters[key].join(',') });
+            }, {})
+        };
+        const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;
+        this._uri += param;
+        return param;
+    }
+    _parseIncludes(s) {
+        if (!s.includes.length) {
+            return this._uri;
+        }
+        const param = `${this._prepend(s.model)}${this._options.includes}=${s.includes}`;
+        this._uri += param;
+        return param;
+    }
+    _parseLimit(s) {
+        const param = `${this._prepend(s.model)}${this._options.limit}=${s.limit}`;
+        this._uri += param;
+        return param;
+    }
+    _parsePage(s) {
+        const param = `${this._prepend(s.model)}${this._options.page}=${s.page}`;
+        this._uri += param;
+        return param;
+    }
+    _parseSort(s) {
+        let param = '';
+        if (!s.sorts.length) {
+            return param;
+        }
+        param = `${this._prepend(s.model)}${this._options.sort}=`;
+        s.sorts.forEach((sort, idx) => {
+            param += `${sort.order === SortEnum.DESC ? '-' : ''}${sort.field}`;
+            if (idx < s.sorts.length - 1) {
+                param += ',';
+            }
+        });
+        this._uri += param;
+        return param;
+    }
+    _parse(s) {
+        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);
+        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
+     *
+     * @param model Model that holds the fields
+     * @param fields Fields to select
+     * @returns {this}
+     */
+    addFields(model, fields) {
+        if (!fields.length) {
+            return this;
+        }
+        this._nestService.addFields({ [model]: fields });
+        return this;
+    }
+    /**
+     * Add a filter with the given value(s)
+     *  I.e. filter[field]=1 or filter[field]=1,2,3
+     *
+     * @param {string} field Name of the field to filter
+     * @param {string[]} value The needle(s)
+     * @returns {this}
+     */
+    addFilter(field, ...values) {
+        if (!values.length) {
+            return this;
+        }
+        this._nestService.addFilters({
+            [field]: values
+        });
+        return this;
+    }
+    /**
+     * Add related entities to include in the request
+     *
+     * @param {string[]} models
+     * @returns
+     */
+    addIncludes(...models) {
+        if (!models.length) {
+            return this;
+        }
+        this._nestService.addIncludes(models);
+        return this;
+    }
+    /**
+     * Add a field with a sort criteria
+     *
+     * @param field Field to use for sorting
+     * @param {SortEnum} order A value from the SortEnum enumeration
+     * @returns {this}
+     */
+    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}
+     */
+    deleteFieldsByModel(model, ...fields) {
+        if (!fields.length) {
+            return this;
+        }
+        this._nestService.deleteFields({
+            [model]: fields
+        });
+        return this;
+    }
+    /**
+     * Remove given filters from the query builder state
+     *
+     * @param {string[]} filters Filters to remove
+     * @returns {this}
+     */
+    deleteFilters(...filters) {
+        if (!filters.length) {
+            return this;
+        }
+        this._nestService.deleteFilters(...filters);
+        return this;
+    }
+    /**
+     * Remove selected related models from the query builder state
+     *
+     * @param {string[]} includes Models to remove
+     * @returns
+     */
+    deleteIncludes(...includes) {
+        if (!includes.length) {
+            return this;
+        }
+        this._nestService.deleteIncludes(...includes);
+        return this;
+    }
+    /**
+     * Remove sorts rules from the query builder state
+     *
+     * @param sorts Fields used for sorting to remove
+     * @returns {this}
+     */
+    deleteSorts(...sorts) {
+        this._nestService.deleteSorts(...sorts);
+        return this;
+    }
+    /**
+     * Generate an URI accordingly to the given data
+     *
+     * @returns {Observable<string>} An observable that emits the generated uri
+     */
+    generateUri() {
+        this._uri$.next(this._parse(this._nestService.nest()));
+        return this.uri$;
+    }
+    /**
+     * Clear the current state and reset the Query Builder to a fresh, clean condition
+     *
+     * @returns {this}
+     */
+    reset() {
+        this._nestService.reset();
+        return this;
+    }
+    /**
+     * Set the base url to use for composing the address
+     *
+     * @param {string} baseUrl
+     * @returns {this}
+     */
+    setBaseUrl(baseUrl) {
+        this._nestService.baseUrl = baseUrl;
+        return this;
+    }
+    /**
+     * Set the items per page number
+     *
+     * @param limit
+     * @returns {this}
+     */
+    setLimit(limit) {
+        this._nestService.limit = limit;
+        return this;
+    }
+    /**
+     * Set the model to use for running the query against
+     *   - I.e. the model "users" will return /users
+     *
+     * @param {string} model Model name
+     * @returns {this}
+     */
+    setModel(model) {
+        this._nestService.model = model;
+        return this;
+    }
+    /**
+     * Set the page that the backend will use to paginate the result set
+     *
+     * @param page Page param
+     * @returns {this}
+     */
+    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: i1.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 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NgQubeeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.NestService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['QUERY_PARAMS_CONFIG']
+                }, {
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-qubee.service.js","sourceRoot":"","sources":["../../../../../projects/ng-qubee/src/lib/services/ng-qubee.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport * as qs from 'qs';\nimport { BehaviorSubject, Observable, filter } from 'rxjs';\n\n// Enums\nimport { SortEnum } from '../enums/sort.enum';\n\n// Errors\nimport { UnselectableModelError } from '../errors/unselectable-model.error';\n\n// Interfaces\nimport { IFields } from '../interfaces/fields.interface';\nimport { IQueryBuilderConfig } from '../interfaces/query-builder-config.interface';\nimport { IQueryBuilderState } from '../interfaces/query-builder-state.interface';\n\n// Models\nimport { QueryBuilderOptions } from '../models/query-builder-options';\n\n// Services\nimport { NestService } from './nest.service';\n\n@Injectable()\nexport class NgQubeeService {\n\n  private _options: QueryBuilderOptions;\n\n  /**\n   * This property serves as an accumulator for holding the composed string with each query param\n   */\n  private _uri = '';\n\n  private _uri$: BehaviorSubject<string> = new BehaviorSubject('');\n\n  public uri$: Observable<string> = this._uri$.asObservable().pipe(\n    filter(uri => !!uri)\n  );\n\n  constructor(private _nestService: NestService, @Inject('QUERY_PARAMS_CONFIG') @Optional() options: IQueryBuilderConfig = {}) {\n    this._options = new QueryBuilderOptions(options);\n  }\n\n  private _parseFields(s: IQueryBuilderState): string {\n    if (!Object.keys(s.fields).length) {\n      return this._uri;\n    }\n\n    if (!s.model) {\n      throw new Error('While selecting fields, the -> model <- is required');\n    }\n\n    if (!(s.model in s.fields)) {\n      throw new Error(`Key ${s.model} is missing in the fields object`);\n    }\n\n    const f = {};\n\n    for (const k in s.fields) {\n      if (s.fields.hasOwnProperty(k)) {\n        // Check if the key is the model or is declared in \"includes\".\n        // If not, it means that has not been selected anywhere and that will cause an error on the API\n        if (k !== s.model && !s.includes.includes(k)) {\n          throw new UnselectableModelError(k);\n        }\n\n        Object.assign(f, { [`${this._options.fields}[${k}]`]: s.fields[k].join(',') });\n      }\n    }\n\n    const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;\n    this._uri += param;\n\n    return param;\n  }\n\n  private _parseFilters(s: IQueryBuilderState): string {\n    const keys = Object.keys(s.filters);\n\n    if (!keys.length) {\n      return this._uri;\n    }\n\n    const f = {\n      [`${this._options.filters}`]: keys.reduce((acc, key) => {\n        return Object.assign(acc, { [key]: s.filters[key].join(',') });\n      }, {})\n    };\n    const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;\n\n    this._uri += param;\n\n    return param;\n  }\n\n  private _parseIncludes(s: IQueryBuilderState): string {\n    if (!s.includes.length) {\n      return this._uri;\n    }\n\n    const param = `${this._prepend(s.model)}${this._options.includes}=${s.includes}`;\n    this._uri += param;\n\n    return param;\n  }\n\n  private _parseLimit(s: IQueryBuilderState): string {\n    const param = `${this._prepend(s.model)}${this._options.limit}=${s.limit}`;\n    this._uri += param;\n\n    return param;\n  }\n\n  private _parsePage(s: IQueryBuilderState): string {\n    const param = `${this._prepend(s.model)}${this._options.page}=${s.page}`;\n    this._uri += param;\n\n    return param;\n  }\n\n  private _parseSort(s: IQueryBuilderState): string {\n    let param: string = '';\n\n    if (!s.sorts.length) {\n      return param;\n    }\n\n    param = `${this._prepend(s.model)}${this._options.sort}=`;\n\n    s.sorts.forEach((sort, idx) => {\n      param += `${sort.order === SortEnum.DESC ? '-' : ''}${sort.field}`;\n\n      if (idx < s.sorts.length - 1) {\n        param += ','\n      }\n    });\n\n    this._uri += param;\n\n    return param;\n  }\n\n  private _parse(s: IQueryBuilderState): string {\n    if (!s.model) {\n      throw new Error('Set the model property BEFORE adding filters or calling the url() / get() methods');\n    }\n\n    // Cleanup the previously generated URI\n    this._uri = '';\n\n    this._parseIncludes(s);\n    this._parseFields(s);\n    this._parseFilters(s);\n    this._parseLimit(s);\n    this._parsePage(s);\n    this._parseSort(s);\n\n    return this._uri;\n  }\n\n  private _prepend(model: string): string {\n    return this._uri ? '&' : `/${model}?`;\n  }\n\n  // private _removeArgIfEmpty(arg: string): string {\n  //   const params = new URL(this._uri).searchParams;\n    \n  //   if (!params.get(arg)) {\n  //     params.delete(arg);\n  //   }\n    \n\n  // }\n\n  /**\n   * Add fields to the select statement for the given model\n   * \n   * @param model Model that holds the fields\n   * @param fields Fields to select\n   * @returns {this}\n   */\n  public addFields(model: string, fields: string[]): this {\n    if (!fields.length) {\n      return this;\n    }\n\n    this._nestService.addFields({ [model]: fields });\n\n    return this;\n  }\n\n  /**\n   * Add a filter with the given value(s)\n   *  I.e. filter[field]=1 or filter[field]=1,2,3\n   * \n   * @param {string} field Name of the field to filter\n   * @param {string[]} value The needle(s)\n   * @returns {this}\n   */\n  public addFilter(field: string, ...values: (string | number | boolean)[]): this {\n    if (!values.length) {\n      return this;\n    }\n\n    this._nestService.addFilters({\n      [field]: values\n    });\n\n    return this;\n  }\n\n  /**\n   * Add related entities to include in the request\n   * \n   * @param {string[]} models \n   * @returns \n   */\n  public addIncludes(...models: string[]): this {\n    if (!models.length) {\n      return this;\n    }\n\n    this._nestService.addIncludes(models);\n\n    return this;\n  }\n\n  /**\n   * Add a field with a sort criteria\n   * \n   * @param field Field to use for sorting\n   * @param {SortEnum} order A value from the SortEnum enumeration\n   * @returns {this}\n   */\n  public addSort(field: string, order: SortEnum): this {\n    this._nestService.addSort({\n      field,\n      order\n    });\n\n    return this;\n  }\n\n  /**\n   * Delete selected fields for the given models in the current query builder state\n   * \n   * ```\n   * ngQubeeService.deleteFields({\n   *   users: ['email', 'password'],\n   *   address: ['zipcode']\n   * });\n   * ```\n   * \n   * @param {IFields} fields \n   * @returns \n   */\n  public deleteFields(fields: IFields): this {\n    this._nestService.deleteFields(fields);\n    return this;\n  }\n\n  /**\n   * Delete selected fields for the given model in the current query builder state\n   * \n   * ```\n   * ngQubeeService.deleteFieldsByModel('users', 'email', 'password']);\n   * ```\n   * \n   * @param model Model that holds the fields\n   * @param {string[]} fields Fields to delete from the state\n   * @returns {this}\n   */\n  public deleteFieldsByModel(model: string, ...fields: string[]): this {\n    if (!fields.length) {\n      return this;\n    }\n\n    this._nestService.deleteFields({\n      [model]: fields\n    });\n\n    return this;\n  }\n\n  /**\n   * Remove given filters from the query builder state\n   * \n   * @param {string[]} filters Filters to remove\n   * @returns {this}\n   */\n  public deleteFilters(...filters: string[]): this {\n    if (!filters.length) {\n      return this;\n    }\n\n    this._nestService.deleteFilters(...filters);\n\n    return this;\n  }\n\n  /**\n   * Remove selected related models from the query builder state\n   * \n   * @param {string[]} includes Models to remove\n   * @returns \n   */\n  public deleteIncludes(...includes: string[]): this {\n    if (!includes.length) {\n      return this;\n    }\n\n    this._nestService.deleteIncludes(...includes);\n\n    return this;\n  }\n\n  /**\n   * Remove sorts rules from the query builder state\n   * \n   * @param sorts Fields used for sorting to remove\n   * @returns {this}\n   */\n  public deleteSorts(...sorts: string[]): this {\n    this._nestService.deleteSorts(...sorts);\n    return this;\n  }\n\n  /**\n   * Generate an URI accordingly to the given data\n   *\n   * @returns {Observable<string>} An observable that emits the generated uri\n   */\n  public generateUri(): Observable<string> {\n    this._uri$.next(this._parse(this._nestService.nest()));\n    return this.uri$;\n  }\n\n  /**\n   * Clear the current state and reset the Query Builder to a fresh, clean condition\n   * \n   * @returns {this}\n   */\n  public reset(): this {\n    this._nestService.reset();\n    return this;\n  }\n\n  /**\n   * Set the base url to use for composing the address\n   * \n   * @param {string} baseUrl \n   * @returns {this}\n   */\n  public setBaseUrl(baseUrl: string): this {\n    this._nestService.baseUrl = baseUrl;\n    return this;\n  }\n\n  /**\n   * Set the items per page number\n   * \n   * @param limit \n   * @returns {this}\n   */\n  public setLimit(limit: number): this {\n    this._nestService.limit = limit;\n    return this;\n  }\n\n  /**\n   * Set the model to use for running the query against\n   *   - I.e. the model \"users\" will return /users\n   * \n   * @param {string} model Model name\n   * @returns {this}\n   */\n  public setModel(model: string): this {\n    this._nestService.model = model;\n    return this;\n  }\n\n  /**\n   * Set the page that the backend will use to paginate the result set\n   * \n   * @param page Page param\n   * @returns {this}\n   */\n  public setPage(page: number): this {\n    this._nestService.page = page;\n    return this;\n  }\n}\n"]}

package/esm2022/lib/services/pagination.service.mjs

@@ -0,0 +1,23 @@
+import { Inject, Injectable, Optional } from "@angular/core";
+import { PaginatedCollection } from "../models/paginated-collection";
+import { ResponseOptions } from "../models/response-options";
+import * as i0 from "@angular/core";
+export class PaginationService {
+    constructor(options = {}) {
+        this._options = new ResponseOptions(options);
+    }
+    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 }); }
+}
+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
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ng-qubee.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctcXViZWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZy1xdWJlZS9zcmMvbmctcXViZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,9 @@
+/*
+ * Public API Surface of angular-query-builder
+ */
+export * from './lib/models/paginated-collection';
+export * from './lib/ng-qubee.module';
+export * from './lib/provide-ngqubee';
+export * from './lib/services/ng-qubee.service';
+export * from './lib/services/pagination.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25nLXF1YmVlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBhbmd1bGFyLXF1ZXJ5LWJ1aWxkZXJcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvcGFnaW5hdGVkLWNvbGxlY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctcXViZWUubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Byb3ZpZGUtbmdxdWJlZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9uZy1xdWJlZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3BhZ2luYXRpb24uc2VydmljZSc7XG4iXX0=