@creatio/base 0.810.0 → 0.811.1

package/fesm2020/creatio-base.mjs

@@ -1,5 +1,5 @@
+import { classToPlain, Exclude, Expose } from 'class-transformer';
 import { __decorate, __metadata } from 'tslib';
-import { Exclude, classToPlain, Expose } from 'class-transformer';
 
 /**
  * @public
@@ -203,6 +203,7 @@ var ɵArithmeticOperation;
     ɵArithmeticOperation[ɵArithmeticOperation["Division"] = 3] = "Division";
 })(ɵArithmeticOperation || (ɵArithmeticOperation = {}));
 
+/* eslint-disable @typescript-eslint/naming-convention */
 var ɵComparisonType;
 (function (ɵComparisonType) {
     ɵComparisonType[ɵComparisonType["Between"] = 0] = "Between";
@@ -367,6 +368,17 @@ var ɵQueryMacrosType;
 })(ɵQueryMacrosType || (ɵQueryMacrosType = {}));
 
 class ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [this._instanceOfKey];
+    }
+    static [Symbol.hasInstance](instance) {
+        const instanceOfKeys = instance?.constructor?.['_instanceOfKeys'] ?? [];
+        return instanceOfKeys.includes(this._instanceOfKey);
+    }
     constructor(config) {
         this.isBlock = false;
         this.isBlock = config?.isBlock;
@@ -378,9 +390,39 @@ class ɵBaseExpression {
     static fromJson(dto, filterParser, expressionParser) {
         throw new Error(`fromJson not supported on expression type ${this.constructor.name}`);
     }
+    serializeItem(item) {
+        return typeof item.toJson === 'function'
+            ? item.toJson()
+            : classToPlain(item, {
+                exposeUnsetFields: false,
+                excludePrefixes: ['_'],
+            });
+    }
+    /**
+     * Converts instance to json object.
+     * @public
+     */
+    toJson() {
+        return classToPlain(this, {
+            exposeUnsetFields: false,
+            excludePrefixes: ['_'],
+        });
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵBaseExpression._instanceOfKey = 'devkit_BaseExpression';
 
 class ɵArithmeticExpression extends ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.expressionType = ɵExpressionType.ArithmeticOperation;
@@ -407,8 +449,20 @@ class ɵArithmeticExpression extends ɵBaseExpression {
         return new ɵArithmeticExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵArithmeticExpression._instanceOfKey = 'devkit_ArithmeticExpression';
 
 class ɵColumnExpression extends ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.expressionType = ɵExpressionType.SchemaColumn;
@@ -426,6 +480,11 @@ class ɵColumnExpression extends ɵBaseExpression {
         return new ɵColumnExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵColumnExpression._instanceOfKey = 'devkit_ColumnExpression';
 
 /**
  * Expression parser interface
@@ -438,20 +497,58 @@ class ɵBaseExpressionParser {
 }
 
 class ɵFunctionExpression extends ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.expressionType = ɵExpressionType.Function;
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵFunctionExpression._instanceOfKey = 'devkit_FunctionExpression';
 
 class ɵArgumentFunctionExpression extends ɵFunctionExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵFunctionExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.functionArgument = config?.functionArgument.clone();
     }
+    toJson() {
+        const result = super.toJson();
+        if (this.functionArgument) {
+            result['functionArgument'] = this.serializeItem(this.functionArgument);
+        }
+        return result;
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵArgumentFunctionExpression._instanceOfKey = 'devkit_ArgumentFunctionExpression';
 
 class ɵAggregationFunctionExpression extends ɵArgumentFunctionExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵArgumentFunctionExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.functionType = ɵFunctionType.Aggregation;
@@ -477,8 +574,20 @@ class ɵAggregationFunctionExpression extends ɵArgumentFunctionExpression {
         return new ɵAggregationFunctionExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵAggregationFunctionExpression._instanceOfKey = 'devkit_AggregationFunctionExpression';
 
 class ɵDatePartFunctionExpression extends ɵArgumentFunctionExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵArgumentFunctionExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.functionType = ɵFunctionType.DatePart;
@@ -497,8 +606,20 @@ class ɵDatePartFunctionExpression extends ɵArgumentFunctionExpression {
         return new ɵDatePartFunctionExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵDatePartFunctionExpression._instanceOfKey = 'devkit_DatePartFunctionExpression';
 
 class ɵLengthFunctionExpression extends ɵArgumentFunctionExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵArgumentFunctionExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.functionType = ɵFunctionType.Length;
@@ -515,8 +636,20 @@ class ɵLengthFunctionExpression extends ɵArgumentFunctionExpression {
         return new ɵLengthFunctionExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵLengthFunctionExpression._instanceOfKey = 'devkit_LengthFunctionExpression';
 
 class ɵMacrosFunctionExpression extends ɵFunctionExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵFunctionExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.functionType = ɵFunctionType.Macros;
@@ -534,8 +667,20 @@ class ɵMacrosFunctionExpression extends ɵFunctionExpression {
         return new ɵMacrosFunctionExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵMacrosFunctionExpression._instanceOfKey = 'devkit_MacrosFunctionExpression';
 
 class ɵWindowFunctionExpression extends ɵArgumentFunctionExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵArgumentFunctionExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.functionType = ɵFunctionType.Window;
@@ -552,8 +697,20 @@ class ɵWindowFunctionExpression extends ɵArgumentFunctionExpression {
         return new ɵWindowFunctionExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵWindowFunctionExpression._instanceOfKey = 'devkit_WindowFunctionExpression';
 
 class ɵParameterExpression extends ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.expressionType = ɵExpressionType.Parameter;
@@ -626,6 +783,11 @@ class ɵParameterExpression extends ɵBaseExpression {
         return new ɵParameterExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵParameterExpression._instanceOfKey = 'devkit_ParameterExpression';
 __decorate([
     Exclude(),
     __metadata("design:type", Object)
@@ -636,6 +798,13 @@ __decorate([
 ], ɵParameterExpression.prototype, "dataValueType", void 0);
 
 class ɵSubQueryExpression extends ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.expressionType = ɵExpressionType.SubQuery;
@@ -661,9 +830,28 @@ class ɵSubQueryExpression extends ɵBaseExpression {
     clone() {
         return new ɵSubQueryExpression(this);
     }
+    toJson() {
+        const result = super.toJson();
+        if (this.subFilters) {
+            result['subFilters'] = this.serializeItem(this.subFilters);
+        }
+        return result;
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵSubQueryExpression._instanceOfKey = 'devkit_SubQueryExpression';
 
 class ɵAggregationSubQueryExpression extends ɵSubQueryExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSubQueryExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config);
         this.aggregationType = config?.aggregationType;
@@ -686,6 +874,11 @@ class ɵAggregationSubQueryExpression extends ɵSubQueryExpression {
         return new ɵAggregationSubQueryExpression(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵAggregationSubQueryExpression._instanceOfKey = 'devkit_AggregationSubQueryExpression';
 
 /**
  * Function expression resolver.
@@ -738,6 +931,13 @@ class ɵExpressionParser extends ɵBaseExpressionParser {
 
 const ɵEXPRESSION_TYPE_MOCK = -1;
 class ɵExpressionMock extends ɵBaseExpression {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseExpression._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(config) {
         super(config || {});
         this.expressionType = ɵEXPRESSION_TYPE_MOCK;
@@ -750,8 +950,24 @@ class ɵExpressionMock extends ɵBaseExpression {
         return new ɵExpressionMock(this);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵExpressionMock._instanceOfKey = 'devkit_ExpressionMock';
 
 class ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [this._instanceOfKey];
+    }
+    static [Symbol.hasInstance](instance) {
+        const instanceOfKeys = instance?.constructor?.['_instanceOfKeys'] ?? [];
+        return instanceOfKeys.includes(this._instanceOfKey);
+    }
     constructor(filterType) {
         this.isEnabled = true;
         this.trimDateTimeParameterToDate = false;
@@ -764,9 +980,39 @@ class ɵBaseFilter {
     static fromJson(dto, filterParser, expressionParser) {
         throw new Error(`fromJson not supported on filter type ${this.constructor.name}`);
     }
+    serializeItem(item) {
+        return typeof item.toJson === 'function'
+            ? item.toJson()
+            : classToPlain(item, {
+                exposeUnsetFields: false,
+                excludePrefixes: ['_'],
+            });
+    }
+    /**
+     * Converts instance to json object.
+     * @public
+     */
+    toJson() {
+        return classToPlain(this, {
+            exposeUnsetFields: false,
+            excludePrefixes: ['_'],
+        });
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵBaseFilter._instanceOfKey = 'devkit_BaseFilter';
 
 class ɵFilterMock extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(filterType = ɵFilterType.None) {
         super(filterType);
     }
@@ -778,6 +1024,11 @@ class ɵFilterMock extends ɵBaseFilter {
         return new ɵFilterMock(this.filterType);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵFilterMock._instanceOfKey = 'devkit_FilterMock';
 
 const ɵparserMock = {
     fromJson: (data) => ({
@@ -788,14 +1039,39 @@ const ɵparserMock = {
 };
 
 class ɵSingleFilter extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(filterType, comparisonType, leftExpression) {
         super(filterType);
         this.comparisonType = comparisonType;
         this.leftExpression = leftExpression.clone();
     }
+    toJson() {
+        return {
+            ...super.toJson(),
+            leftExpression: this.serializeItem(this.leftExpression),
+        };
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵSingleFilter._instanceOfKey = 'devkit_SingleFilter';
 
 class ɵCompareFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(comparisonType, leftExpression, rightExpression) {
         super(ɵFilterType.Compare, comparisonType, leftExpression);
         this.rightExpression = rightExpression.clone();
@@ -811,9 +1087,27 @@ class ɵCompareFilter extends ɵSingleFilter {
     clone() {
         return new ɵCompareFilter(this.comparisonType, this.leftExpression, this.rightExpression);
     }
+    toJson() {
+        return {
+            ...super.toJson(),
+            rightExpression: this.serializeItem(this.rightExpression),
+        };
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵCompareFilter._instanceOfKey = 'devkit_CompareFilter';
 
 class ɵBetweenFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(leftExpression, rightLessExpression, rightGreaterExpression) {
         super(ɵFilterType.Between, ɵComparisonType.Between, leftExpression);
         this.rightLessExpression = rightLessExpression.clone();
@@ -830,9 +1124,28 @@ class ɵBetweenFilter extends ɵSingleFilter {
     clone() {
         return new ɵBetweenFilter(this.leftExpression, this.rightLessExpression, this.rightGreaterExpression);
     }
+    toJson() {
+        return {
+            ...super.toJson(),
+            rightLessExpression: this.serializeItem(this.rightLessExpression),
+            rightGreaterExpression: this.serializeItem(this.rightGreaterExpression),
+        };
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵBetweenFilter._instanceOfKey = 'devkit_BetweenFilter';
 
 class ɵExistsFilter extends ɵSingleFilter {
+    /**
+     * @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();
@@ -850,9 +1163,28 @@ class ɵExistsFilter extends ɵSingleFilter {
     clone() {
         return new ɵExistsFilter(this.leftExpression, this.subFilters, this.comparisonType, this.isAggregative);
     }
+    toJson() {
+        const result = super.toJson();
+        if (this.subFilters) {
+            result['subFilters'] = this.serializeItem(this.subFilters);
+        }
+        return result;
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵExistsFilter._instanceOfKey = 'devkit_ExistsFilter';
 
 class ɵInFilter extends ɵSingleFilter {
+    /**
+     * @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());
@@ -868,9 +1200,27 @@ class ɵInFilter extends ɵSingleFilter {
     clone() {
         return new ɵInFilter(this.comparisonType, this.leftExpression, this.rightExpressions);
     }
+    toJson() {
+        return {
+            ...super.toJson(),
+            rightExpressions: this.rightExpressions.map((expression) => this.serializeItem(expression)),
+        };
+    }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵInFilter._instanceOfKey = 'devkit_InFilter';
 
 class ɵIsNullFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
     constructor(comparisonType, leftExpression) {
         super(ɵFilterType.IsNull, comparisonType, leftExpression);
     }
@@ -888,6 +1238,11 @@ class ɵIsNullFilter extends ɵSingleFilter {
         return new ɵIsNullFilter(this.comparisonType, this.leftExpression);
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵIsNullFilter._instanceOfKey = 'devkit_IsNullFilter';
 __decorate([
     Expose(),
     __metadata("design:type", Boolean),
@@ -1008,11 +1363,19 @@ class ɵValidationUtilities {
 }
 
 class ɵFilterGroup extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
     get items() {
-        return classToPlain(this.filters, {
-            exposeUnsetFields: false,
-            excludePrefixes: ['_'],
+        const result = {};
+        this.filters.forEach((filter, key) => {
+            result[key] = this.serializeItem(filter);
         });
+        return result;
     }
     constructor(logicalOperation = ɵLogicalOperatorType.And) {
         super(ɵFilterType.FilterGroup);
@@ -1052,18 +1415,25 @@ class ɵFilterGroup extends ɵBaseFilter {
         const filter = new ɵCompareFilter(comparisonType, leftExpression, rightExpression);
         this.add(filter, filterKey);
     }
-    addSchemaColumnInFilterWithParameters(comparisonType, columnPath, parameterValues) {
+    /**
+     * 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 = parameterValues.map((singleParameterValue) => new ɵParameterExpression({
             value: singleParameterValue,
         }));
         const filter = new ɵInFilter(comparisonType, leftExpression, expressions);
-        this.add(filter);
+        this.add(filter, filterKey);
     }
-    addSchemaColumnIsNullFilter(columnPath) {
+    addSchemaColumnIsNullFilter(columnPath, filterKey) {
         const leftExpression = new ɵColumnExpression({ columnPath });
         const filter = new ɵIsNullFilter(ɵComparisonType.Is_null, leftExpression);
-        this.add(filter);
+        this.add(filter, filterKey);
     }
     /**
      * Creates and adds not null filter.
@@ -1080,23 +1450,24 @@ class ɵFilterGroup extends ɵBaseFilter {
      * @param columnPath Column path.
      * @param lessParamValue Less parameter value.
      * @param greaterParamValue Greater parameter value.
+     * @param filterKey Filter key.
      */
-    addSchemaColumnBetweenFilterWithParameters(columnPath, lessParamValue, greaterParamValue) {
+    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);
+        this.add(filter, filterKey);
     }
-    addExistsFilter(columnPath, subFilters) {
+    addExistsFilter(columnPath, subFilters, filterKey) {
         const leftExpression = new ɵColumnExpression({ columnPath });
         const filter = new ɵExistsFilter(leftExpression, subFilters);
-        this.add(filter);
+        this.add(filter, filterKey);
     }
-    addNotExistsFilter(columnPath, subFilters) {
+    addNotExistsFilter(columnPath, subFilters, filterKey) {
         const leftExpression = new ɵColumnExpression({ columnPath });
         const filter = new ɵExistsFilter(leftExpression, subFilters, ɵComparisonType.Not_exists);
-        this.add(filter);
+        this.add(filter, filterKey);
     }
     add(filter, filterKey) {
         ɵValidationUtilities.checkArgumentEmpty('filter', filter);
@@ -1111,6 +1482,11 @@ class ɵFilterGroup extends ɵBaseFilter {
         return filterGroup;
     }
 }
+/**
+ * @internal
+ * @dontChange
+ */
+ɵFilterGroup._instanceOfKey = 'devkit_FilterGroup';
 __decorate([
     Exclude(),
     __metadata("design:type", Object)
@@ -1343,6 +1719,12 @@ class ɵBaseFilterableQuery extends ɵBaseQuery {
     clearFilters() {
         this.filters.filters.clear();
     }
+    getMetadata() {
+        return {
+            ...super.getMetadata(),
+            filters: this.filters.toJson(),
+        };
+    }
 }
 
 /**