@creatio/base 0.815.0 → 0.820.1

package/esm2022/lib/public/esq/data-model/filters/exists-filter.mjs

@@ -0,0 +1,64 @@
+import { ɵSingleFilter } from './single-filter';
+import { ɵComparisonType, ɵFilterType } from '../enums';
+/**
+ * @public
+ * @description The comparison filter class [Exists according to the specified condition].
+ * @extends {ɵSingleFilter}
+ */
+export class ɵExistsFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_ExistsFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(leftExpression, subFilters, comparisonType = ɵComparisonType.Exists, isAggregative = true) {
+        super(ɵFilterType.Exists, comparisonType, leftExpression);
+        this.subFilters = subFilters?.clone();
+        this.isAggregative = isAggregative;
+    }
+    /**
+     * Parses filter from json.
+     * @public
+     */
+    static fromJson(dto, filterParser, expressionParser) {
+        const leftExpression = expressionParser.fromJson(dto['leftExpression'], filterParser);
+        const subFiltersDto = dto['subFilters'];
+        let subFilters;
+        if (subFiltersDto) {
+            subFilters = filterParser.fromJson(dto['subFilters']);
+        }
+        return new ɵExistsFilter(leftExpression, subFilters, dto['comparisonType'], dto['isAggregative']);
+    }
+    /**
+     * @public
+     * @description Clones instance.
+     */
+    clone() {
+        const filter = new ɵExistsFilter(this.leftExpression, this.subFilters, this.comparisonType, this.isAggregative);
+        filter.isEnabled = this.isEnabled;
+        filter.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filter;
+    }
+    /** {@inheritDoc ɵSerializable.toJson} */
+    toJson() {
+        const result = super.toJson();
+        if (this.subFilters) {
+            result['subFilters'] = this.serializeItem(this.subFilters);
+        }
+        return result;
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        return [...super._getUsedColumns(), ...(this.subFilters?._getUsedColumns() ?? [])];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/filter-group.mjs

@@ -0,0 +1,247 @@
+import { __decorate, __metadata } from "tslib";
+import { Exclude, Expose } from 'class-transformer';
+import { ɵBaseFilter } from './base-filter';
+import { ɵBetweenFilter } from './between-filter';
+import { ɵCompareFilter } from './compare-filter';
+import { ɵExistsFilter } from './exists-filter';
+import { ɵInFilter } from './in-filter';
+import { ɵIsNullFilter } from './isnull-filter';
+import { ɵgenerateGuid } from '../../../../public/types';
+import { ɵValidationUtilities } from '../../../exceptions';
+import { ɵComparisonType } from '../enums/comparison-type.enum';
+import { ɵFilterType } from '../enums/filter-type.enum';
+import { ɵLogicalOperatorType } from '../enums/logical-operator-type.enum';
+import { ɵQueryMacrosType } from '../enums/query-macros-type.enum';
+import { ɵColumnExpression } from '../expressions/columns/column-expression';
+import { ɵMacrosFunctionExpression } from '../expressions/functions/macros-function-expression';
+import { ɵParameterExpression } from '../expressions/parameters/parameter-expression';
+/**
+ * @public
+ * @description Group of filters. Groups of filters can be nested into each other,
+ * i.e. The collection itself can be an element of another collection.
+ * @extends {ɵBaseFilter}
+ */
+export class ɵFilterGroup extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_FilterGroup'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    /**
+     * @public
+     * @description Return collecion of deserialized filters.
+     */
+    get items() {
+        const result = {};
+        this.filters.forEach((filter, key) => {
+            result[key] = this.serializeItem(filter);
+        });
+        return result;
+    }
+    constructor(logicalOperation = ɵLogicalOperatorType.And, rootSchemaName) {
+        super(ɵFilterType.FilterGroup);
+        /**
+         * @public
+         * @description Collection of child filters.
+         */
+        this.filters = new Map();
+        this.logicalOperation = logicalOperation;
+        this.rootSchemaName = rootSchemaName;
+    }
+    /**
+     * @public
+     * @description Parses filter group from json.
+     */
+    static fromJson(dto, filterParser) {
+        const logicalOperation = dto['logicalOperation'];
+        const group = new ɵFilterGroup(logicalOperation || ɵLogicalOperatorType.And, dto['rootSchemaName']);
+        Object.entries(dto['items']).forEach(([key, filterDTO]) => {
+            group.add(filterParser.fromJson(filterDTO), key);
+        });
+        return group;
+    }
+    /** {@inheritDoc ɵSerializable.toJson} */
+    toJson() {
+        const result = {};
+        result['filterType'] = this.filterType;
+        result['isEnabled'] = this.isEnabled;
+        result['logicalOperation'] = this.logicalOperation;
+        result['trimDateTimeParameterToDate'] = this.trimDateTimeParameterToDate;
+        result['items'] = this.items;
+        if (this.rootSchemaName) {
+            result['rootSchemaName'] = this.rootSchemaName;
+        }
+        return result;
+    }
+    _createParameterValueExpressions(values) {
+        return values.map((value) => new ɵParameterExpression({
+            value: value,
+        }));
+    }
+    /**
+     * @public
+     * @description Returns filter item by index.
+     * @param index Item index.
+     * @returns Filter.
+     */
+    getItemByIndex(index) {
+        return this.items[Object.keys(this.items)[index]];
+    }
+    /**
+     * @public
+     * @description Creates and adds compare filter by value.
+     * @param comparisonType Comparison type.
+     * @param columnPath Column path.
+     * @param parameterValue Parameter value.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnFilterWithParameter(comparisonType, columnPath, parameterValue, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const rightExpression = new ɵParameterExpression({ value: parameterValue });
+        const filter = new ɵCompareFilter(comparisonType, leftExpression, rightExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds in filter by values.
+     * @param comparisonType Comparison type.
+     * @param columnPath Column path.
+     * @param parameterValues Parameter values.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnInFilterWithParameters(comparisonType, columnPath, parameterValues, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const expressions = this._createParameterValueExpressions(parameterValues);
+        const filter = new ɵInFilter(comparisonType, leftExpression, expressions);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds in filter for primary column.
+     * @param primaryColumnValues Primary column values.
+     * @param filterKey Filter key.
+     */
+    addPrimarySchemaColumnInFilter(primaryColumnValues, filterKey) {
+        const leftExpression = new ɵMacrosFunctionExpression({ macrosType: ɵQueryMacrosType.PrimaryColumn });
+        const expressions = this._createParameterValueExpressions(primaryColumnValues);
+        const filter = new ɵInFilter(ɵComparisonType.Equal, leftExpression, expressions);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds null filter.
+     * @param columnPath Path of column.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnIsNullFilter(columnPath, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵIsNullFilter(ɵComparisonType.Is_null, leftExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds not null filter.
+     * @param columnPath Column path.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnIsNotNullFilter(columnPath, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵIsNullFilter(ɵComparisonType.Is_not_null, leftExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds filter between less value and greater value.
+     * @param columnPath Column path.
+     * @param lessParamValue Less parameter value.
+     * @param greaterParamValue Greater parameter value.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnBetweenFilterWithParameters(columnPath, lessParamValue, greaterParamValue, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const rightLessExpression = new ɵParameterExpression({ value: lessParamValue });
+        const rightGreaterExpression = new ɵParameterExpression({ value: greaterParamValue });
+        const filter = new ɵBetweenFilter(leftExpression, rightLessExpression, rightGreaterExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds exists filter.
+     * @param columnPath Column path.
+     * @param subFilters Filters for exists expression.
+     * @param filterKey Filter key.
+     */
+    addExistsFilter(columnPath, subFilters, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵExistsFilter(leftExpression, subFilters);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds not exists filter.
+     * @param columnPath Column path.
+     * @param subFilters Filters for exist expression.
+     * @param filterKey Filter key.
+     */
+    addNotExistsFilter(columnPath, subFilters, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵExistsFilter(leftExpression, subFilters, ɵComparisonType.Not_exists);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Adds filter.
+     * @param filter Instance of filter.
+     * @param filterKey Filter key.
+     */
+    add(filter, filterKey) {
+        ɵValidationUtilities.checkArgumentEmpty('filter', filter);
+        const key = filterKey || ɵgenerateGuid();
+        this.filters.set(key, filter);
+    }
+    /**
+     * @public
+     * @description Clones instance.
+     */
+    clone() {
+        const filterGroup = new ɵFilterGroup(this.logicalOperation, this.rootSchemaName);
+        this.filters.forEach((filter, filterKey) => {
+            filterGroup.filters.set(filterKey, filter.clone());
+        });
+        filterGroup.isEnabled = this.isEnabled;
+        filterGroup.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filterGroup;
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        const result = [];
+        this.filters.forEach((filter) => {
+            let filterUsedColumns = filter._getUsedColumns ? filter._getUsedColumns() : [];
+            filterUsedColumns = filterUsedColumns.map((usedColumn) => ({
+                path: usedColumn.path,
+                schemaName: usedColumn.schemaName ?? this.rootSchemaName,
+            }));
+            result.push(...filterUsedColumns);
+        });
+        return result;
+    }
+}
+__decorate([
+    Exclude(),
+    __metadata("design:type", Object)
+], ɵFilterGroup.prototype, "filters", void 0);
+__decorate([
+    Expose(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], ɵFilterGroup.prototype, "items", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-group.js","sourceRoot":"","sources":["../../../../../../../../../../libs/devkit/base/src/lib/public/esq/data-model/filters/filter-group.ts"],"names":[],"mappings":"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","sourcesContent":["import { Exclude, Expose } from 'class-transformer';\n\nimport { ɵBaseFilter } from './base-filter';\nimport { ɵBetweenFilter } from './between-filter';\nimport { ɵCompareFilter } from './compare-filter';\nimport { ɵExistsFilter } from './exists-filter';\nimport { ɵBaseFilterParser } from './filter-parser/base-filter-parser';\nimport { ɵInFilter } from './in-filter';\nimport { ɵIsNullFilter } from './isnull-filter';\nimport { ɵEntityColumnValue, ɵgenerateGuid, ɵGuid, ɵJsonObject } from '../../../../public/types';\nimport { ɵValidationUtilities } from '../../../exceptions';\nimport { ɵComparisonType } from '../enums/comparison-type.enum';\nimport { ɵFilterType } from '../enums/filter-type.enum';\nimport { ɵLogicalOperatorType } from '../enums/logical-operator-type.enum';\nimport { ɵQueryMacrosType } from '../enums/query-macros-type.enum';\nimport { ɵColumnExpression } from '../expressions/columns/column-expression';\nimport { ɵMacrosFunctionExpression } from '../expressions/functions/macros-function-expression';\nimport { ɵParameterExpression } from '../expressions/parameters/parameter-expression';\nimport { UsedColumn } from '../used-column';\n\n/**\n * @public\n * @description Group of filters. Groups of filters can be nested into each other,\n * i.e. The collection itself can be an element of another collection.\n * @extends {ɵBaseFilter}\n */\nexport class ɵFilterGroup extends ɵBaseFilter {\n\t/**\n\t * @internal\n\t * @dontChange\n\t */\n\tprotected static readonly _instanceOfKey: string = 'devkit_FilterGroup';\n\n\t/**\n\t * @internal\n\t * @dontChange\n\t */\n\tprotected static get _instanceOfKeys(): string[] {\n\t\treturn [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];\n\t}\n\n\t/**\n\t * @public\n\t * @description Collection of child filters.\n\t */\n\t@Exclude()\n\tpublic filters = new Map<ɵGuid, ɵBaseFilter>();\n\n\t/**\n\t * @public\n\t * @description Return collecion of deserialized filters.\n\t */\n\t@Expose()\n\tpublic get items(): { [key: string]: ɵBaseFilter } {\n\t\tconst result = {};\n\t\tthis.filters.forEach((filter, key) => {\n\t\t\tresult[key] = this.serializeItem(filter);\n\t\t});\n\t\treturn result;\n\t}\n\n\t/**\n\t * @description The type of the logical operation for a combination of filters in the collection.\n\t */\n\tpublic logicalOperation: ɵLogicalOperatorType;\n\t/**\n\t * @description Root schema name.\n\t */\n\tpublic rootSchemaName?: string;\n\n\tconstructor(logicalOperation = ɵLogicalOperatorType.And, rootSchemaName?: string) {\n\t\tsuper(ɵFilterType.FilterGroup);\n\t\tthis.logicalOperation = logicalOperation;\n\t\tthis.rootSchemaName = rootSchemaName;\n\t}\n\n\t/**\n\t * @public\n\t * @description Parses filter group from json.\n\t */\n\tpublic static fromJson<T extends typeof ɵBaseFilterParser>(dto: ɵJsonObject, filterParser: T): ɵFilterGroup {\n\t\tconst logicalOperation = dto['logicalOperation'] as ɵLogicalOperatorType;\n\t\tconst group = new ɵFilterGroup(logicalOperation || ɵLogicalOperatorType.And, dto['rootSchemaName'] as string);\n\t\tObject.entries(dto['items'] as ɵJsonObject).forEach(([key, filterDTO]) => {\n\t\t\tgroup.add(filterParser.fromJson(filterDTO as ɵJsonObject) as ɵBaseFilter, key);\n\t\t});\n\t\treturn group;\n\t}\n\n\t/** {@inheritDoc ɵSerializable.toJson} */\n\tpublic toJson(): ɵJsonObject {\n\t\tconst result = {};\n\t\tresult['filterType'] = this.filterType;\n\t\tresult['isEnabled'] = this.isEnabled;\n\t\tresult['logicalOperation'] = this.logicalOperation;\n\t\tresult['trimDateTimeParameterToDate'] = this.trimDateTimeParameterToDate;\n\t\tresult['items'] = this.items;\n\t\tif (this.rootSchemaName) {\n\t\t\tresult['rootSchemaName'] = this.rootSchemaName;\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate _createParameterValueExpressions(values: ɵEntityColumnValue[]): ɵParameterExpression[] {\n\t\treturn values.map(\n\t\t\t(value) =>\n\t\t\t\tnew ɵParameterExpression({\n\t\t\t\t\tvalue: value,\n\t\t\t\t}),\n\t\t);\n\t}\n\n\t/**\n\t * @public\n\t * @description Returns filter item by index.\n\t * @param index Item index.\n\t * @returns Filter.\n\t */\n\tpublic getItemByIndex(index: number): ɵBaseFilter {\n\t\treturn this.items[Object.keys(this.items)[index]];\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds compare filter by value.\n\t * @param comparisonType Comparison type.\n\t * @param columnPath Column path.\n\t * @param parameterValue Parameter value.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnFilterWithParameter(\n\t\tcomparisonType: ɵComparisonType,\n\t\tcolumnPath: string,\n\t\tparameterValue: ɵEntityColumnValue,\n\t\tfilterKey?: string,\n\t): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst rightExpression = new ɵParameterExpression({ value: parameterValue });\n\t\tconst filter = new ɵCompareFilter(comparisonType, leftExpression, rightExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds in filter by values.\n\t * @param comparisonType Comparison type.\n\t * @param columnPath Column path.\n\t * @param parameterValues Parameter values.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnInFilterWithParameters(\n\t\tcomparisonType: ɵComparisonType,\n\t\tcolumnPath: string,\n\t\tparameterValues: ɵEntityColumnValue[],\n\t\tfilterKey?: string,\n\t): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst expressions = this._createParameterValueExpressions(parameterValues);\n\t\tconst filter = new ɵInFilter(comparisonType, leftExpression, expressions);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds in filter for primary column.\n\t * @param primaryColumnValues Primary column values.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addPrimarySchemaColumnInFilter(primaryColumnValues: ɵEntityColumnValue[], filterKey?: string): void {\n\t\tconst leftExpression = new ɵMacrosFunctionExpression({ macrosType: ɵQueryMacrosType.PrimaryColumn });\n\t\tconst expressions = this._createParameterValueExpressions(primaryColumnValues);\n\t\tconst filter = new ɵInFilter(ɵComparisonType.Equal, leftExpression, expressions);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds null filter.\n\t * @param columnPath Path of column.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnIsNullFilter(columnPath: string, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵIsNullFilter(ɵComparisonType.Is_null, leftExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds not null filter.\n\t * @param columnPath Column path.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnIsNotNullFilter(columnPath: string, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵIsNullFilter(ɵComparisonType.Is_not_null, leftExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds filter between less value and greater value.\n\t * @param columnPath Column path.\n\t * @param lessParamValue Less parameter value.\n\t * @param greaterParamValue Greater parameter value.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnBetweenFilterWithParameters(\n\t\tcolumnPath: string,\n\t\tlessParamValue: Date | number,\n\t\tgreaterParamValue: Date | number,\n\t\tfilterKey?: string,\n\t): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst rightLessExpression = new ɵParameterExpression({ value: lessParamValue });\n\t\tconst rightGreaterExpression = new ɵParameterExpression({ value: greaterParamValue });\n\t\tconst filter = new ɵBetweenFilter(leftExpression, rightLessExpression, rightGreaterExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds exists filter.\n\t * @param columnPath Column path.\n\t * @param subFilters Filters for exists expression.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addExistsFilter(columnPath: string, subFilters?: ɵFilterGroup, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵExistsFilter(leftExpression, <ɵFilterGroup>subFilters);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds not exists filter.\n\t * @param columnPath Column path.\n\t * @param subFilters Filters for exist expression.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addNotExistsFilter(columnPath: string, subFilters?: ɵFilterGroup, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵExistsFilter(leftExpression, <ɵFilterGroup>subFilters, ɵComparisonType.Not_exists);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Adds filter.\n\t * @param filter Instance of filter.\n\t * @param filterKey Filter key.\n\t */\n\tpublic add(filter: ɵBaseFilter, filterKey?: string): void {\n\t\tɵValidationUtilities.checkArgumentEmpty('filter', filter);\n\t\tconst key = filterKey || ɵgenerateGuid();\n\t\tthis.filters.set(key, filter);\n\t}\n\n\t/**\n\t * @public\n\t * @description Clones instance.\n\t */\n\tpublic clone(): ɵFilterGroup {\n\t\tconst filterGroup = new ɵFilterGroup(this.logicalOperation, this.rootSchemaName);\n\t\tthis.filters.forEach((filter, filterKey) => {\n\t\t\tfilterGroup.filters.set(filterKey, filter.clone());\n\t\t});\n\t\tfilterGroup.isEnabled = this.isEnabled;\n\t\tfilterGroup.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;\n\t\treturn filterGroup;\n\t}\n\n\t/**\n\t * @internal\n\t */\n\tpublic _getUsedColumns(): UsedColumn[] {\n\t\tconst result: UsedColumn[] = [];\n\t\tthis.filters.forEach((filter) => {\n\t\t\tlet filterUsedColumns = filter._getUsedColumns ? filter._getUsedColumns() : [];\n\t\t\tfilterUsedColumns = filterUsedColumns.map((usedColumn) => ({\n\t\t\t\tpath: usedColumn.path,\n\t\t\t\tschemaName: usedColumn.schemaName ?? this.rootSchemaName,\n\t\t\t}));\n\t\t\tresult.push(...filterUsedColumns);\n\t\t});\n\t\treturn result;\n\t}\n}\n"]}

package/esm2022/lib/public/esq/data-model/filters/in-filter.mjs

@@ -0,0 +1,57 @@
+import { ɵSingleFilter } from './single-filter';
+import { ɵFilterType } from '../enums';
+/**
+ * @public
+ * @description In-Filter Class
+ * @extends {ɵSingleFilter}
+ */
+export class ɵInFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_InFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(comparisonType, leftExpression, rightExpressions) {
+        super(ɵFilterType.In, comparisonType, leftExpression);
+        this.rightExpressions = rightExpressions.map((expression) => expression?.clone()) ?? [];
+    }
+    /**
+     * @description Parses in filter from json.
+     * @public
+     */
+    static fromJson(dto, filterParser, expressionParser) {
+        const dtoRightExpressions = (dto['rightExpressions'] ?? []);
+        return new ɵInFilter(dto['comparisonType'], expressionParser.fromJson(dto['leftExpression'], filterParser), dtoRightExpressions.map((expression) => expressionParser.fromJson(expression, filterParser)));
+    }
+    /** {@inheritDoc ɵBaseFilter.clone} */
+    clone() {
+        const filter = new ɵInFilter(this.comparisonType, this.leftExpression, this.rightExpressions);
+        filter.isEnabled = this.isEnabled;
+        filter.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filter;
+    }
+    /** {@inheritDoc ɵSerializable.toJson} */
+    toJson() {
+        return {
+            ...super.toJson(),
+            rightExpressions: this.rightExpressions.map((expression) => this.serializeItem(expression)),
+        };
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        const rightExpressionsUsedColumns = this.rightExpressions
+            .map((expression) => expression._getUsedColumns())
+            .flat();
+        return [...super._getUsedColumns(), ...rightExpressionsUsedColumns];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/isnull-filter.mjs

@@ -0,0 +1,52 @@
+import { __decorate, __metadata } from "tslib";
+import { Expose } from 'class-transformer';
+import { ɵSingleFilter } from './single-filter';
+import { ɵComparisonType, ɵFilterType } from '../enums';
+/**
+ * @public
+ * @description IsNull filter Class
+ * @extends {ɵSingleFilter}
+ */
+export class ɵIsNullFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_IsNullFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(comparisonType, leftExpression) {
+        super(ɵFilterType.IsNull, comparisonType, leftExpression);
+    }
+    /**
+     * @description Flag that indicates if expression is empty or not.
+     */
+    get isNull() {
+        return this.comparisonType === ɵComparisonType.Is_null;
+    }
+    /**
+     * @description Parses isNull filter from json.
+     * @public
+     */
+    static fromJson(dto, filterParser, expressionParser) {
+        return new ɵIsNullFilter(dto['comparisonType'], expressionParser.fromJson(dto['leftExpression'], filterParser));
+    }
+    /** {@inheritDoc ɵBaseFilter.clone} */
+    clone() {
+        const filter = new ɵIsNullFilter(this.comparisonType, this.leftExpression);
+        filter.isEnabled = this.isEnabled;
+        filter.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filter;
+    }
+}
+__decorate([
+    Expose(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], ɵIsNullFilter.prototype, "isNull", null);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/mocks/filter.mock.mjs

@@ -0,0 +1,34 @@
+import { classToPlain } from 'class-transformer';
+import { ɵFilterType } from '../../enums';
+import { ɵBaseFilter } from '../base-filter';
+export class ɵFilterMock extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_FilterMock'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(filterType = ɵFilterType.None) {
+        super(filterType);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    get plainObject() {
+        return classToPlain(this, { exposeUnsetFields: false, excludePrefixes: ['_'] });
+    }
+    clone() {
+        return new ɵFilterMock(this.filterType);
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        return [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/single-filter.mjs

@@ -0,0 +1,39 @@
+import { ɵBaseFilter } from './base-filter';
+/**
+ * @public
+ * @description Basic filter class with one condition.
+ * @extends {ɵBaseFilter}
+ */
+export class ɵSingleFilter extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_SingleFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(filterType, comparisonType, leftExpression) {
+        super(filterType);
+        this.comparisonType = comparisonType;
+        this.leftExpression = leftExpression?.clone();
+    }
+    /** {@inheritDoc ɵSerializable.toJson} */
+    toJson() {
+        return {
+            ...super.toJson(),
+            leftExpression: this.serializeItem(this.leftExpression),
+        };
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        return this.leftExpression._getUsedColumns();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/public/esq/data-model/queries/base-filterable-query.mjs

@@ -46,4 +46,4 @@ __decorate([
     Exclude(),
     __metadata("design:type", Object)
 ], ɵBaseFilterableQuery.prototype, "filters", void 0);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1maWx0ZXJhYmxlLXF1ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kZXZraXQvYmFzZS9zcmMvbGliL3B1YmxpYy9lc3EvZGF0YS1tb2RlbC9xdWVyaWVzL2Jhc2UtZmlsdGVyYWJsZS1xdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRTVDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFMUMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBR3ZEOzs7O0dBSUc7QUFDSCxNQUFNLE9BQWdCLG9CQUFxQixTQUFRLFVBQVU7SUFPNUQsWUFBc0IsYUFBa0MsRUFBRSxjQUFzQjtRQUMvRSxLQUFLLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDO1FBUHRDOztXQUVHO1FBRWEsWUFBTyxHQUFHLElBQUksWUFBWSxFQUFFLENBQUM7SUFJN0MsQ0FBQztJQUVEOzs7T0FHRztJQUNJLFlBQVk7UUFDbEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDOUIsQ0FBQztJQUVELGtEQUFrRDtJQUMzQyxXQUFXO1FBQ2pCLE9BQU87WUFDTixHQUFHLEtBQUssQ0FBQyxXQUFXLEVBQUU7WUFDdEIsT0FBTyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFO1NBQzlCLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxlQUFlO1FBQ3JCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDbkQsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFO1lBQ2xDLElBQUksQ0FBQyxVQUFVLENBQUMsVUFBVSxFQUFFLENBQUM7Z0JBQzVCLFVBQVUsQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQztZQUM3QyxDQUFDO1FBQ0YsQ0FBQyxDQUFDLENBQUM7UUFDSCxPQUFPLFdBQVcsQ0FBQztJQUNwQixDQUFDO0NBQ0Q7QUFsQ2dCO0lBRGYsT0FBTyxFQUFFOztxREFDbUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFeGNsdWRlIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInO1xuXG5pbXBvcnQgeyDJtUJhc2VRdWVyeSB9IGZyb20gJy4vYmFzZS1xdWVyeSc7XG5pbXBvcnQgeyDJtVF1ZXJ5T3BlcmF0aW9uVHlwZSB9IGZyb20gJy4vcXVlcnktb3BlcmF0aW9uLXR5cGUnO1xuaW1wb3J0IHsgybVGaWx0ZXJHcm91cCB9IGZyb20gJy4uL2ZpbHRlcnMvZmlsdGVyLWdyb3VwJztcbmltcG9ydCB7IFVzZWRDb2x1bW4gfSBmcm9tICcuLi91c2VkLWNvbHVtbic7XG5cbi8qKlxuICogQHB1YmxpY1xuICogQGRlc2NyaXB0aW9uIFRoZSBiYXNlIGNsYXNzIG9mIHRoZSBmaWx0ZXJlZCBkYXRhIHJlcXVlc3QuXG4gKiBAZXh0ZW5kcyB7ybVCYXNlUXVlcnl9XG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyDJtUJhc2VGaWx0ZXJhYmxlUXVlcnkgZXh0ZW5kcyDJtUJhc2VRdWVyeSB7XG5cdC8qKlxuXHQgKiBAZGVzY3JpcHRpb24gQ29sbGVjdGlvbiBvZiBmaWx0ZXJzLlxuXHQgKi9cblx0QEV4Y2x1ZGUoKVxuXHRwdWJsaWMgcmVhZG9ubHkgZmlsdGVycyA9IG5ldyDJtUZpbHRlckdyb3VwKCk7XG5cblx0cHJvdGVjdGVkIGNvbnN0cnVjdG9yKG9wZXJhdGlvblR5cGU6IMm1UXVlcnlPcGVyYXRpb25UeXBlLCByb290U2NoZW1hTmFtZTogc3RyaW5nKSB7XG5cdFx0c3VwZXIob3BlcmF0aW9uVHlwZSwgcm9vdFNjaGVtYU5hbWUpO1xuXHR9XG5cblx0LyoqXG5cdCAqIEBwdWJsaWNcblx0ICogQGRlc2NyaXB0aW9uIENsZWFycyBhbGwgZmlsdGVycy5cblx0ICovXG5cdHB1YmxpYyBjbGVhckZpbHRlcnMoKTogdm9pZCB7XG5cdFx0dGhpcy5maWx0ZXJzLmZpbHRlcnMuY2xlYXIoKTtcblx0fVxuXG5cdC8qKiB7QGluaGVyaXREb2MgybVNZXRhZGF0YVByb3ZpZGVyLmdldE1ldGFkYXRhfSAqL1xuXHRwdWJsaWMgZ2V0TWV0YWRhdGEoKTogUmVjb3JkPHN0cmluZywgdW5rbm93bj4ge1xuXHRcdHJldHVybiB7XG5cdFx0XHQuLi5zdXBlci5nZXRNZXRhZGF0YSgpLFxuXHRcdFx0ZmlsdGVyczogdGhpcy5maWx0ZXJzLnRvSnNvbigpLFxuXHRcdH07XG5cdH1cblxuXHQvKipcblx0ICogQGludGVybmFsXG5cdCAqL1xuXHRwdWJsaWMgX2dldFVzZWRDb2x1bW5zKCk6IFVzZWRDb2x1bW5bXSB7XG5cdFx0Y29uc3QgdXNlZENvbHVtbnMgPSB0aGlzLmZpbHRlcnMuX2dldFVzZWRDb2x1bW5zKCk7XG5cdFx0dXNlZENvbHVtbnMuZm9yRWFjaCgodXNlZENvbHVtbikgPT4ge1xuXHRcdFx0aWYgKCF1c2VkQ29sdW1uLnNjaGVtYU5hbWUpIHtcblx0XHRcdFx0dXNlZENvbHVtbi5zY2hlbWFOYW1lID0gdGhpcy5yb290U2NoZW1hTmFtZTtcblx0XHRcdH1cblx0XHR9KTtcblx0XHRyZXR1cm4gdXNlZENvbHVtbnM7XG5cdH1cbn1cbiJdfQ==