@creatio/base 0.814.0 → 0.820.0

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/mocks/parser.mock.mjs

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+export const ɵparserMock = {
+    fromJson: (data) => ({
+        ...data,
+        clone: () => data,
+    }),
+    clone: () => this,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VyLm1vY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RldmtpdC9iYXNlL3NyYy9saWIvcHVibGljL2VzcS9kYXRhLW1vZGVsL2ZpbHRlcnMvbW9ja3MvcGFyc2VyLm1vY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDMUIsUUFBUSxFQUFFLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3BCLEdBQUcsSUFBSTtRQUNQLEtBQUssRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJO0tBQ2pCLENBQUM7SUFDRixLQUFLLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSTtDQUNqQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNvbnN0IMm1cGFyc2VyTW9jayA9IHtcblx0ZnJvbUpzb246IChkYXRhKSA9PiAoe1xuXHRcdC4uLmRhdGEsXG5cdFx0Y2xvbmU6ICgpID0+IGRhdGEsXG5cdH0pLFxuXHRjbG9uZTogKCkgPT4gdGhpcyxcbn07XG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xlLWZpbHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGV2a2l0L2Jhc2Uvc3JjL2xpYi9wdWJsaWMvZXNxL2RhdGEtbW9kZWwvZmlsdGVycy9zaW5nbGUtZmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFNNUM7Ozs7R0FJRztBQUNILE1BQU0sT0FBZ0IsYUFBYyxTQUFRLFdBQVc7SUFDdEQ7OztPQUdHO2FBQ3VCLG1CQUFjLEdBQVcscUJBQXFCLENBQUM7SUFFekU7OztPQUdHO0lBQ08sTUFBTSxLQUFLLGVBQWU7UUFDbkMsT0FBTyxDQUFDLEdBQUcsV0FBVyxDQUFDLGVBQWUsRUFBRSxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQVlELFlBQXNCLFVBQXVCLEVBQUUsY0FBK0IsRUFBRSxjQUErQjtRQUM5RyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDbEIsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7UUFDckMsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLEVBQUUsS0FBSyxFQUFFLENBQUM7SUFDL0MsQ0FBQztJQUVELHlDQUF5QztJQUNsQyxNQUFNO1FBQ1osT0FBTztZQUNOLEdBQUcsS0FBSyxDQUFDLE1BQU0sRUFBRTtZQUNqQixjQUFjLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDO1NBQ3ZELENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxlQUFlO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsQ0FBQztJQUM5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgybVCYXNlRmlsdGVyIH0gZnJvbSAnLi9iYXNlLWZpbHRlcic7XG5pbXBvcnQgeyDJtUpzb25PYmplY3QgfSBmcm9tICcuLi8uLi8uLi90eXBlcyc7XG5pbXBvcnQgeyDJtUNvbXBhcmlzb25UeXBlLCDJtUZpbHRlclR5cGUgfSBmcm9tICcuLi9lbnVtcyc7XG5pbXBvcnQgeyDJtUJhc2VFeHByZXNzaW9uIH0gZnJvbSAnLi4vZXhwcmVzc2lvbnMvYmFzZS1leHByZXNzaW9uJztcbmltcG9ydCB7IFVzZWRDb2x1bW4gfSBmcm9tICcuLi91c2VkLWNvbHVtbic7XG5cbi8qKlxuICogQHB1YmxpY1xuICogQGRlc2NyaXB0aW9uIEJhc2ljIGZpbHRlciBjbGFzcyB3aXRoIG9uZSBjb25kaXRpb24uXG4gKiBAZXh0ZW5kcyB7ybVCYXNlRmlsdGVyfVxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgybVTaW5nbGVGaWx0ZXIgZXh0ZW5kcyDJtUJhc2VGaWx0ZXIge1xuXHQvKipcblx0ICogQGludGVybmFsXG5cdCAqIEBkb250Q2hhbmdlXG5cdCAqL1xuXHRwcm90ZWN0ZWQgc3RhdGljIHJlYWRvbmx5IF9pbnN0YW5jZU9mS2V5OiBzdHJpbmcgPSAnZGV2a2l0X1NpbmdsZUZpbHRlcic7XG5cblx0LyoqXG5cdCAqIEBpbnRlcm5hbFxuXHQgKiBAZG9udENoYW5nZVxuXHQgKi9cblx0cHJvdGVjdGVkIHN0YXRpYyBnZXQgX2luc3RhbmNlT2ZLZXlzKCk6IHN0cmluZ1tdIHtcblx0XHRyZXR1cm4gWy4uLsm1QmFzZUZpbHRlci5faW5zdGFuY2VPZktleXMsIHRoaXMuX2luc3RhbmNlT2ZLZXldO1xuXHR9XG5cblx0LyoqXG5cdCAqIEBkZXNjcmlwdGlvbiBUeXBlIG9mIGNvbXBhcmlzb24gb3BlcmF0aW9uLlxuXHQgKi9cblx0cHVibGljIHJlYWRvbmx5IGNvbXBhcmlzb25UeXBlOiDJtUNvbXBhcmlzb25UeXBlO1xuXG5cdC8qKlxuXHQgKiBAZGVzY3JpcHRpb24gVGhlIHRlc3QgZXhwcmVzc2lvbi5cblx0ICovXG5cdHB1YmxpYyByZWFkb25seSBsZWZ0RXhwcmVzc2lvbjogybVCYXNlRXhwcmVzc2lvbjtcblxuXHRwcm90ZWN0ZWQgY29uc3RydWN0b3IoZmlsdGVyVHlwZTogybVGaWx0ZXJUeXBlLCBjb21wYXJpc29uVHlwZTogybVDb21wYXJpc29uVHlwZSwgbGVmdEV4cHJlc3Npb246IMm1QmFzZUV4cHJlc3Npb24pIHtcblx0XHRzdXBlcihmaWx0ZXJUeXBlKTtcblx0XHR0aGlzLmNvbXBhcmlzb25UeXBlID0gY29tcGFyaXNvblR5cGU7XG5cdFx0dGhpcy5sZWZ0RXhwcmVzc2lvbiA9IGxlZnRFeHByZXNzaW9uPy5jbG9uZSgpO1xuXHR9XG5cblx0LyoqIHtAaW5oZXJpdERvYyDJtVNlcmlhbGl6YWJsZS50b0pzb259ICovXG5cdHB1YmxpYyB0b0pzb24oKTogybVKc29uT2JqZWN0IHtcblx0XHRyZXR1cm4ge1xuXHRcdFx0Li4uc3VwZXIudG9Kc29uKCksXG5cdFx0XHRsZWZ0RXhwcmVzc2lvbjogdGhpcy5zZXJpYWxpemVJdGVtKHRoaXMubGVmdEV4cHJlc3Npb24pLFxuXHRcdH07XG5cdH1cblxuXHQvKipcblx0ICogQGludGVybmFsXG5cdCAqL1xuXHRwdWJsaWMgX2dldFVzZWRDb2x1bW5zKCk6IFVzZWRDb2x1bW5bXSB7XG5cdFx0cmV0dXJuIHRoaXMubGVmdEV4cHJlc3Npb24uX2dldFVzZWRDb2x1bW5zKCk7XG5cdH1cbn1cbiJdfQ==

package/{esm2020 → esm2022}/lib/public/esq/data-model/metadata-provider/metadata-provider.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RldmtpdC9iYXNlL3NyYy9saWIvcHVibGljL2VzcS9kYXRhLW1vZGVsL21ldGFkYXRhLXByb3ZpZGVyL21ldGFkYXRhLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwdWJsaWNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSDJtU1ldGFkYXRhUHJvdmlkZXI8VD4ge1xuXHQvLyByZWdpb24gTWV0aG9kczogUHVibGljXG5cblx0Z2V0TWV0YWRhdGEoKTogVDtcblxuXHQvLyBlbmRyZWdpb25cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RldmtpdC9iYXNlL3NyYy9saWIvcHVibGljL2VzcS9kYXRhLW1vZGVsL21ldGFkYXRhLXByb3ZpZGVyL21ldGFkYXRhLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwdWJsaWNcbiAqIEBkZXNjcmlwdGlvbiBQcm92aWRlciB0byB3b3JrIHdpdGggbWV0YWRhdGEuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgybVNZXRhZGF0YVByb3ZpZGVyPFQ+IHtcblx0Ly8gcmVnaW9uIE1ldGhvZHM6IFB1YmxpY1xuXG5cdC8qKlxuXHQgKiBAcHVibGljXG5cdCAqIEBkZXNjcmlwdGlvbiBSZXR1cm5zIG1ldGFkYXRhLlxuXHQgKi9cblx0Z2V0TWV0YWRhdGEoKTogVDtcblxuXHQvLyBlbmRyZWdpb25cbn1cbiJdfQ==

package/esm2022/lib/public/esq/data-model/queries/base-filterable-query.mjs

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from "tslib";
+import { Exclude } from 'class-transformer';
+import { ɵBaseQuery } from './base-query';
+import { ɵFilterGroup } from '../filters/filter-group';
+/**
+ * @public
+ * @description The base class of the filtered data request.
+ * @extends {ɵBaseQuery}
+ */
+export class ɵBaseFilterableQuery extends ɵBaseQuery {
+    constructor(operationType, rootSchemaName) {
+        super(operationType, rootSchemaName);
+        /**
+         * @description Collection of filters.
+         */
+        this.filters = new ɵFilterGroup();
+    }
+    /**
+     * @public
+     * @description Clears all filters.
+     */
+    clearFilters() {
+        this.filters.filters.clear();
+    }
+    /** {@inheritDoc ɵMetadataProvider.getMetadata} */
+    getMetadata() {
+        return {
+            ...super.getMetadata(),
+            filters: this.filters.toJson(),
+        };
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        const usedColumns = this.filters._getUsedColumns();
+        usedColumns.forEach((usedColumn) => {
+            if (!usedColumn.schemaName) {
+                usedColumn.schemaName = this.rootSchemaName;
+            }
+        });
+        return usedColumns;
+    }
+}
+__decorate([
+    Exclude(),
+    __metadata("design:type", Object)
+], ɵBaseFilterableQuery.prototype, "filters", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/queries/base-query.mjs

@@ -0,0 +1,22 @@
+import { classToPlain } from 'class-transformer';
+import { ɵValidationUtilities } from '../../../exceptions';
+/**
+ * @public
+ * @description The base class of the data request. Implements {@link ɵMetadataProvider}
+ */
+export class ɵBaseQuery {
+    // region Constructors: Protected
+    constructor(operationType, rootSchemaName) {
+        this.operationType = operationType;
+        this.rootSchemaName = rootSchemaName;
+        ɵValidationUtilities.checkArgumentEmpty('_operationType', operationType);
+        ɵValidationUtilities.checkArgumentEmpty('_rootSchemaName', rootSchemaName);
+    }
+    // endregion
+    // region Methods: Public
+    /** {@inheritDoc ɵMetadataProvider.getMetadata} */
+    getMetadata() {
+        return classToPlain(this, { exposeUnsetFields: false, excludePrefixes: ['_'] });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/queries/delete-query.mjs

@@ -0,0 +1,14 @@
+import { ɵBaseFilterableQuery } from './base-filterable-query';
+import { ɵQueryOperationType } from './query-operation-type';
+/**
+ * @public
+ * @description Request to delete data.
+ * @extends {ɵBaseFilterableQuery}
+ */
+export class ɵDeleteQuery extends ɵBaseFilterableQuery {
+    // region Constructors: Public
+    constructor(rootSchemaName) {
+        super(ɵQueryOperationType.Delete, rootSchemaName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlLXF1ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kZXZraXQvYmFzZS9zcmMvbGliL3B1YmxpYy9lc3EvZGF0YS1tb2RlbC9xdWVyaWVzL2RlbGV0ZS1xdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUU3RDs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLFlBQWEsU0FBUSxvQkFBb0I7SUFDckQsOEJBQThCO0lBRTlCLFlBQVksY0FBc0I7UUFDakMsS0FBSyxDQUFDLG1CQUFtQixDQUFDLE1BQU0sRUFBRSxjQUFjLENBQUMsQ0FBQztJQUNuRCxDQUFDO0NBR0QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyDJtUJhc2VGaWx0ZXJhYmxlUXVlcnkgfSBmcm9tICcuL2Jhc2UtZmlsdGVyYWJsZS1xdWVyeSc7XG5pbXBvcnQgeyDJtVF1ZXJ5T3BlcmF0aW9uVHlwZSB9IGZyb20gJy4vcXVlcnktb3BlcmF0aW9uLXR5cGUnO1xuXG4vKipcbiAqIEBwdWJsaWNcbiAqIEBkZXNjcmlwdGlvbiBSZXF1ZXN0IHRvIGRlbGV0ZSBkYXRhLlxuICogQGV4dGVuZHMge8m1QmFzZUZpbHRlcmFibGVRdWVyeX1cbiAqL1xuZXhwb3J0IGNsYXNzIMm1RGVsZXRlUXVlcnkgZXh0ZW5kcyDJtUJhc2VGaWx0ZXJhYmxlUXVlcnkge1xuXHQvLyByZWdpb24gQ29uc3RydWN0b3JzOiBQdWJsaWNcblxuXHRjb25zdHJ1Y3Rvcihyb290U2NoZW1hTmFtZTogc3RyaW5nKSB7XG5cdFx0c3VwZXIoybVRdWVyeU9wZXJhdGlvblR5cGUuRGVsZXRlLCByb290U2NoZW1hTmFtZSk7XG5cdH1cblxuXHQvLyBlbmRyZWdpb25cbn1cbiJdfQ==

package/esm2022/lib/public/esq/data-model/queries/entity-schema-query.mjs

@@ -0,0 +1,242 @@
+import { classToPlain } from 'class-transformer';
+import { ɵBaseFilterableQuery } from './base-filterable-query';
+import { ɵQueryOperationType } from './query-operation-type';
+import { ɵItemNotFoundException, ɵValidationUtilities } from '../../../exceptions';
+import { ɵAggregationFunctionColumn, ɵAggregationSubQueryColumn, ɵArithmeticQueryColumn, ɵDatePartFunctionColumn, ɵEntityQueryColumn, ɵLengthFunctionColumn, ɵMacrosFunctionColumn, ɵParameterQueryColumn, ɵWindowFunctionColumn, } from '../columns';
+import { ɵAggregationEvalType, } from '../enums';
+import { ɵAggregationFunctionExpression, ɵColumnExpression } from '../expressions';
+/**
+ * @public
+ * @description The query class for data fetching.
+ * @extends {ɵBaseFilterableQuery}
+ */
+export class ɵEntitySchemaQuery extends ɵBaseFilterableQuery {
+    constructor(rootSchemaName) {
+        super(ɵQueryOperationType.Select, rootSchemaName);
+        this._columns = new Map();
+        /**
+         * @description Determines if merge duplicates in query result.
+         */
+        this.isDistinct = false;
+        /**
+         * @description Number of rows to select.
+         */
+        this.rowCount = -1;
+        /**
+         * @description Rows count to skip.
+         */
+        this.rowsOffset = -1;
+        /**
+         * @description The parameter that determines whether to use the localized data.
+         */
+        this.useLocalization = true;
+        /**
+         * @description Represent parameter which determines disabling data in filtering.
+         */
+        this.useRecordDeactivation = false;
+        this._getIsPageable = () => this.rowCount > 0 && this.rowsOffset > -1;
+    }
+    _internalAddColumn(key, column) {
+        if (!this._columns.has(key)) {
+            this._columns.set(key, column);
+        }
+    }
+    // endregion
+    // region Methods: Public
+    /**
+     * @public
+     * @description Returns column instance by column alias.
+     * @param columnAlias Column alias.
+     * @returns [BaseQueryColumn] Column instance.
+     */
+    getColumn(columnAlias) {
+        if (!this._columns.has(columnAlias)) {
+            throw new ɵItemNotFoundException(columnAlias);
+        }
+        return this.findColumn(columnAlias);
+    }
+    /**
+     * @public
+     * @description Returns column instance by column alias if not found returns null.
+     */
+    findColumn(columnAlias) {
+        return this._columns.get(columnAlias);
+    }
+    /** {@inheritDoc ɵMetadataProvider.getMetadata} */
+    getMetadata() {
+        return {
+            ...super.getMetadata(),
+            columns: {
+                items: classToPlain(this._columns, { exposeUnsetFields: false, excludePrefixes: ['_'] }),
+            },
+            allColumns: false,
+            isDistinct: this.isDistinct,
+            ignoreDisplayValues: false,
+            rowCount: this.rowCount,
+            rowsOffset: this.rowsOffset,
+            adminUnitRoleSources: this.adminUnitRoleSources,
+            isPageable: this._getIsPageable(),
+            conditionalValues: this.conditionalValues ? this.conditionalValues : null,
+            isHierarchical: false,
+            hierarchicalMaxDepth: 0,
+            hierarchicalColumnName: null,
+            hierarchicalColumnValue: null,
+            useLocalization: this.useLocalization,
+            useRecordDeactivation: this.useRecordDeactivation,
+        };
+    }
+    /**
+     * @public
+     * @description Add column.
+     * @param column Column path.
+     * @param columnAlias Column alias.
+     * @returns [BaseQueryColumn] Column instance.
+     */
+    addColumn(column, columnAlias) {
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add column by column path.
+     * @param columnPath Column path.
+     * @param columnAlias Column alias.
+     * @returns [EntityQueryColumn] Column instance.
+     */
+    addSchemaColumn(columnPath, columnAlias) {
+        ɵValidationUtilities.checkArgumentEmpty('columnPath', columnPath);
+        const column = new ɵEntityQueryColumn(columnPath);
+        this._internalAddColumn(columnAlias || columnPath, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add aggregation sub query column.
+     * @param columnPath Column path.
+     * @param aggregationType Aggregation type.
+     * @param subFilters Sub query filters.
+     * @param columnAlias Column alias.
+     * @returns [AggregationSubQueryColumn] Column instance.
+     */
+    addAggregationSubQueryColumn(columnPath, aggregationType, aggregationConfig, columnAlias) {
+        const column = new ɵAggregationSubQueryColumn(columnPath, aggregationType, aggregationConfig.filter, aggregationConfig.sortByDirection, aggregationConfig.sortByColumn);
+        this._internalAddColumn(columnAlias || columnPath, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add parameter column.
+     * @param value Parameter value.
+     * @param dataValueType Parameter data value type.
+     * @param columnAlias Column alias.
+     * @returns [ParameterQueryColumn] Column instance.
+     */
+    addParameterColumn(value, dataValueType, columnAlias) {
+        const column = new ɵParameterQueryColumn(value, dataValueType);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add arithmetic column.
+     * @param arithmeticOperation Arithmetic operation.
+     * @param leftArithmeticOperand Left arithmetic operand expression.
+     * @param rightArithmeticOperand Right arithmetic operand expression.
+     * @param columnAlias Column alias.
+     * @returns [ArithmeticQueryColumn] Column instance.
+     */
+    addArithmeticColumn(arithmeticOperation, leftArithmeticOperand, rightArithmeticOperand, columnAlias) {
+        const column = new ɵArithmeticQueryColumn(arithmeticOperation, leftArithmeticOperand, rightArithmeticOperand);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add macros function column.
+     * @param queryMacrosType Macros type.
+     * @param columnAlias Column alias.
+     * @returns [MacrosFunctionColumn] Column instance.
+     */
+    addMacrosFunctionColumn(queryMacrosType, columnAlias) {
+        const column = new ɵMacrosFunctionColumn(queryMacrosType);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add date part function column.
+     * @param columnPath Column path.
+     * @param datePartType Date part type.
+     * @param columnAlias Column alias.
+     * @returns [DatePartFunctionColumn] Column instance.
+     */
+    addDatePartFunctionColumn(columnPath, datePartType, columnAlias) {
+        const functionArgument = new ɵColumnExpression({ columnPath });
+        const column = new ɵDatePartFunctionColumn(datePartType, functionArgument);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add aggregation function column.
+     * @param columnPath Column path.
+     * @param aggregationType Aggregation type.
+     * @param columnAlias Column alias.
+     * @param aggregationEvalType Aggregation eval type.
+     * @returns [AggregationFunctionColumn] Column instance.
+     */
+    addAggregationFunctionColumn(columnPath, aggregationType, columnAlias, aggregationEvalType = ɵAggregationEvalType.None) {
+        const functionArgument = new ɵColumnExpression({ columnPath });
+        const column = new ɵAggregationFunctionColumn(aggregationType, aggregationEvalType, functionArgument);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add length function column.
+     * @param columnPath Column path.
+     * @param columnAlias Column alias.
+     * @returns [LengthFunctionColumn] Column instance.
+     */
+    addLengthFunctionColumn(columnPath, columnAlias) {
+        const functionArgument = new ɵColumnExpression({ columnPath });
+        const column = new ɵLengthFunctionColumn(functionArgument);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @public
+     * @description Add window function column.
+     * @param columnPath Column path.
+     * @param aggregationType Aggregation type.
+     * @param columnAlias Column alias.
+     * @param aggregationEvalType Aggregation eval type.
+     * @returns [WindowFunctionColumn] Column instance.
+     */
+    addWindowFunctionColumn(columnPath, aggregationType, columnAlias, aggregationEvalType = ɵAggregationEvalType.None) {
+        const functionArgument = new ɵAggregationFunctionExpression({
+            aggregationType,
+            aggregationEvalType,
+            functionArgument: new ɵColumnExpression({ columnPath }),
+        });
+        const column = new ɵWindowFunctionColumn(functionArgument);
+        this._internalAddColumn(columnAlias, column);
+        return column;
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        const usedColumns = [];
+        this._columns.forEach((column) => {
+            usedColumns.push(...column._getUsedColumns());
+        });
+        usedColumns.forEach((usedColumn) => {
+            if (!usedColumn.schemaName) {
+                usedColumn.schemaName = this.rootSchemaName;
+            }
+        });
+        return [...usedColumns, ...super._getUsedColumns()];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-schema-query.js","sourceRoot":"","sources":["../../../../../../../../../../libs/devkit/base/src/lib/public/esq/data-model/queries/entity-schema-query.ts"],"names":[],"mappings":"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","sourcesContent":["import { classToPlain } from 'class-transformer';\n\nimport { ɵBaseFilterableQuery } from './base-filterable-query';\nimport { ɵQueryOperationType } from './query-operation-type';\nimport { ɵAggregationType, ɵDataValueType } from '../../../enums';\nimport { ɵItemNotFoundException, ɵValidationUtilities } from '../../../exceptions';\nimport { ɵDataSourceAggregationConfig } from '../../../services/model/data-source-aggregation-config';\nimport { ɵEntityColumnValue } from '../../../types';\nimport {\n\tɵAggregationFunctionColumn,\n\tɵAggregationSubQueryColumn,\n\tɵArithmeticQueryColumn,\n\tɵBaseQueryColumn,\n\tɵDatePartFunctionColumn,\n\tɵEntityQueryColumn,\n\tɵLengthFunctionColumn,\n\tɵMacrosFunctionColumn,\n\tɵParameterQueryColumn,\n\tɵWindowFunctionColumn,\n} from '../columns';\nimport {\n\teAdminUnitRoleSources,\n\tɵAggregationEvalType,\n\tɵArithmeticOperation,\n\tɵDatePartType,\n\tɵExpressionType,\n\tɵQueryMacrosType,\n} from '../enums';\nimport { ɵAggregationFunctionExpression, ɵBaseExpression, ɵColumnExpression } from '../expressions';\nimport { UsedColumn } from '../used-column';\n\n/**\n * @public\n * @description Interface for condition with expression and parameter.\n * @property {ɵExpressionType} expressionType - Type of expression.\n * @property {Record<string, unknown>=} parameter - Parameter.\n */\nexport interface ɵConditionalValueItem {\n\t/**\n\t * @description Type of expression.\n\t */\n\texpressionType: ɵExpressionType;\n\t/**\n\t * @description Parameter.\n\t */\n\tparameter: {\n\t\tdataValueType: ɵDataValueType;\n\t\tvalue: string;\n\t};\n}\n\n/**\n * @public\n * @description The query class for data fetching.\n * @extends {ɵBaseFilterableQuery}\n */\nexport class ɵEntitySchemaQuery extends ɵBaseFilterableQuery {\n\tprivate _columns = new Map<string, ɵBaseQueryColumn>();\n\n\t/**\n\t * @description Determines if merge duplicates in query result.\n\t */\n\tpublic isDistinct = false;\n\n\t/**\n\t * @description Number of rows to select.\n\t */\n\tpublic rowCount = -1;\n\n\t/**\n\t * @description Rows count to skip.\n\t */\n\tpublic rowsOffset = -1;\n\n\t/**\n\t * @description Query conditional values\n\t */\n\tpublic conditionalValues?: null | { items: unknown };\n\n\t/**\n\t * @description The parameter that determines whether to use the localized data.\n\t */\n\tpublic useLocalization = true;\n\n\t/**\n\t * @description Represent parameter which determines disabling data in filtering.\n\t */\n\tpublic useRecordDeactivation = false;\n\n\t/**\n\t * @description Bit mask that indicates which role sources will be considered when checking record rights.\n\t */\n\tpublic adminUnitRoleSources?: eAdminUnitRoleSources;\n\n\tconstructor(rootSchemaName: string) {\n\t\tsuper(ɵQueryOperationType.Select, rootSchemaName);\n\t}\n\n\tprivate _internalAddColumn(key: string, column: ɵBaseQueryColumn): void {\n\t\tif (!this._columns.has(key)) {\n\t\t\tthis._columns.set(key, column);\n\t\t}\n\t}\n\n\tprivate _getIsPageable = (): boolean => this.rowCount > 0 && this.rowsOffset > -1;\n\n\t// endregion\n\n\t// region Methods: Public\n\n\t/**\n\t * @public\n\t * @description Returns column instance by column alias.\n\t * @param columnAlias Column alias.\n\t * @returns [BaseQueryColumn] Column instance.\n\t */\n\tpublic getColumn(columnAlias: string): ɵBaseQueryColumn {\n\t\tif (!this._columns.has(columnAlias)) {\n\t\t\tthrow new ɵItemNotFoundException(columnAlias);\n\t\t}\n\t\treturn this.findColumn(columnAlias);\n\t}\n\n\t/**\n\t * @public\n\t * @description Returns column instance by column alias if not found returns null.\n\t */\n\tpublic findColumn(columnAlias: string): ɵBaseQueryColumn {\n\t\treturn this._columns.get(columnAlias) as ɵBaseQueryColumn;\n\t}\n\n\t/** {@inheritDoc ɵMetadataProvider.getMetadata} */\n\tpublic getMetadata(): Record<string, unknown> {\n\t\treturn {\n\t\t\t...super.getMetadata(),\n\t\t\tcolumns: {\n\t\t\t\titems: classToPlain(this._columns, { exposeUnsetFields: false, excludePrefixes: ['_'] }),\n\t\t\t},\n\t\t\tallColumns: false,\n\t\t\tisDistinct: this.isDistinct,\n\t\t\tignoreDisplayValues: false,\n\t\t\trowCount: this.rowCount,\n\t\t\trowsOffset: this.rowsOffset,\n\t\t\tadminUnitRoleSources: this.adminUnitRoleSources,\n\t\t\tisPageable: this._getIsPageable(),\n\t\t\tconditionalValues: this.conditionalValues ? this.conditionalValues : null,\n\t\t\tisHierarchical: false,\n\t\t\thierarchicalMaxDepth: 0,\n\t\t\thierarchicalColumnName: null,\n\t\t\thierarchicalColumnValue: null,\n\t\t\tuseLocalization: this.useLocalization,\n\t\t\tuseRecordDeactivation: this.useRecordDeactivation,\n\t\t};\n\t}\n\n\t/**\n\t * @public\n\t * @description Add column.\n\t * @param column Column path.\n\t * @param columnAlias Column alias.\n\t * @returns [BaseQueryColumn] Column instance.\n\t */\n\tpublic addColumn(column: ɵBaseQueryColumn, columnAlias: string): ɵBaseQueryColumn {\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add column by column path.\n\t * @param columnPath Column path.\n\t * @param columnAlias Column alias.\n\t * @returns [EntityQueryColumn] Column instance.\n\t */\n\tpublic addSchemaColumn(columnPath: string, columnAlias?: string): ɵEntityQueryColumn {\n\t\tɵValidationUtilities.checkArgumentEmpty('columnPath', columnPath);\n\t\tconst column = new ɵEntityQueryColumn(columnPath);\n\t\tthis._internalAddColumn(columnAlias || columnPath, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add aggregation sub query column.\n\t * @param columnPath Column path.\n\t * @param aggregationType Aggregation type.\n\t * @param subFilters Sub query filters.\n\t * @param columnAlias Column alias.\n\t * @returns [AggregationSubQueryColumn] Column instance.\n\t */\n\tpublic addAggregationSubQueryColumn(\n\t\tcolumnPath: string,\n\t\taggregationType: ɵAggregationType,\n\t\taggregationConfig: ɵDataSourceAggregationConfig,\n\t\tcolumnAlias?: string,\n\t): ɵAggregationSubQueryColumn {\n\t\tconst column = new ɵAggregationSubQueryColumn(\n\t\t\tcolumnPath,\n\t\t\taggregationType,\n\t\t\taggregationConfig.filter,\n\t\t\taggregationConfig.sortByDirection,\n\t\t\taggregationConfig.sortByColumn,\n\t\t);\n\t\tthis._internalAddColumn(columnAlias || columnPath, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add parameter column.\n\t * @param value Parameter value.\n\t * @param dataValueType Parameter data value type.\n\t * @param columnAlias Column alias.\n\t * @returns [ParameterQueryColumn] Column instance.\n\t */\n\tpublic addParameterColumn(\n\t\tvalue: ɵEntityColumnValue,\n\t\tdataValueType: ɵDataValueType,\n\t\tcolumnAlias: string,\n\t): ɵParameterQueryColumn {\n\t\tconst column = new ɵParameterQueryColumn(value, dataValueType);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add arithmetic column.\n\t * @param arithmeticOperation Arithmetic operation.\n\t * @param leftArithmeticOperand Left arithmetic operand expression.\n\t * @param rightArithmeticOperand Right arithmetic operand expression.\n\t * @param columnAlias Column alias.\n\t * @returns [ArithmeticQueryColumn] Column instance.\n\t */\n\tpublic addArithmeticColumn(\n\t\tarithmeticOperation: ɵArithmeticOperation,\n\t\tleftArithmeticOperand: ɵBaseExpression,\n\t\trightArithmeticOperand: ɵBaseExpression,\n\t\tcolumnAlias: string,\n\t): ɵArithmeticQueryColumn {\n\t\tconst column = new ɵArithmeticQueryColumn(arithmeticOperation, leftArithmeticOperand, rightArithmeticOperand);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add macros function column.\n\t * @param queryMacrosType Macros type.\n\t * @param columnAlias Column alias.\n\t * @returns [MacrosFunctionColumn] Column instance.\n\t */\n\tpublic addMacrosFunctionColumn(queryMacrosType: ɵQueryMacrosType, columnAlias: string): ɵMacrosFunctionColumn {\n\t\tconst column = new ɵMacrosFunctionColumn(queryMacrosType);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add date part function column.\n\t * @param columnPath Column path.\n\t * @param datePartType Date part type.\n\t * @param columnAlias Column alias.\n\t * @returns [DatePartFunctionColumn] Column instance.\n\t */\n\tpublic addDatePartFunctionColumn(\n\t\tcolumnPath: string,\n\t\tdatePartType: ɵDatePartType,\n\t\tcolumnAlias: string,\n\t): ɵDatePartFunctionColumn {\n\t\tconst functionArgument = new ɵColumnExpression({ columnPath });\n\t\tconst column = new ɵDatePartFunctionColumn(datePartType, functionArgument);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add aggregation function column.\n\t * @param columnPath Column path.\n\t * @param aggregationType Aggregation type.\n\t * @param columnAlias Column alias.\n\t * @param aggregationEvalType Aggregation eval type.\n\t * @returns [AggregationFunctionColumn] Column instance.\n\t */\n\tpublic addAggregationFunctionColumn(\n\t\tcolumnPath: string,\n\t\taggregationType: ɵAggregationType,\n\t\tcolumnAlias: string,\n\t\taggregationEvalType: ɵAggregationEvalType = ɵAggregationEvalType.None,\n\t): ɵAggregationFunctionColumn {\n\t\tconst functionArgument = new ɵColumnExpression({ columnPath });\n\t\tconst column = new ɵAggregationFunctionColumn(aggregationType, aggregationEvalType, functionArgument);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add length function column.\n\t * @param columnPath Column path.\n\t * @param columnAlias Column alias.\n\t * @returns [LengthFunctionColumn] Column instance.\n\t */\n\tpublic addLengthFunctionColumn(columnPath: string, columnAlias: string): ɵLengthFunctionColumn {\n\t\tconst functionArgument = new ɵColumnExpression({ columnPath });\n\t\tconst column = new ɵLengthFunctionColumn(functionArgument);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @public\n\t * @description Add window function column.\n\t * @param columnPath Column path.\n\t * @param aggregationType Aggregation type.\n\t * @param columnAlias Column alias.\n\t * @param aggregationEvalType Aggregation eval type.\n\t * @returns [WindowFunctionColumn] Column instance.\n\t */\n\tpublic addWindowFunctionColumn(\n\t\tcolumnPath: string,\n\t\taggregationType: ɵAggregationType,\n\t\tcolumnAlias: string,\n\t\taggregationEvalType: ɵAggregationEvalType = ɵAggregationEvalType.None,\n\t): ɵWindowFunctionColumn {\n\t\tconst functionArgument = new ɵAggregationFunctionExpression({\n\t\t\taggregationType,\n\t\t\taggregationEvalType,\n\t\t\tfunctionArgument: new ɵColumnExpression({ columnPath }),\n\t\t});\n\t\tconst column = new ɵWindowFunctionColumn(functionArgument);\n\t\tthis._internalAddColumn(columnAlias, column);\n\t\treturn column;\n\t}\n\n\t/**\n\t * @internal\n\t */\n\tpublic _getUsedColumns(): UsedColumn[] {\n\t\tconst usedColumns: UsedColumn[] = [];\n\t\tthis._columns.forEach((column) => {\n\t\t\tusedColumns.push(...column._getUsedColumns());\n\t\t});\n\t\tusedColumns.forEach((usedColumn) => {\n\t\t\tif (!usedColumn.schemaName) {\n\t\t\t\tusedColumn.schemaName = this.rootSchemaName;\n\t\t\t}\n\t\t});\n\t\treturn [...usedColumns, ...super._getUsedColumns()];\n\t}\n}\n"]}