@gooddata/typings - npm Package Compare versions

Comparing version 2.18.0 to 2.19.0

dist/src/AFM.d.ts

@@ -220,2 +220,3 @@ /**
     function isMeasureValueFilter(filter: AFM.CompatibilityFilter): filter is AFM.IMeasureValueFilter;
+    function isExpressionFilter(filter: AFM.CompatibilityFilter): filter is AFM.IExpressionFilter;
 }

dist/src/AFM.js

@@ -85,3 +85,7 @@ "use strict";
     AFM.isMeasureValueFilter = isMeasureValueFilter;
+    function isExpressionFilter(filter) {
+        return !isEmpty(filter) && filter.value !== undefined;
+    }
+    AFM.isExpressionFilter = isExpressionFilter;
 })(AFM = exports.AFM || (exports.AFM = {}));
 //# sourceMappingURL=AFM.js.map

dist/src/ExecuteAFM.d.ts

@@ -220,2 +220,3 @@ /**
     function isMeasureValueFilter(filter: ExecuteAFM.CompatibilityFilter): filter is ExecuteAFM.IMeasureValueFilter;
+    function isExpressionFilter(filter: ExecuteAFM.CompatibilityFilter): filter is ExecuteAFM.IExpressionFilter;
     function isAttributeElementsArray(attributeElements: AttributeElements): attributeElements is string[];
@@ -222,0 +223,0 @@ function isAttributeElementsByRef(attributeElements: ExecuteAFM.AttributeElements): attributeElements is ExecuteAFM.IAttributeElementsByRef;

dist/src/ExecuteAFM.js

@@ -85,2 +85,6 @@ "use strict";
     ExecuteAFM.isMeasureValueFilter = isMeasureValueFilter;
+    function isExpressionFilter(filter) {
+        return !isEmpty(filter) && filter.value !== undefined;
+    }
+    ExecuteAFM.isExpressionFilter = isExpressionFilter;
     function isAttributeElementsArray(attributeElements) {
@@ -87,0 +91,0 @@ return attributeElements !== undefined && attributeElements instanceof Array;

dist/src/tests/AFM.test.js

@@ -383,2 +383,47 @@ "use strict";
     });
+    var expressionFilter = {
+        value: 'MAQL'
+    };
+    var relativeDateFilter = {
+        relativeDateFilter: {
+            dataSet: {
+                uri: '/gdc/mock/ds'
+            },
+            granularity: 'gram',
+            from: -10,
+            to: 0
+        }
+    };
+    var absoluteDateFilter = {
+        absoluteDateFilter: {
+            dataSet: {
+                uri: '/gdc/mock/ds'
+            },
+            from: '1',
+            to: '2'
+        }
+    };
+    var negativeAttributeFilter = {
+        negativeAttributeFilter: {
+            displayForm: {
+                uri: '/gdc/mock/date'
+            },
+            notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
+        }
+    };
+    var positiveAttributeFilter = {
+        positiveAttributeFilter: {
+            displayForm: {
+                uri: '/gdc/mock/attribute'
+            },
+            "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
+        }
+    };
+    var measureValueFilter = {
+        measureValueFilter: {
+            measure: {
+                uri: '/gdc/mock/date'
+            }
+        }
+    };
     describe('isDateFilter', function () {
@@ -394,52 +439,25 @@ it('should return false when null is tested', function () {
         it('should return true when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = AFM_1.AFM.isDateFilter(filter);
+            var result = AFM_1.AFM.isDateFilter(relativeDateFilter);
             expect(result).toEqual(true);
         });
         it('should return true when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = AFM_1.AFM.isDateFilter(filter);
+            var result = AFM_1.AFM.isDateFilter(absoluteDateFilter);
             expect(result).toEqual(true);
         });
         it('should return false when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isDateFilter(filter);
+            var result = AFM_1.AFM.isDateFilter(negativeAttributeFilter);
             expect(result).toEqual(false);
         });
         it('should return false when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isDateFilter(filter);
+            var result = AFM_1.AFM.isDateFilter(positiveAttributeFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isDateFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isDateFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -456,28 +474,25 @@ describe('isRelativeDateFilter', function () {
         it('should return true when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = AFM_1.AFM.isRelativeDateFilter(filter);
+            var result = AFM_1.AFM.isRelativeDateFilter(relativeDateFilter);
             expect(result).toEqual(true);
         });
-        it('should return false when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = AFM_1.AFM.isRelativeDateFilter(filter);
+        it('should return true when absolute date filter is tested', function () {
+            var result = AFM_1.AFM.isRelativeDateFilter(absoluteDateFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = AFM_1.AFM.isRelativeDateFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when positive attribute filter is tested', function () {
+            var result = AFM_1.AFM.isRelativeDateFilter(positiveAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isRelativeDateFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isRelativeDateFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -493,29 +508,26 @@ describe('isAbsoluteDateFilter', function () {
         });
-        it('should return false when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = AFM_1.AFM.isAbsoluteDateFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = AFM_1.AFM.isAbsoluteDateFilter(relativeDateFilter);
             expect(result).toEqual(false);
         });
         it('should return true when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = AFM_1.AFM.isAbsoluteDateFilter(filter);
+            var result = AFM_1.AFM.isAbsoluteDateFilter(absoluteDateFilter);
             expect(result).toEqual(true);
         });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = AFM_1.AFM.isAbsoluteDateFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when positive attribute filter is tested', function () {
+            var result = AFM_1.AFM.isAbsoluteDateFilter(positiveAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isAbsoluteDateFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isAbsoluteDateFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -531,51 +543,24 @@ describe('isAttributeFilter', function () {
         });
-        it('should return true when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isAttributeFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = AFM_1.AFM.isAttributeFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = AFM_1.AFM.isAttributeFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = AFM_1.AFM.isAttributeFilter(negativeAttributeFilter);
             expect(result).toEqual(true);
         });
-        it('should return true when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isAttributeFilter(filter);
+        it('should return false when positive attribute filter is tested', function () {
+            var result = AFM_1.AFM.isAttributeFilter(positiveAttributeFilter);
             expect(result).toEqual(true);
         });
-        it('should return false when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = AFM_1.AFM.isAttributeFilter(filter);
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isAttributeFilter(measureValueFilter);
             expect(result).toEqual(false);
         });
-        it('should return false when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = AFM_1.AFM.isAttributeFilter(filter);
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isAttributeFilter(expressionFilter);
             expect(result).toEqual(false);
@@ -593,26 +578,26 @@ });
         });
+        it('should return true when relative date filter is tested', function () {
+            var result = AFM_1.AFM.isPositiveAttributeFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = AFM_1.AFM.isPositiveAttributeFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
         it('should return false when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isPositiveAttributeFilter(filter);
+            var result = AFM_1.AFM.isPositiveAttributeFilter(negativeAttributeFilter);
             expect(result).toEqual(false);
         });
-        it('should return true when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isPositiveAttributeFilter(filter);
+        it('should return false when positive attribute filter is tested', function () {
+            var result = AFM_1.AFM.isPositiveAttributeFilter(positiveAttributeFilter);
             expect(result).toEqual(true);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isPositiveAttributeFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isPositiveAttributeFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -628,26 +613,26 @@ describe('isNegativeAttributeFilter', function () {
         });
-        it('should return true when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isNegativeAttributeFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = AFM_1.AFM.isNegativeAttributeFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = AFM_1.AFM.isNegativeAttributeFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = AFM_1.AFM.isNegativeAttributeFilter(negativeAttributeFilter);
             expect(result).toEqual(true);
         });
         it('should return false when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isNegativeAttributeFilter(filter);
+            var result = AFM_1.AFM.isNegativeAttributeFilter(positiveAttributeFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isNegativeAttributeFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isNegativeAttributeFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -663,27 +648,62 @@ describe('isMeasureValueFilter', function () {
         });
-        it('should return true when measure value filter is tested', function () {
-            var filter = {
-                measureValueFilter: {
-                    measure: {
-                        uri: '/gdc/mock/date'
-                    }
-                }
-            };
-            var result = AFM_1.AFM.isMeasureValueFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = AFM_1.AFM.isMeasureValueFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = AFM_1.AFM.isMeasureValueFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = AFM_1.AFM.isMeasureValueFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when positive attribute filter is tested', function () {
+            var result = AFM_1.AFM.isMeasureValueFilter(positiveAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isMeasureValueFilter(measureValueFilter);
             expect(result).toEqual(true);
         });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isMeasureValueFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
+    });
+    describe('isExpressionFilter', function () {
+        it('should return false when null is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(null);
+            expect(result).toEqual(false);
+        });
+        it('should return false when undefined is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(undefined);
+            expect(result).toEqual(false);
+        });
+        it('should return true when relative date filter is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
         it('should return false when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = AFM_1.AFM.isMeasureValueFilter(filter);
+            var result = AFM_1.AFM.isExpressionFilter(positiveAttributeFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = AFM_1.AFM.isExpressionFilter(expressionFilter);
+            expect(result).toEqual(true);
+        });
     });
 });
 //# sourceMappingURL=AFM.test.js.map

dist/src/tests/ExecuteAFM.test.js

@@ -6,2 +6,47 @@ "use strict";
 describe('AFM', function () {
+    var expressionFilter = {
+        value: 'MAQL'
+    };
+    var relativeDateFilter = {
+        relativeDateFilter: {
+            dataSet: {
+                uri: '/gdc/mock/ds'
+            },
+            granularity: 'gram',
+            from: -10,
+            to: 0
+        }
+    };
+    var absoluteDateFilter = {
+        absoluteDateFilter: {
+            dataSet: {
+                uri: '/gdc/mock/ds'
+            },
+            from: '1',
+            to: '2'
+        }
+    };
+    var negativeAttributeFilter = {
+        negativeAttributeFilter: {
+            displayForm: {
+                uri: '/gdc/mock/date'
+            },
+            notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
+        }
+    };
+    var positiveAttributeFilter = {
+        positiveAttributeFilter: {
+            displayForm: {
+                uri: '/gdc/mock/attribute'
+            },
+            "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
+        }
+    };
+    var measureValueFilter = {
+        measureValueFilter: {
+            measure: {
+                uri: '/gdc/mock/date'
+            }
+        }
+    };
     describe('isDateFilter', function () {
@@ -17,52 +62,25 @@ it('should return false when null is tested', function () {
         it('should return true when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(relativeDateFilter);
             expect(result).toEqual(true);
         });
         it('should return true when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(absoluteDateFilter);
             expect(result).toEqual(true);
         });
         it('should return false when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(negativeAttributeFilter);
             expect(result).toEqual(false);
         });
         it('should return false when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(positiveAttributeFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isDateFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -79,28 +97,25 @@ describe('isRelativeDateFilter', function () {
         it('should return true when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(relativeDateFilter);
             expect(result).toEqual(true);
         });
-        it('should return false when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(filter);
+        it('should return true when absolute date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(absoluteDateFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when positive attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(positiveAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isRelativeDateFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -116,29 +131,26 @@ describe('isAbsoluteDateFilter', function () {
         });
-        it('should return false when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(relativeDateFilter);
             expect(result).toEqual(false);
         });
         it('should return true when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(absoluteDateFilter);
             expect(result).toEqual(true);
         });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when positive attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(positiveAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAbsoluteDateFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -154,51 +166,24 @@ describe('isAttributeFilter', function () {
         });
-        it('should return true when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(negativeAttributeFilter);
             expect(result).toEqual(true);
         });
-        it('should return true when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(filter);
+        it('should return false when positive attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(positiveAttributeFilter);
             expect(result).toEqual(true);
         });
-        it('should return false when absolute date filter is tested', function () {
-            var filter = {
-                absoluteDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    from: '1',
-                    to: '2'
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(filter);
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(measureValueFilter);
             expect(result).toEqual(false);
         });
-        it('should return false when relative date filter is tested', function () {
-            var filter = {
-                relativeDateFilter: {
-                    dataSet: {
-                        uri: '/gdc/mock/ds'
-                    },
-                    granularity: 'gram',
-                    from: -10,
-                    to: 0
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(filter);
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isAttributeFilter(expressionFilter);
             expect(result).toEqual(false);
@@ -216,26 +201,26 @@ });
         });
+        it('should return true when relative date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
         it('should return false when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(negativeAttributeFilter);
             expect(result).toEqual(false);
         });
-        it('should return true when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(filter);
+        it('should return false when positive attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(positiveAttributeFilter);
             expect(result).toEqual(true);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isPositiveAttributeFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -251,26 +236,26 @@ describe('isNegativeAttributeFilter', function () {
         });
-        it('should return true when negative attribute filter is tested', function () {
-            var filter = {
-                negativeAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/date'
-                    },
-                    notIn: ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(negativeAttributeFilter);
             expect(result).toEqual(true);
         });
         it('should return false when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(positiveAttributeFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isNegativeAttributeFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
     });
@@ -286,25 +271,60 @@ describe('isMeasureValueFilter', function () {
         });
-        it('should return true when measure value filter is tested', function () {
-            var filter = {
-                measureValueFilter: {
-                    measure: {
-                        uri: '/gdc/mock/date'
-                    }
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(filter);
+        it('should return true when relative date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when positive attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(positiveAttributeFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(measureValueFilter);
             expect(result).toEqual(true);
         });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(expressionFilter);
+            expect(result).toEqual(false);
+        });
+    });
+    describe('isExpressionFilter', function () {
+        it('should return false when null is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(null);
+            expect(result).toEqual(false);
+        });
+        it('should return false when undefined is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(undefined);
+            expect(result).toEqual(false);
+        });
+        it('should return true when relative date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(relativeDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return true when absolute date filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(absoluteDateFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when negative attribute filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(negativeAttributeFilter);
+            expect(result).toEqual(false);
+        });
         it('should return false when positive attribute filter is tested', function () {
-            var filter = {
-                positiveAttributeFilter: {
-                    displayForm: {
-                        uri: '/gdc/mock/attribute'
-                    },
-                    "in": ['/gdc/mock/attribute/value_1', '/gdc/mock/attribute/value_2']
-                }
-            };
-            var result = ExecuteAFM_1.ExecuteAFM.isMeasureValueFilter(filter);
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(positiveAttributeFilter);
             expect(result).toEqual(false);
         });
+        it('should return false when measure value filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(measureValueFilter);
+            expect(result).toEqual(false);
+        });
+        it('should return false when expression filter is tested', function () {
+            var result = ExecuteAFM_1.ExecuteAFM.isExpressionFilter(expressionFilter);
+            expect(result).toEqual(true);
+        });
     });
@@ -311,0 +331,0 @@ describe('isAttributeElementsArray', function () {

dist/src/VisualizationInput.d.ts

@@ -25,3 +25,3 @@ import { AFM } from './AFM';
             aggregation?: MeasureAggregation;
-            filters?: IFilter[];
+            filters?: IMeasureFilter[];
             computeRatio?: boolean;
@@ -44,3 +44,5 @@ };
     type IRelativeDateFilter = VisualizationObject.IVisualizationObjectRelativeDateFilter;
-    type IFilter = IAbsoluteDateFilter | IRelativeDateFilter | IPositiveAttributeFilter | INegativeAttributeFilter;
+    type IMeasureValueFilter = VisualizationObject.IMeasureValueFilter;
+    type IMeasureFilter = IAbsoluteDateFilter | IRelativeDateFilter | IPositiveAttributeFilter | INegativeAttributeFilter;
+    type IFilter = IAbsoluteDateFilter | IRelativeDateFilter | IPositiveAttributeFilter | INegativeAttributeFilter | IMeasureValueFilter;
     type ISort = AFM.IAttributeSortItem | AFM.IMeasureSortItem;
@@ -58,3 +60,4 @@ type ITotal = VisualizationObject.IVisualizationTotal;
     function isRelativeDateFilter(obj: any): obj is IRelativeDateFilter;
+    function isMeasureValueFilter(obj: any): obj is IMeasureValueFilter;
     function isSort(obj: any): obj is ISort;
 }

dist/src/VisualizationInput.js

@@ -56,2 +56,6 @@ "use strict";
     VisualizationInput.isRelativeDateFilter = isRelativeDateFilter;
+    function isMeasureValueFilter(obj) {
+        return VisualizationObject_1.VisualizationObject.isMeasureValueFilter(obj);
+    }
+    VisualizationInput.isMeasureValueFilter = isMeasureValueFilter;
     function isSort(obj) {
@@ -58,0 +62,0 @@ return AFM_1.AFM.isAttributeSortItem(obj) || AFM_1.AFM.isMeasureSortItem(obj);

package.json

 {
   "name": "@gooddata/typings",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "description": "TypeScript definition files for GoodData platform",
@@ -5,0 +5,0 @@ "typings": "dist/index.d.ts",

No alert changes

Improved metrics

Total package byte prevSize

251838

increased by23.32%

Number of package files

58

increased by5.45%

Lines of code

3773

increased by15.74%

No dependency changes