@magda/typescript-common 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/OpaCompileResponseParser.d.ts

@@ -53,6 +53,17 @@ export declare class RegoRule {
      * @memberof RegoRule
      */
     value: RegoValue;
+    /**
+     * Whether the rule contains any expressions that has any resolvable references.
+     * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+     * When this field is set to `true`, we should not attempt to evaluate this expression.
+     * i.e. evaluate() method should return immediately.
+     * This will speed up evaluation process.
+     *
+     * @type {boolean}
+     * @memberof RegoRule
+     */
+    hasNoResolvableRef: boolean;
     /**
      * All Rego expressions in this rule's rule body. @see RegoExp
      *
@@ -86,6 +97,24 @@ export declare class RegoRule {
      */
     private parser;
     constructor(options: RegoRuleOptions);
+    /**
+     * OPA PE result might contain duplicate expressions.
+     * https://github.com/open-policy-agent/opa/issues/4516
+     * This method will remove those duplication by simply string comparison.
+     *
+     * @return {*}
+     * @memberof RegoRule
+     */
+    removeDuplicateExpressions(): void;
+    /**
+     * Test whether the rule is an "impossible" rule.
+     * If so, the rule should be simply discarded.
+     * See: https://github.com/open-policy-agent/opa/issues/4516
+     *
+     * @return {*}  {boolean}
+     * @memberof RegoRule
+     */
+    isImpossible(): boolean;
     clone(options?: Partial<RegoRuleOptions>): RegoRule;
     /**
      * Re-evaluate this rule
@@ -117,12 +146,26 @@ export declare class RegoRule {
         fullName: string;
         name: string;
         expressions: ({
+            negated: boolean;
+            terms: {
+                type: string;
+                value: RegoTermValue;
+            }[];
+            index?: undefined;
+        } | {
             negated: boolean;
             index: number;
             terms: {
                 type: string;
                 value: RegoTermValue;
             }[];
+        } | {
+            terms: {
+                type: string;
+                value: RegoTermValue;
+            }[];
+            negated?: undefined;
+            index?: undefined;
         } | {
             index: number;
             terms: {
@@ -193,6 +236,17 @@ export declare class RegoTerm {
     type: string;
     value: RegoTermValue;
     private parser;
+    /**
+     * Whether the expression contains any resolvable references.
+     * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+     * When this field is set to `true`, we should not attempt to evaluate this expression.
+     * i.e. evaluate() method should return immediately.
+     * This will speed up evaluation process.
+     *
+     * @type {boolean}
+     * @memberof RegoTerm
+     */
+    hasNoResolvableRef: boolean;
     constructor(type: string, value: RegoTermValue, parser: OpaCompileResponseParser);
     clone(): RegoTerm;
     /**
@@ -201,7 +255,7 @@ export declare class RegoTerm {
      * @returns
      * @memberof RegoTerm
      */
-    asString(): number | Object;
+    asString(): string;
     /**
      * If it's a reference term. A operator is an Reference term as well
      *
@@ -317,6 +371,17 @@ export declare class RegoExp {
      * @memberof RegoExp
      */
     terms: RegoTerm[];
+    /**
+     * Whether the expression contains any resolvable references.
+     * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+     * When this field is set to `true`, we should not attempt to evaluate this expression.
+     * i.e. evaluate() method should return immediately.
+     * This will speed up evaluation process.
+     *
+     * @type {boolean}
+     * @memberof RegoExp
+     */
+    hasNoResolvableRef: boolean;
     /**
      * Whether this expression is a negative expression
      * i.e. it's final evaluation result should be `false` if result is `true`
@@ -355,7 +420,15 @@ export declare class RegoExp {
      * @returns
      * @memberof RegoExp
      */
-    termsAsString(): (number | Object)[];
+    termsAsString(): string;
+    /**
+     * Print concise format expression string presentation.
+     * Can be used for debugging
+     *
+     * @return {*}
+     * @memberof RegoExp
+     */
+    asString(): string;
     /**
      * Output human readable string
      *
@@ -404,13 +477,27 @@ export declare class RegoExp {
      * @memberof RegoExp
      */
     evaluate(): this;
-    toData(index?: number): {
+    toData(index?: number, ignoreIndex?: boolean, ignoreNegated?: boolean): {
+        negated: boolean;
+        terms: {
+            type: string;
+            value: RegoTermValue;
+        }[];
+        index?: undefined;
+    } | {
         negated: boolean;
         index: number;
         terms: {
             type: string;
             value: RegoTermValue;
         }[];
+    } | {
+        terms: {
+            type: string;
+            value: RegoTermValue;
+        }[];
+        negated?: undefined;
+        index?: undefined;
     } | {
         index: number;
         terms: {
@@ -419,7 +506,7 @@ export declare class RegoExp {
         }[];
         negated?: undefined;
     };
-    toJSON(index?: number): string;
+    toJSON(index?: number, ignoreIndex?: boolean, ignoreNegated?: boolean): string;
     toConciseData(): {
         negated: boolean;
         operator: string;
@@ -440,6 +527,17 @@ export declare class RegoExp {
  */
 export declare class RegoRef {
     parts: RegoRefPart[];
+    /**
+     * Whether the expression contains any resolvable references.
+     * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+     * When this field is set to `true`, we should not attempt to evaluate this expression.
+     * i.e. evaluate() method should return immediately.
+     * This will speed up evaluation process.
+     *
+     * @type {boolean}
+     * @memberof RegoRef
+     */
+    hasNoResolvableRef: boolean;
     constructor(parts: RegoRefPart[]);
     clone(): RegoRef;
     toData(): {
@@ -475,6 +573,17 @@ export declare class RegoRuleSet {
     value?: any;
     isCompleteEvaluated: boolean;
     parser: OpaCompileResponseParser;
+    /**
+     * Whether the ruleSet contains any rules that has any resolvable references.
+     * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+     * When this field is set to `true`, we should not attempt to evaluate this expression.
+     * i.e. evaluate() method should return immediately.
+     * This will speed up evaluation process.
+     *
+     * @type {boolean}
+     * @memberof RegoRuleSet
+     */
+    hasNoResolvableRef: boolean;
     constructor(parser: OpaCompileResponseParser, rules: RegoRule[], fullName?: string, name?: string);
     evaluate(): RegoRuleSet;
     isResolvable(): boolean;
@@ -546,6 +655,7 @@ export default class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     readonly pseudoQueryRuleName: string;
+    private ruleDuplicationCheckCache;
     private setQueryRuleResult;
     /**
      * Parse OPA result Response
@@ -555,6 +665,7 @@ export default class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     parse(json: any): RegoRule[];
+    addRule(rule: RegoRule): void;
     isRefResolvable(fullName: string): boolean;
     getRefValue(fullName: string): any;
     private resolveAllRuleSets;

package/dist/OpaCompileResponseParser.js

@@ -1,4 +1,15 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -19,6 +30,18 @@ const lodash_1 = __importDefault(require("lodash"));
  */
 class RegoRule {
     constructor(options) {
+        var _a;
+        /**
+         * Whether the rule contains any expressions that has any resolvable references.
+         * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+         * When this field is set to `true`, we should not attempt to evaluate this expression.
+         * i.e. evaluate() method should return immediately.
+         * This will speed up evaluation process.
+         *
+         * @type {boolean}
+         * @memberof RegoRule
+         */
+        this.hasNoResolvableRef = false;
         this.isCompleteEvaluated = false;
         this.name = lodash_1.default.isString(options.name) ? options.name : "";
         this.fullName = lodash_1.default.isString(options.fullName) ? options.fullName : "";
@@ -42,8 +65,69 @@ class RegoRule {
         if (!(this.parser instanceof OpaCompileResponseParser)) {
             throw new Error("Require parser parameter to create a RegoRule");
         }
+        this.removeDuplicateExpressions();
+        if (((_a = this.expressions) === null || _a === void 0 ? void 0 : _a.length) &&
+            this.expressions.findIndex((exp) => !exp.hasNoResolvableRef) === -1) {
+            this.hasNoResolvableRef = true;
+        }
         this.evaluate();
     }
+    /**
+     * OPA PE result might contain duplicate expressions.
+     * https://github.com/open-policy-agent/opa/issues/4516
+     * This method will remove those duplication by simply string comparison.
+     *
+     * @return {*}
+     * @memberof RegoRule
+     */
+    removeDuplicateExpressions() {
+        var _a;
+        if (!((_a = this === null || this === void 0 ? void 0 : this.expressions) === null || _a === void 0 ? void 0 : _a.length)) {
+            return;
+        }
+        const expSet = new Set();
+        this.expressions = this.expressions.filter((exp) => {
+            const orgSetLength = expSet.size;
+            // exp.toJSON() is faster than exp.toConciseJSON()
+            expSet.add(exp.toJSON(0, true));
+            return expSet.size > orgSetLength;
+        });
+    }
+    /**
+     * Test whether the rule is an "impossible" rule.
+     * If so, the rule should be simply discarded.
+     * See: https://github.com/open-policy-agent/opa/issues/4516
+     *
+     * @return {*}  {boolean}
+     * @memberof RegoRule
+     */
+    isImpossible() {
+        var _a;
+        if (!((_a = this === null || this === void 0 ? void 0 : this.expressions) === null || _a === void 0 ? void 0 : _a.length)) {
+            return false;
+        }
+        const nonNegatedExpSet = new Set();
+        const negatedExps = this.expressions.filter((exp) => {
+            if (exp.isNegated) {
+                return true;
+            }
+            else {
+                // add non negated exp content to set
+                // exp.toJSON() is faster than exp.toConciseJSON()
+                nonNegatedExpSet.add(exp.toJSON(0, true));
+                return false;
+            }
+        });
+        if (!negatedExps.length) {
+            return false;
+        }
+        for (const exp of negatedExps) {
+            if (nonNegatedExpSet.has(exp.toJSON(0, true, true))) {
+                return true;
+            }
+        }
+        return false;
+    }
     clone(options = {}) {
         const regoRule = new RegoRule(Object.assign({ name: this.name, fullName: this.fullName, isDefault: this.isDefault, value: this.value, isCompleteEvaluated: this.isCompleteEvaluated, expressions: this.expressions.map((e) => e.clone()), parser: this.parser }, options));
         regoRule.isMatched = this.isMatched;
@@ -58,6 +142,9 @@ class RegoRule {
      */
     evaluate() {
         var _a;
+        if (this.hasNoResolvableRef) {
+            return this;
+        }
         if (this.isCompleteEvaluated) {
             return this;
         }
@@ -223,9 +310,23 @@ exports.RegoOperators = {
  */
 class RegoTerm {
     constructor(type, value, parser) {
+        /**
+         * Whether the expression contains any resolvable references.
+         * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+         * When this field is set to `true`, we should not attempt to evaluate this expression.
+         * i.e. evaluate() method should return immediately.
+         * This will speed up evaluation process.
+         *
+         * @type {boolean}
+         * @memberof RegoTerm
+         */
+        this.hasNoResolvableRef = false;
         this.type = type;
         this.value = value;
         this.parser = parser;
+        if (this.value instanceof RegoRef && this.value.hasNoResolvableRef) {
+            this.hasNoResolvableRef = true;
+        }
     }
     clone() {
         return new RegoTerm(this.type, this.value, this.parser);
@@ -240,7 +341,7 @@ class RegoTerm {
         if (this.value instanceof RegoRef)
             return this.value.fullRefString();
         else
-            return this.value;
+            return JSON.stringify(this.value);
     }
     /**
      * If it's a reference term. A operator is an Reference term as well
@@ -376,6 +477,9 @@ class RegoTerm {
      * @memberof RegoTerm
      */
     getValue() {
+        if (this.hasNoResolvableRef) {
+            return undefined;
+        }
         if (!this.isRef()) {
             return this.value;
         }
@@ -399,6 +503,9 @@ class RegoTerm {
      * @memberof RegoTerm
      */
     isValueResolvable() {
+        if (this.hasNoResolvableRef) {
+            return false;
+        }
         if (!this.isRef()) {
             return true;
         }
@@ -461,6 +568,18 @@ exports.RegoTerm = RegoTerm;
  */
 class RegoExp {
     constructor(terms, isNegated = false, isCompleteEvaluated = false, value = null, parser) {
+        var _a;
+        /**
+         * Whether the expression contains any resolvable references.
+         * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+         * When this field is set to `true`, we should not attempt to evaluate this expression.
+         * i.e. evaluate() method should return immediately.
+         * This will speed up evaluation process.
+         *
+         * @type {boolean}
+         * @memberof RegoExp
+         */
+        this.hasNoResolvableRef = false;
         /**
          * If it's complete evaluated
          *
@@ -480,6 +599,10 @@ class RegoExp {
         this.isCompleteEvaluated = isCompleteEvaluated;
         this.value = value;
         this.parser = parser;
+        if (((_a = this === null || this === void 0 ? void 0 : this.terms) === null || _a === void 0 ? void 0 : _a.length) &&
+            this.terms.findIndex((item) => !item.hasNoResolvableRef) === -1) {
+            this.hasNoResolvableRef = true;
+        }
     }
     clone() {
         const regoExp = new RegoExp(this.terms.map((t) => t.clone()), this.isNegated, this.isCompleteEvaluated, this.value, this.parser);
@@ -492,7 +615,22 @@ class RegoExp {
      * @memberof RegoExp
      */
     termsAsString() {
-        return this.terms.map((t) => t.asString());
+        return this.terms.map((t) => t.asString()).join(" ");
+    }
+    /**
+     * Print concise format expression string presentation.
+     * Can be used for debugging
+     *
+     * @return {*}
+     * @memberof RegoExp
+     */
+    asString() {
+        if (this.isNegated) {
+            return "NOT " + this.termsAsString();
+        }
+        else {
+            return this.termsAsString();
+        }
     }
     /**
      * Output human readable string
@@ -631,6 +769,9 @@ class RegoExp {
      * @memberof RegoExp
      */
     evaluate() {
+        if (this.hasNoResolvableRef) {
+            return this;
+        }
         if (this.isCompleteEvaluated) {
             return this;
         }
@@ -696,24 +837,39 @@ class RegoExp {
             throw new Error(`Invalid ${this.terms.length} terms rego expression: ${this.termsAsString()}`);
         }
     }
-    toData(index = 0) {
+    toData(index = 0, ignoreIndex = false, ignoreNegated = false) {
         const terms = this.terms.map((term) => term.toData());
-        if (this.isNegated) {
-            return {
-                negated: true,
-                index,
-                terms
-            };
+        if (this.isNegated && !ignoreNegated) {
+            if (ignoreIndex) {
+                return {
+                    negated: true,
+                    terms
+                };
+            }
+            else {
+                return {
+                    negated: true,
+                    index,
+                    terms
+                };
+            }
         }
         else {
-            return {
-                index,
-                terms
-            };
+            if (ignoreIndex) {
+                return {
+                    terms
+                };
+            }
+            else {
+                return {
+                    index,
+                    terms
+                };
+            }
         }
     }
-    toJSON(index = 0) {
-        return JSON.stringify(this.toData(index));
+    toJSON(index = 0, ignoreIndex = false, ignoreNegated = false) {
+        return JSON.stringify(this.toData(index, ignoreIndex, ignoreNegated));
     }
     toConciseData() {
         let data;
@@ -768,7 +924,25 @@ exports.RegoExp = RegoExp;
  */
 class RegoRef {
     constructor(parts) {
+        var _a;
+        /**
+         * Whether the expression contains any resolvable references.
+         * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+         * When this field is set to `true`, we should not attempt to evaluate this expression.
+         * i.e. evaluate() method should return immediately.
+         * This will speed up evaluation process.
+         *
+         * @type {boolean}
+         * @memberof RegoRef
+         */
+        this.hasNoResolvableRef = false;
         this.parts = parts;
+        if (
+        // `input.` ref should be considered not resolvable in partial evaluate context.
+        (this.parts.length && ((_a = this.parts[0]) === null || _a === void 0 ? void 0 : _a.value) === "input") ||
+            this.isOperator()) {
+            this.hasNoResolvableRef = true;
+        }
     }
     clone() {
         return new RegoRef(this.parts.map((p) => (Object.assign({}, p))));
@@ -893,6 +1067,17 @@ class RegoRuleSet {
         this.rules = [];
         this.defaultRule = null;
         this.isCompleteEvaluated = false;
+        /**
+         * Whether the ruleSet contains any rules that has any resolvable references.
+         * reference start with `input.` should be considered as non-resolvable in context of partial evaluation.
+         * When this field is set to `true`, we should not attempt to evaluate this expression.
+         * i.e. evaluate() method should return immediately.
+         * This will speed up evaluation process.
+         *
+         * @type {boolean}
+         * @memberof RegoRuleSet
+         */
+        this.hasNoResolvableRef = false;
         this.parser = parser;
         if (rules === null || rules === void 0 ? void 0 : rules.length) {
             const defaultRuleIdx = rules.findIndex((r) => r.isDefault);
@@ -913,10 +1098,17 @@ class RegoRuleSet {
         else if ((_b = rules === null || rules === void 0 ? void 0 : rules[0]) === null || _b === void 0 ? void 0 : _b.name) {
             this.name = rules[0].name;
         }
+        if (this.rules.length &&
+            this.rules.findIndex((r) => !r.hasNoResolvableRef) === -1) {
+            this.hasNoResolvableRef = true;
+        }
         this.evaluate();
     }
     evaluate() {
         var _a;
+        if (this.hasNoResolvableRef) {
+            return this;
+        }
         if (this.isCompleteEvaluated) {
             return this;
         }
@@ -1113,6 +1305,7 @@ class OpaCompileResponseParser {
          * @memberof OpaCompileResponseParser
          */
         this.pseudoQueryRuleName = RegoRule.randomRuleName("default_rule_");
+        this.ruleDuplicationCheckCache = {};
     }
     setQueryRuleResult(val) {
         this.completeRuleResults[this.pseudoQueryRuleName] = {
@@ -1173,8 +1366,9 @@ class OpaCompileResponseParser {
                     value: true,
                     parser: this
                 });
-                this.originalRules.push(rule);
-                this.rules.push(rule);
+                // this.originalRules.push(rule);
+                // this.rules.push(rule);
+                this.addRule(rule);
             });
         }
         const packages = this.data.support;
@@ -1188,15 +1382,35 @@ class OpaCompileResponseParser {
                 const rules = p.rules;
                 rules.forEach((r) => {
                     const regoRule = RegoRule.parseFromData(r, packageName, this);
-                    this.originalRules.push(regoRule);
-                    this.rules.push(regoRule);
+                    //this.originalRules.push(regoRule);
+                    //this.rules.push(regoRule);
+                    this.addRule(regoRule);
                 });
             });
         }
+        this.ruleDuplicationCheckCache = {};
         lodash_1.default.uniq(this.rules.map((r) => r.fullName)).forEach((fullName) => (this.ruleSets[fullName] = new RegoRuleSet(this, this.rules.filter((r) => r.fullName === fullName), fullName)));
         this.resolveAllRuleSets();
         return this.rules;
     }
+    addRule(rule) {
+        this.originalRules.push(rule);
+        if (rule.isImpossible()) {
+            return;
+        }
+        if (!this.ruleDuplicationCheckCache[rule.fullName]) {
+            this.ruleDuplicationCheckCache[rule.fullName] = new Set();
+        }
+        const setData = this.ruleDuplicationCheckCache[rule.fullName];
+        const _a = rule.toData(), { name, fullName } = _a, ruleData = __rest(_a, ["name", "fullName"]);
+        const jsonData = JSON.stringify(ruleData);
+        const size = setData.size;
+        setData.add(jsonData);
+        if (size === setData.size) {
+            return;
+        }
+        this.rules.push(rule);
+    }
     isRefResolvable(fullName) {
         if (this.completeRuleResults[fullName]) {
             return true;