@alfresco/adf-content-services 8.1.0-15972188736 → 8.1.0-15979090800

package/esm2022/lib/search/services/base-query-builder.service.mjs

@@ -0,0 +1,509 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BehaviorSubject, from, ReplaySubject, Subject } from 'rxjs';
+import { SEARCH_LANGUAGE, SearchApi } from '@alfresco/js-api';
+import { Buffer } from 'buffer';
+import { inject } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+export class BaseQueryBuilderService {
+    get searchApi() {
+        this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());
+        return this._searchApi;
+    }
+    get userQuery() {
+        return this._userQuery;
+    }
+    set userQuery(value) {
+        value = (value || '').trim();
+        this._userQuery = value ? `(${value})` : '';
+    }
+    constructor(appConfig, alfrescoApiService) {
+        this.appConfig = appConfig;
+        this.alfrescoApiService = alfrescoApiService;
+        this.router = inject(Router);
+        this.activatedRoute = inject(ActivatedRoute);
+        /*  Stream that emits the search configuration whenever the user change the search forms */
+        this.configUpdated = new Subject();
+        /*  Stream that emits the event each time when search filter finishes loading initial value */
+        this.filterLoaded = new Subject();
+        /*  Stream that emits the query before search whenever user search  */
+        this.updated = new Subject();
+        /*  Stream that emits the results whenever user search  */
+        this.executed = new Subject();
+        /*  Stream that emits the error whenever user search  */
+        this.error = new Subject();
+        /*  Stream that emits search forms  */
+        this.searchForms = new ReplaySubject(1);
+        /*  Stream that emits void when change in filterQueries  */
+        this.filterQueryUpdate = new Subject();
+        /*  Stream that emits the initial value for some or all search filters */
+        this.populateFilters = new BehaviorSubject({});
+        this.categories = [];
+        this.queryFragments = {};
+        this.filterQueries = [];
+        this.filterRawParams = {};
+        this.paging = null;
+        this.sorting = [];
+        this.sortingOptions = [];
+        this._userQuery = '';
+        this.userFacetBuckets = {};
+        this.config = {
+            categories: []
+        };
+        // TODO: to be supported in future iterations
+        this.ranges = {};
+        this.resetToDefaults();
+    }
+    resetToDefaults(withNavigate = false) {
+        if (withNavigate) {
+            this.router.navigate([], {
+                queryParams: { q: null },
+                relativeTo: this.activatedRoute,
+                queryParamsHandling: 'merge'
+            });
+        }
+        const currentConfig = this.getDefaultConfiguration();
+        this.resetSearchOptions();
+        this.configUpdated.next(currentConfig);
+        this.searchForms.next(this.getSearchFormDetails());
+        this.setUpSearchConfiguration(currentConfig);
+    }
+    getDefaultConfiguration() {
+        const configurations = this.loadConfiguration();
+        if (Array.isArray(configurations)) {
+            if (this.selectedConfiguration !== undefined) {
+                return configurations[this.selectedConfiguration];
+            }
+            return configurations.find((configuration) => configuration.default);
+        }
+        return configurations;
+    }
+    updateSelectedConfiguration(index) {
+        const currentConfig = this.loadConfiguration();
+        if (Array.isArray(currentConfig) && currentConfig[index] !== undefined) {
+            this.selectedConfiguration = index;
+            this.configUpdated.next(currentConfig[index]);
+            this.searchForms.next(this.getSearchFormDetails());
+            this.resetSearchOptions();
+            this.setUpSearchConfiguration(currentConfig[index]);
+            this.update();
+        }
+    }
+    resetSearchOptions() {
+        this.categories = [];
+        this.queryFragments = {};
+        this.filterQueries = [];
+        this.sorting = [];
+        this.sortingOptions = [];
+        this.userFacetBuckets = {};
+        this.scope = null;
+        this.filterRawParams = {};
+        this._userQuery = '';
+        this.populateFilters.next({});
+    }
+    getSearchFormDetails() {
+        const configurations = this.loadConfiguration();
+        if (Array.isArray(configurations)) {
+            return configurations.map((configuration, index) => ({
+                index,
+                name: configuration.name || 'SEARCH.UNKNOWN_CONFIGURATION',
+                default: configuration.default || false,
+                selected: this.selectedConfiguration !== undefined ? index === this.selectedConfiguration : configuration.default
+            }));
+        }
+        else if (configurations) {
+            return [
+                {
+                    index: 0,
+                    name: configurations.name || 'SEARCH.UNKNOWN_CONFIGURATION',
+                    default: true,
+                    selected: true
+                }
+            ];
+        }
+        return [];
+    }
+    setUpSearchConfiguration(currentConfiguration) {
+        if (currentConfiguration) {
+            this.config = JSON.parse(JSON.stringify(currentConfiguration));
+            this.categories = (this.config.categories || []).filter((category) => category.enabled);
+            this.filterQueries = this.config.filterQueries || [];
+            this.userFacetBuckets = {};
+            if (this.config.sorting) {
+                this.sorting = this.config.sorting.defaults || [];
+                this.sortingOptions = this.config.sorting.options || [];
+            }
+        }
+    }
+    /**
+     * Adds a facet bucket to a field.
+     *
+     * @param field The target field
+     * @param bucket Bucket to add
+     */
+    addUserFacetBucket(field, bucket) {
+        if (field && bucket) {
+            const buckets = this.userFacetBuckets[field] || [];
+            const existing = buckets.find((facetBucket) => facetBucket.label === bucket.label);
+            if (!existing) {
+                buckets.push(bucket);
+            }
+            this.userFacetBuckets[field] = buckets;
+        }
+    }
+    /**
+     * Gets the buckets currently added to a field
+     *
+     * @param field The target fields
+     * @returns Bucket array
+     */
+    getUserFacetBuckets(field) {
+        return this.userFacetBuckets[field] || [];
+    }
+    /**
+     * Removes an existing bucket from a field.
+     *
+     * @param field The target field
+     * @param bucket Bucket to remove
+     */
+    removeUserFacetBucket(field, bucket) {
+        if (field && bucket) {
+            const buckets = this.userFacetBuckets[field] || [];
+            this.userFacetBuckets[field] = buckets.filter((facetBucket) => facetBucket.label !== bucket.label);
+        }
+    }
+    /**
+     * Adds a filter query to the current query.
+     *
+     * @param query Query string to add
+     */
+    addFilterQuery(query) {
+        if (query) {
+            const existing = this.filterQueries.find((filterQuery) => filterQuery.query === query);
+            if (!existing) {
+                this.filterQueries.push({ query });
+                this.filterQueryUpdate.next();
+            }
+        }
+    }
+    /**
+     * Removes an existing filter query.
+     *
+     * @param query The query to remove
+     */
+    removeFilterQuery(query) {
+        if (query) {
+            this.filterQueries = this.filterQueries.filter((filterQuery) => filterQuery.query !== query);
+            this.filterQueryUpdate.next();
+        }
+    }
+    /**
+     * Gets a facet query by label.
+     *
+     * @param label Label of the query
+     * @returns Facet query data
+     */
+    getFacetQuery(label) {
+        if (label && this.hasFacetQueries) {
+            const result = this.config.facetQueries.queries.find((query) => query.label === label);
+            if (result) {
+                return { ...result };
+            }
+        }
+        return null;
+    }
+    /**
+     * Gets a facet field by label.
+     *
+     * @param label Label of the facet field
+     * @returns Facet field data
+     */
+    getFacetField(label) {
+        if (label) {
+            const fields = this.config.facetFields.fields || [];
+            const result = fields.find((field) => field.label === label);
+            if (result) {
+                result.label = this.getSupportedLabel(result.label);
+                return { ...result };
+            }
+        }
+        return null;
+    }
+    setScope(scope) {
+        this.scope = scope;
+    }
+    getScope() {
+        return this.scope;
+    }
+    /**
+     * Builds the current query and triggers the `updated` event.
+     *
+     * @param queryBody query settings
+     */
+    update(queryBody) {
+        const query = queryBody ? queryBody : this.buildQuery();
+        this.updated.next(query);
+    }
+    /**
+     * Builds and executes the current query.
+     *
+     * @param updateQueryParams whether query params should be updated with encoded query
+     * @param queryBody query settings
+     */
+    async execute(updateQueryParams = true, queryBody) {
+        try {
+            const query = queryBody ? queryBody : this.buildQuery();
+            if (query) {
+                if (updateQueryParams) {
+                    this.updateSearchQueryParams();
+                }
+                const resultSetPaging = await this.searchApi.search(query);
+                this.executed.next(resultSetPaging);
+            }
+        }
+        catch (error) {
+            this.error.next(error);
+            this.executed.next({
+                list: {
+                    pagination: {
+                        totalItems: 0
+                    },
+                    entries: []
+                }
+            });
+        }
+    }
+    search(queryBody) {
+        const promise = this.searchApi.search(queryBody);
+        promise.then((resultSetPaging) => {
+            this.executed.next(resultSetPaging);
+        });
+        return from(promise);
+    }
+    /**
+     * Builds the current query.
+     *
+     * @returns The finished query
+     */
+    buildQuery() {
+        const query = this.getFinalQuery();
+        const include = this.config.include || [];
+        if (include.length === 0) {
+            include.push('path', 'allowableOperations');
+        }
+        if (query) {
+            const result = {
+                query: {
+                    query,
+                    language: SEARCH_LANGUAGE.AFTS
+                },
+                include,
+                paging: this.paging,
+                fields: this.config.fields,
+                filterQueries: this.filterQueries,
+                facetQueries: this.facetQueries,
+                facetIntervals: this.facetIntervals,
+                facetFields: this.facetFields,
+                sort: this.sort,
+                highlight: this.highlight
+            };
+            if (this.scope) {
+                result.scope = this.scope;
+            }
+            result['facetFormat'] = 'V2';
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Gets the primary sorting definition.
+     *
+     * @returns The primary sorting definition
+     */
+    getPrimarySorting() {
+        if (this.sorting?.length > 0) {
+            return this.sorting[0];
+        }
+        return null;
+    }
+    /**
+     * Gets all pre-configured sorting options that users can choose from.
+     *
+     * @returns Pre-configured sorting options
+     */
+    getSortingOptions() {
+        return this.config?.sorting?.options || [];
+    }
+    /**
+     * Gets the query group.
+     *
+     * @param query Target query
+     * @returns Query group
+     */
+    getQueryGroup(query) {
+        return query.group || this.config.facetQueries.label || 'Facet Queries';
+    }
+    /**
+     * Checks if FacetQueries has been defined
+     *
+     * @returns True if defined, false otherwise
+     */
+    get hasFacetQueries() {
+        return this.config?.facetQueries?.queries?.length > 0;
+    }
+    /**
+     * Checks if FacetIntervals has been defined
+     *
+     * @returns True if defined, false otherwise
+     */
+    get hasFacetIntervals() {
+        return this.config?.facetIntervals?.intervals?.length > 0;
+    }
+    get hasFacetHighlight() {
+        return !!this.config?.highlight;
+    }
+    get sort() {
+        return this.sorting.map((def) => ({
+            type: def.type,
+            field: def.field,
+            ascending: def.ascending
+        }));
+    }
+    get facetQueries() {
+        if (this.hasFacetQueries) {
+            return this.config.facetQueries.queries.map((query) => {
+                query.group = this.getQueryGroup(query);
+                return { ...query };
+            });
+        }
+        return null;
+    }
+    get facetIntervals() {
+        if (this.hasFacetIntervals) {
+            const configIntervals = this.config.facetIntervals;
+            return {
+                intervals: configIntervals.intervals.map((interval) => ({
+                    label: this.getSupportedLabel(interval.label),
+                    field: interval.field,
+                    sets: interval.sets.map((set) => ({
+                        label: this.getSupportedLabel(set.label),
+                        start: set.start,
+                        end: set.end,
+                        startInclusive: set.startInclusive,
+                        endInclusive: set.endInclusive
+                    }))
+                }))
+            };
+        }
+        return null;
+    }
+    get highlight() {
+        return this.hasFacetHighlight ? this.config.highlight : null;
+    }
+    getFinalQuery() {
+        let query = '';
+        if (this.userQuery) {
+            this.filterRawParams['userQuery'] = this.userQuery;
+        }
+        this.categories.forEach((facet) => {
+            const customQuery = this.queryFragments[facet.id];
+            if (customQuery) {
+                if (query.length > 0) {
+                    query += ' AND ';
+                }
+                query += `(${customQuery})`;
+            }
+        });
+        let result = [this.userQuery, query].filter((entry) => entry).join(' AND ');
+        if (this.userFacetBuckets) {
+            Object.keys(this.userFacetBuckets).forEach((key) => {
+                const subQuery = (this.userFacetBuckets[key] || [])
+                    .filter((bucket) => bucket.filterQuery)
+                    .map((bucket) => bucket.filterQuery)
+                    .join(' OR ');
+                if (subQuery) {
+                    if (result.length > 0) {
+                        result += ' AND ';
+                    }
+                    result += `(${subQuery})`;
+                }
+            });
+        }
+        return result;
+    }
+    get facetFields() {
+        const facetFields = this.config.facetFields?.fields;
+        if (facetFields?.length > 0) {
+            return {
+                facets: facetFields.map((facet) => ({
+                    field: facet.field,
+                    mincount: facet.mincount,
+                    label: this.getSupportedLabel(facet.label),
+                    limit: facet.limit,
+                    offset: facet.offset,
+                    prefix: facet.prefix
+                }))
+            };
+        }
+        return null;
+    }
+    /**
+     * Encloses a label name with double quotes if it contains whitespace characters.
+     *
+     * @param configLabel Original label text
+     * @returns Label, possibly with quotes if it contains spaces
+     */
+    getSupportedLabel(configLabel) {
+        const spaceInsideLabelIndex = configLabel.search(/\s/g);
+        if (spaceInsideLabelIndex > -1) {
+            return `"${configLabel}"`;
+        }
+        return configLabel;
+    }
+    /**
+     * Encodes filter configuration stored in filterRawParams object.
+     */
+    encodeQuery() {
+        this.encodedQuery = Buffer.from(JSON.stringify(this.filterRawParams)).toString('base64');
+    }
+    /**
+     * Encodes existing filters configuration and updates search query param value.
+     */
+    updateSearchQueryParams() {
+        this.encodeQuery();
+        this.router.navigate([], {
+            relativeTo: this.activatedRoute,
+            queryParams: { q: this.encodedQuery },
+            queryParamsHandling: 'merge'
+        });
+    }
+    /**
+     * Builds search query with provided user query, executes query, encodes latest filter config and navigates to search.
+     *
+     * @param query user query to search for
+     * @param searchUrl search url to navigate to
+     */
+    async navigateToSearch(query, searchUrl) {
+        this.userQuery = query;
+        await this.execute();
+        await this.router.navigate([searchUrl], {
+            queryParams: { q: this.encodedQuery },
+            queryParamsHandling: 'merge'
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-query-builder.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/search/services/base-query-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { BehaviorSubject, from, Observable, ReplaySubject, Subject } from 'rxjs';\nimport { AppConfigService } from '@alfresco/adf-core';\nimport {\n    RequestFacetFields,\n    RequestHighlight,\n    RequestScope,\n    RequestSortDefinitionInner,\n    ResultSetPaging,\n    SEARCH_LANGUAGE,\n    SearchApi,\n    SearchRequest\n} from '@alfresco/js-api';\nimport { SearchCategory } from '../models/search-category.interface';\nimport { FilterQuery } from '../models/filter-query.interface';\nimport { SearchRange } from '../models/search-range.interface';\nimport { SearchConfiguration } from '../models/search-configuration.interface';\nimport { FacetQuery } from '../models/facet-query.interface';\nimport { SearchSortingDefinition } from '../models/search-sorting-definition.interface';\nimport { FacetField } from '../models/facet-field.interface';\nimport { FacetFieldBucket } from '../models/facet-field-bucket.interface';\nimport { SearchForm } from '../models/search-form.interface';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport { Buffer } from 'buffer';\nimport { inject } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\n\nexport abstract class BaseQueryBuilderService {\n    private readonly router = inject(Router);\n    private readonly activatedRoute = inject(ActivatedRoute);\n    private _searchApi: SearchApi;\n    get searchApi(): SearchApi {\n        this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());\n        return this._searchApi;\n    }\n\n    /*  Stream that emits the search configuration whenever the user change the search forms */\n    configUpdated = new Subject<SearchConfiguration>();\n\n    /*  Stream that emits the event each time when search filter finishes loading initial value */\n    filterLoaded = new Subject<void>();\n\n    /*  Stream that emits the query before search whenever user search  */\n    updated = new Subject<SearchRequest>();\n\n    /*  Stream that emits the results whenever user search  */\n    executed = new Subject<ResultSetPaging>();\n\n    /*  Stream that emits the error whenever user search  */\n    error = new Subject();\n\n    /*  Stream that emits search forms  */\n    searchForms = new ReplaySubject<SearchForm[]>(1);\n\n    /*  Stream that emits void when change in filterQueries  */\n    filterQueryUpdate = new Subject<void>();\n\n    /*  Stream that emits the initial value for some or all search filters */\n    populateFilters = new BehaviorSubject<{ [key: string]: any }>({});\n\n    categories: SearchCategory[] = [];\n    queryFragments: { [id: string]: string } = {};\n    filterQueries: FilterQuery[] = [];\n    filterRawParams: { [key: string]: any } = {};\n    paging: { maxItems?: number; skipCount?: number } = null;\n    sorting: SearchSortingDefinition[] = [];\n    sortingOptions: SearchSortingDefinition[] = [];\n    private encodedQuery: string;\n    private scope: RequestScope;\n    private selectedConfiguration: number;\n    private _userQuery = '';\n\n    protected userFacetBuckets: { [key: string]: FacetFieldBucket[] } = {};\n\n    get userQuery(): string {\n        return this._userQuery;\n    }\n\n    set userQuery(value: string) {\n        value = (value || '').trim();\n        this._userQuery = value ? `(${value})` : '';\n    }\n\n    config: SearchConfiguration = {\n        categories: []\n    };\n\n    // TODO: to be supported in future iterations\n    ranges: { [id: string]: SearchRange } = {};\n\n    protected constructor(protected readonly appConfig: AppConfigService, protected readonly alfrescoApiService: AlfrescoApiService) {\n        this.resetToDefaults();\n    }\n\n    public abstract loadConfiguration(): SearchConfiguration | SearchConfiguration[];\n\n    public abstract isFilterServiceActive(): boolean;\n\n    public resetToDefaults(withNavigate = false) {\n        if (withNavigate) {\n            this.router.navigate([], {\n                queryParams: { q: null },\n                relativeTo: this.activatedRoute,\n                queryParamsHandling: 'merge'\n            });\n        }\n        const currentConfig = this.getDefaultConfiguration();\n        this.resetSearchOptions();\n        this.configUpdated.next(currentConfig);\n        this.searchForms.next(this.getSearchFormDetails());\n        this.setUpSearchConfiguration(currentConfig);\n    }\n\n    public getDefaultConfiguration(): SearchConfiguration | undefined {\n        const configurations = this.loadConfiguration();\n\n        if (Array.isArray(configurations)) {\n            if (this.selectedConfiguration !== undefined) {\n                return configurations[this.selectedConfiguration];\n            }\n\n            return configurations.find((configuration) => configuration.default);\n        }\n        return configurations;\n    }\n\n    public updateSelectedConfiguration(index: number): void {\n        const currentConfig = this.loadConfiguration();\n        if (Array.isArray(currentConfig) && currentConfig[index] !== undefined) {\n            this.selectedConfiguration = index;\n            this.configUpdated.next(currentConfig[index]);\n            this.searchForms.next(this.getSearchFormDetails());\n            this.resetSearchOptions();\n            this.setUpSearchConfiguration(currentConfig[index]);\n            this.update();\n        }\n    }\n\n    private resetSearchOptions(): void {\n        this.categories = [];\n        this.queryFragments = {};\n        this.filterQueries = [];\n        this.sorting = [];\n        this.sortingOptions = [];\n        this.userFacetBuckets = {};\n        this.scope = null;\n        this.filterRawParams = {};\n        this._userQuery = '';\n        this.populateFilters.next({});\n    }\n\n    public getSearchFormDetails(): SearchForm[] {\n        const configurations = this.loadConfiguration();\n        if (Array.isArray(configurations)) {\n            return configurations.map((configuration, index) => ({\n                index,\n                name: configuration.name || 'SEARCH.UNKNOWN_CONFIGURATION',\n                default: configuration.default || false,\n                selected: this.selectedConfiguration !== undefined ? index === this.selectedConfiguration : configuration.default\n            }));\n        } else if (configurations) {\n            return [\n                {\n                    index: 0,\n                    name: configurations.name || 'SEARCH.UNKNOWN_CONFIGURATION',\n                    default: true,\n                    selected: true\n                }\n            ];\n        }\n        return [];\n    }\n\n    private setUpSearchConfiguration(currentConfiguration: SearchConfiguration) {\n        if (currentConfiguration) {\n            this.config = JSON.parse(JSON.stringify(currentConfiguration));\n            this.categories = (this.config.categories || []).filter((category) => category.enabled);\n            this.filterQueries = this.config.filterQueries || [];\n            this.userFacetBuckets = {};\n            if (this.config.sorting) {\n                this.sorting = this.config.sorting.defaults || [];\n                this.sortingOptions = this.config.sorting.options || [];\n            }\n        }\n    }\n\n    /**\n     * Adds a facet bucket to a field.\n     *\n     * @param field The target field\n     * @param bucket Bucket to add\n     */\n    addUserFacetBucket(field: string, bucket: FacetFieldBucket) {\n        if (field && bucket) {\n            const buckets = this.userFacetBuckets[field] || [];\n            const existing = buckets.find((facetBucket) => facetBucket.label === bucket.label);\n            if (!existing) {\n                buckets.push(bucket);\n            }\n            this.userFacetBuckets[field] = buckets;\n        }\n    }\n\n    /**\n     * Gets the buckets currently added to a field\n     *\n     * @param field The target fields\n     * @returns Bucket array\n     */\n    getUserFacetBuckets(field: string) {\n        return this.userFacetBuckets[field] || [];\n    }\n\n    /**\n     * Removes an existing bucket from a field.\n     *\n     * @param field The target field\n     * @param bucket Bucket to remove\n     */\n    removeUserFacetBucket(field: string, bucket: FacetFieldBucket) {\n        if (field && bucket) {\n            const buckets = this.userFacetBuckets[field] || [];\n            this.userFacetBuckets[field] = buckets.filter((facetBucket) => facetBucket.label !== bucket.label);\n        }\n    }\n\n    /**\n     * Adds a filter query to the current query.\n     *\n     * @param query Query string to add\n     */\n    addFilterQuery(query: string): void {\n        if (query) {\n            const existing = this.filterQueries.find((filterQuery) => filterQuery.query === query);\n            if (!existing) {\n                this.filterQueries.push({ query });\n                this.filterQueryUpdate.next();\n            }\n        }\n    }\n\n    /**\n     * Removes an existing filter query.\n     *\n     * @param query The query to remove\n     */\n    removeFilterQuery(query: string): void {\n        if (query) {\n            this.filterQueries = this.filterQueries.filter((filterQuery) => filterQuery.query !== query);\n            this.filterQueryUpdate.next();\n        }\n    }\n\n    /**\n     * Gets a facet query by label.\n     *\n     * @param label Label of the query\n     * @returns Facet query data\n     */\n    getFacetQuery(label: string): FacetQuery {\n        if (label && this.hasFacetQueries) {\n            const result = this.config.facetQueries.queries.find((query) => query.label === label);\n            if (result) {\n                return { ...result };\n            }\n        }\n        return null;\n    }\n\n    /**\n     * Gets a facet field by label.\n     *\n     * @param label Label of the facet field\n     * @returns Facet field data\n     */\n    getFacetField(label: string): FacetField {\n        if (label) {\n            const fields = this.config.facetFields.fields || [];\n            const result = fields.find((field) => field.label === label);\n            if (result) {\n                result.label = this.getSupportedLabel(result.label);\n                return { ...result };\n            }\n        }\n        return null;\n    }\n\n    setScope(scope: RequestScope) {\n        this.scope = scope;\n    }\n\n    getScope(): RequestScope {\n        return this.scope;\n    }\n\n    /**\n     * Builds the current query and triggers the `updated` event.\n     *\n     * @param queryBody query settings\n     */\n    update(queryBody?: SearchRequest): void {\n        const query = queryBody ? queryBody : this.buildQuery();\n        this.updated.next(query);\n    }\n\n    /**\n     * Builds and executes the current query.\n     *\n     * @param updateQueryParams whether query params should be updated with encoded query\n     * @param queryBody query settings\n     */\n    async execute(updateQueryParams = true, queryBody?: SearchRequest) {\n        try {\n            const query = queryBody ? queryBody : this.buildQuery();\n            if (query) {\n                if (updateQueryParams) {\n                    this.updateSearchQueryParams();\n                }\n                const resultSetPaging: ResultSetPaging = await this.searchApi.search(query);\n                this.executed.next(resultSetPaging);\n            }\n        } catch (error) {\n            this.error.next(error);\n\n            this.executed.next({\n                list: {\n                    pagination: {\n                        totalItems: 0\n                    },\n                    entries: []\n                }\n            });\n        }\n    }\n\n    search(queryBody: SearchRequest): Observable<ResultSetPaging> {\n        const promise = this.searchApi.search(queryBody);\n\n        promise.then((resultSetPaging) => {\n            this.executed.next(resultSetPaging);\n        });\n\n        return from(promise);\n    }\n\n    /**\n     * Builds the current query.\n     *\n     * @returns The finished query\n     */\n    buildQuery(): SearchRequest {\n        const query = this.getFinalQuery();\n\n        const include = this.config.include || [];\n        if (include.length === 0) {\n            include.push('path', 'allowableOperations');\n        }\n\n        if (query) {\n            const result: SearchRequest = {\n                query: {\n                    query,\n                    language: SEARCH_LANGUAGE.AFTS\n                },\n                include,\n                paging: this.paging,\n                fields: this.config.fields,\n                filterQueries: this.filterQueries,\n                facetQueries: this.facetQueries,\n                facetIntervals: this.facetIntervals,\n                facetFields: this.facetFields,\n                sort: this.sort,\n                highlight: this.highlight\n            };\n\n            if (this.scope) {\n                result.scope = this.scope;\n            }\n\n            result['facetFormat'] = 'V2';\n            return result;\n        }\n\n        return null;\n    }\n\n    /**\n     * Gets the primary sorting definition.\n     *\n     * @returns The primary sorting definition\n     */\n    getPrimarySorting(): SearchSortingDefinition {\n        if (this.sorting?.length > 0) {\n            return this.sorting[0];\n        }\n        return null;\n    }\n\n    /**\n     * Gets all pre-configured sorting options that users can choose from.\n     *\n     * @returns Pre-configured sorting options\n     */\n    getSortingOptions(): SearchSortingDefinition[] {\n        return this.config?.sorting?.options || [];\n    }\n\n    /**\n     * Gets the query group.\n     *\n     * @param query Target query\n     * @returns Query group\n     */\n    getQueryGroup(query: FacetQuery): string {\n        return query.group || this.config.facetQueries.label || 'Facet Queries';\n    }\n\n    /**\n     * Checks if FacetQueries has been defined\n     *\n     * @returns True if defined, false otherwise\n     */\n    get hasFacetQueries(): boolean {\n        return this.config?.facetQueries?.queries?.length > 0;\n    }\n\n    /**\n     * Checks if FacetIntervals has been defined\n     *\n     * @returns True if defined, false otherwise\n     */\n    get hasFacetIntervals(): boolean {\n        return this.config?.facetIntervals?.intervals?.length > 0;\n    }\n\n    get hasFacetHighlight(): boolean {\n        return !!this.config?.highlight;\n    }\n\n    protected get sort(): RequestSortDefinitionInner[] {\n        return this.sorting.map((def) => ({\n            type: def.type,\n            field: def.field,\n            ascending: def.ascending\n        }));\n    }\n\n    protected get facetQueries(): FacetQuery[] {\n        if (this.hasFacetQueries) {\n            return this.config.facetQueries.queries.map((query) => {\n                query.group = this.getQueryGroup(query);\n                return { ...query };\n            });\n        }\n\n        return null;\n    }\n\n    protected get facetIntervals(): any {\n        if (this.hasFacetIntervals) {\n            const configIntervals = this.config.facetIntervals;\n\n            return {\n                intervals: configIntervals.intervals.map(\n                    (interval) =>\n                        ({\n                            label: this.getSupportedLabel(interval.label),\n                            field: interval.field,\n                            sets: interval.sets.map(\n                                (set) =>\n                                    ({\n                                        label: this.getSupportedLabel(set.label),\n                                        start: set.start,\n                                        end: set.end,\n                                        startInclusive: set.startInclusive,\n                                        endInclusive: set.endInclusive\n                                    } as any)\n                            )\n                        } as any)\n                )\n            };\n        }\n\n        return null;\n    }\n\n    protected get highlight(): RequestHighlight {\n        return this.hasFacetHighlight ? this.config.highlight : null;\n    }\n\n    protected getFinalQuery(): string {\n        let query = '';\n        if (this.userQuery) {\n            this.filterRawParams['userQuery'] = this.userQuery;\n        }\n        this.categories.forEach((facet) => {\n            const customQuery = this.queryFragments[facet.id];\n            if (customQuery) {\n                if (query.length > 0) {\n                    query += ' AND ';\n                }\n                query += `(${customQuery})`;\n            }\n        });\n\n        let result = [this.userQuery, query].filter((entry) => entry).join(' AND ');\n\n        if (this.userFacetBuckets) {\n            Object.keys(this.userFacetBuckets).forEach((key) => {\n                const subQuery = (this.userFacetBuckets[key] || [])\n                    .filter((bucket) => bucket.filterQuery)\n                    .map((bucket) => bucket.filterQuery)\n                    .join(' OR ');\n                if (subQuery) {\n                    if (result.length > 0) {\n                        result += ' AND ';\n                    }\n                    result += `(${subQuery})`;\n                }\n            });\n        }\n\n        return result;\n    }\n\n    protected get facetFields(): RequestFacetFields {\n        const facetFields = this.config.facetFields?.fields;\n\n        if (facetFields?.length > 0) {\n            return {\n                facets: facetFields.map(\n                    (facet) =>\n                        ({\n                            field: facet.field,\n                            mincount: facet.mincount,\n                            label: this.getSupportedLabel(facet.label),\n                            limit: facet.limit,\n                            offset: facet.offset,\n                            prefix: facet.prefix\n                        } as any)\n                )\n            };\n        }\n\n        return null;\n    }\n\n    /**\n     * Encloses a label name with double quotes if it contains whitespace characters.\n     *\n     * @param configLabel Original label text\n     * @returns Label, possibly with quotes if it contains spaces\n     */\n    getSupportedLabel(configLabel: string): string {\n        const spaceInsideLabelIndex = configLabel.search(/\\s/g);\n        if (spaceInsideLabelIndex > -1) {\n            return `\"${configLabel}\"`;\n        }\n        return configLabel;\n    }\n\n    /**\n     * Encodes filter configuration stored in filterRawParams object.\n     */\n    encodeQuery() {\n        this.encodedQuery = Buffer.from(JSON.stringify(this.filterRawParams)).toString('base64');\n    }\n\n    /**\n     * Encodes existing filters configuration and updates search query param value.\n     */\n    updateSearchQueryParams() {\n        this.encodeQuery();\n        this.router.navigate([], {\n            relativeTo: this.activatedRoute,\n            queryParams: { q: this.encodedQuery },\n            queryParamsHandling: 'merge'\n        });\n    }\n\n    /**\n     * Builds search query with provided user query, executes query, encodes latest filter config and navigates to search.\n     *\n     * @param query user query to search for\n     * @param searchUrl search url to navigate to\n     */\n    async navigateToSearch(query: string, searchUrl: string) {\n        this.userQuery = query;\n        await this.execute();\n        await this.router.navigate([searchUrl], {\n            queryParams: { q: this.encodedQuery },\n            queryParamsHandling: 'merge'\n        });\n    }\n}\n"]}

package/esm2022/lib/search/services/index.mjs

@@ -0,0 +1,24 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './base-query-builder.service';
+export * from './search-configuration.service';
+export * from './search-facet-filters.service';
+export * from './search-filter.service';
+export * from './search-header-query-builder.service';
+export * from './search-query-builder.service';
+export * from './search.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2Jhc2UtcXVlcnktYnVpbGRlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLWNvbmZpZ3VyYXRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1mYWNldC1maWx0ZXJzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtZmlsdGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtaGVhZGVyLXF1ZXJ5LWJ1aWxkZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1xdWVyeS1idWlsZGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2guc2VydmljZSc7XG4iXX0=