ng-qubee 1.0.9 → 2.0.2

package/fesm2022/ng-qubee.mjs

@@ -0,0 +1,678 @@
+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 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 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;
+            }, [])
+        };
+    }
+}
+
+var SortEnum;
+(function (SortEnum) {
+    SortEnum["ASC"] = "asc";
+    SortEnum["DESC"] = "desc";
+})(SortEnum || (SortEnum = {}));
+
+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 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: {},
+    includes: [],
+    limit: 15,
+    model: '',
+    page: 1,
+    sorts: []
+};
+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: () => [] });
+
+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: 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: NestService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['QUERY_PARAMS_CONFIG']
+                }, {
+                    type: Optional
+                }] }] });
+
+class ResponseOptions {
+    constructor(options) {
+        this.currentPage = options.currentPage || 'current_page';
+        this.data = options.data || 'data';
+        this.firstPageUrl = options.firstPageUrl || 'first_page_url';
+        this.from = options.from || 'from';
+        this.lastPage = options.lastPage || 'last_page';
+        this.lastPageUrl = options.lastPageUrl || 'last_page_url';
+        this.nextPageUrl = options.nextPageUrl || 'next_page_url';
+        this.path = options.path || 'path';
+        this.perPage = options.perPage || 'per_page';
+        this.prevPageUrl = options.prevPageUrl || 'prev_page_url';
+        this.to = options.to || 'to';
+        this.total = options.total || 'total';
+    }
+}
+
+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
+                }] }] });
+
+// @dynamic
+class NgQubeeModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: NgQubeeModule,
+            providers: [
+                NestService,
+                {
+                    deps: [NestService],
+                    provide: NgQubeeService,
+                    useFactory: (nestService) => new NgQubeeService(nestService, Object.assign({}, config.request))
+                }, {
+                    provide: PaginationService,
+                    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))
+        }
+    ]);
+}
+
+/*
+ * Public API Surface of angular-query-builder
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationService, provideNgQubee };
+//# sourceMappingURL=ng-qubee.mjs.map