@magda/typescript-common 2.3.3 → 3.0.0-alpha.1

package/dist/OpaCompileResponseParser.js

@@ -1,21 +1,4 @@
-"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 };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unknown2Ref = exports.RegoRuleSet = exports.value2String = exports.RegoRef = exports.RegoExp = exports.RegoTerm = exports.RegoOperators = exports.RegoRule = void 0;
-const lodash_1 = __importDefault(require("lodash"));
+import _ from "lodash";
 /**
  * @class RegoRule
  * @export
@@ -28,31 +11,94 @@ const lodash_1 = __importDefault(require("lodash"));
  * - The rule is considered as matched if all expressions in rule body are `true`
  * You can opt to define a `default` rule. A default rule has no rule body and will only considered as matched if all other rules are not matched.
  */
-class RegoRule {
+export class RegoRule {
+    /**
+     * the local name of the rule. i.e. doesn't include full package path
+     * e.g. `allow`
+     *
+     * @type {string}
+     * @memberof RegoRule
+     */
+    name;
+    /**
+     * Full name of the rule. Includes fulle package path
+     * e.g. `data.object.content.allowRead`
+     *
+     * @type {string}
+     * @memberof RegoRule
+     */
+    fullName;
+    /**
+     * Whether a rule is a default Rule
+     * Its value only be used if any other residual rules are not matched (or no other residual rules)
+     *
+     * @type {boolean}
+     * @memberof RegoRule
+     */
+    isDefault;
+    /**
+     * Rule value. Rule value is this value if all expression in rule body are true
+     * It can be any type. e.g. can be object or array etc. But a simple policy normally outputs a boolean true or false
+     *
+     * @type {RegoValue}
+     * @memberof RegoRule
+     */
+    value;
+    /**
+     * 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 = false;
+    /**
+     * All Rego expressions in this rule's rule body. @see RegoExp
+     *
+     * @type {RegoExp[]}
+     * @memberof RegoRule
+     */
+    expressions;
+    /**
+     * If the rule is matched or not
+     * Default to undefined
+     * Its value is only set when `isCompleteEvaluated` is true
+     *
+     * @type {boolean}
+     * @memberof RegoRule
+     */
+    isMatched;
+    /**
+     * If the rule is fully evaluate
+     * Default to false
+     *
+     * @type {boolean}
+     * @memberof RegoRule
+     */
+    isCompleteEvaluated;
+    /**
+     * Reference to OpaParser
+     *
+     * @private
+     * @type {OpaCompileResponseParser}
+     * @memberof RegoRule
+     */
+    parser;
     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 : "";
-        this.isDefault = lodash_1.default.isBoolean(options.isDefault)
+        this.name = _.isString(options.name) ? options.name : "";
+        this.fullName = _.isString(options.fullName) ? options.fullName : "";
+        this.isDefault = _.isBoolean(options.isDefault)
             ? options.isDefault
             : false;
-        this.value = lodash_1.default.isUndefined(options.value) ? true : options.value;
-        this.expressions = lodash_1.default.isArray(options.expressions)
+        this.value = _.isUndefined(options.value) ? true : options.value;
+        this.expressions = _.isArray(options.expressions)
             ? options.expressions
             : [];
-        this.isCompleteEvaluated = lodash_1.default.isBoolean(options.isCompleteEvaluated)
+        this.isCompleteEvaluated = _.isBoolean(options.isCompleteEvaluated)
             ? options.isCompleteEvaluated
             : false;
         this.parser = options.parser;
@@ -66,7 +112,7 @@ class RegoRule {
             throw new Error("Require parser parameter to create a RegoRule");
         }
         this.removeDuplicateExpressions();
-        if (((_a = this.expressions) === null || _a === void 0 ? void 0 : _a.length) &&
+        if (this.expressions?.length &&
             this.expressions.findIndex((exp) => !exp.hasNoResolvableRef) === -1) {
             this.hasNoResolvableRef = true;
         }
@@ -81,8 +127,7 @@ class RegoRule {
      * @memberof RegoRule
      */
     removeDuplicateExpressions() {
-        var _a;
-        if (!((_a = this === null || this === void 0 ? void 0 : this.expressions) === null || _a === void 0 ? void 0 : _a.length)) {
+        if (!this?.expressions?.length) {
             return;
         }
         const expSet = new Set();
@@ -102,8 +147,7 @@ class RegoRule {
      * @memberof RegoRule
      */
     isImpossible() {
-        var _a;
-        if (!((_a = this === null || this === void 0 ? void 0 : this.expressions) === null || _a === void 0 ? void 0 : _a.length)) {
+        if (!this?.expressions?.length) {
             return false;
         }
         const nonNegatedExpSet = new Set();
@@ -129,7 +173,16 @@ class RegoRule {
         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));
+        const regoRule = new RegoRule({
+            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;
         return regoRule;
     }
@@ -141,14 +194,13 @@ class RegoRule {
      * @memberof RegoRule
      */
     evaluate() {
-        var _a;
         if (this.hasNoResolvableRef) {
             return this;
         }
         if (this.isCompleteEvaluated) {
             return this;
         }
-        if (!((_a = this === null || this === void 0 ? void 0 : this.expressions) === null || _a === void 0 ? void 0 : _a.length)) {
+        if (!this?.expressions?.length) {
             // a rule with empty body / no expression is matched
             this.isCompleteEvaluated = true;
             this.isMatched = true;
@@ -252,7 +304,7 @@ class RegoRule {
         const ruleName = r.head && r.head.name ? r.head.name : "";
         const ruleFullName = [packageName, ruleName].join(".");
         const ruleIsDefault = r.default === true;
-        const ruleValue = r.head && r.head.value && !lodash_1.default.isUndefined(r.head.value.value)
+        const ruleValue = r.head && r.head.value && !_.isUndefined(r.head.value.value)
             ? r.head.value.value
             : true;
         const ruleOptions = {
@@ -267,7 +319,7 @@ class RegoRule {
         return regoRule;
     }
     static createExpressionsFromRuleBodyData(data, parser) {
-        if (!lodash_1.default.isArray(data) || !data.length) {
+        if (!_.isArray(data) || !data.length) {
             throw new Error(`Encountered empty rule body.`);
         }
         return data.map((expData) => RegoExp.parseFromData(expData, parser));
@@ -288,9 +340,8 @@ class RegoRule {
         });
     }
 }
-exports.RegoRule = RegoRule;
-exports.RegoOperators = {
-    eq: "=",
+export const RegoOperators = {
+    eq: "=", // --- eq & equal are different in rego but no difference for value evluation.
     equal: "=",
     neq: "!=",
     lt: "<",
@@ -308,19 +359,22 @@ exports.RegoOperators = {
  * @export
  * @class RegoTerm
  */
-class RegoTerm {
+export class RegoTerm {
+    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
+     */
+    hasNoResolvableRef = false;
     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;
@@ -559,47 +613,68 @@ class RegoTerm {
         }
     }
 }
-exports.RegoTerm = RegoTerm;
 /**
  * Represents Rego expression
  *
  * @export
  * @class RegoExp
  */
-class RegoExp {
+export class RegoExp {
+    /**
+     * All RegoTerms belongs to this expression
+     *
+     * @type {RegoTerm[]}
+     * @memberof RegoExp
+     */
+    terms;
+    /**
+     * 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 = false;
+    /**
+     * Whether this expression is a negative expression
+     * i.e. it's final evaluation result should be `false` if result is `true`
+     *
+     * @type {boolean}
+     * @memberof RegoExp
+     */
+    isNegated;
+    /**
+     * If it's complete evaluated
+     *
+     * @type {boolean}
+     * @memberof RegoExp
+     */
+    isCompleteEvaluated = false;
+    /**
+     * The value of the expression
+     *
+     * @type {RegoValue}
+     * @memberof RegoExp
+     */
+    value = null;
+    /**
+     * Ref to Opa Parser
+     *
+     * @private
+     * @type {OpaCompileResponseParser}
+     * @memberof RegoExp
+     */
+    parser;
     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
-         *
-         * @type {boolean}
-         * @memberof RegoExp
-         */
-        this.isCompleteEvaluated = false;
-        /**
-         * The value of the expression
-         *
-         * @type {RegoValue}
-         * @memberof RegoExp
-         */
-        this.value = null;
         this.terms = terms;
         this.isNegated = isNegated;
         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) &&
+        if (this?.terms?.length &&
             this.terms.findIndex((item) => !item.hasNoResolvableRef) === -1) {
             this.hasNoResolvableRef = true;
         }
@@ -644,7 +719,7 @@ class RegoExp {
             const parts = [];
             if (this.isNegated)
                 parts.push("NOT");
-            if (!lodash_1.default.isUndefined(value)) {
+            if (!_.isUndefined(value)) {
                 parts.push(value2String(value));
             }
             else {
@@ -692,7 +767,7 @@ class RegoExp {
             // --- undefined is a common value in Rego similar to false
             // --- we set to false here to tell the difference between
             // --- real undefined (not full resolved) and undefined value
-            if (lodash_1.default.isUndefined(this.value))
+            if (_.isUndefined(this.value))
                 return false;
             else
                 return this.value;
@@ -713,7 +788,7 @@ class RegoExp {
         if (!this.isResolvable()) {
             return undefined;
         }
-        const isMatched = this.value === false || lodash_1.default.isUndefined(this.value) ? false : true;
+        const isMatched = this.value === false || _.isUndefined(this.value) ? false : true;
         if (this.isNegated) {
             return !isMatched;
         }
@@ -896,13 +971,13 @@ class RegoExp {
     }
     static parseFromData(expData, parser) {
         const isNegated = expData.negated === true;
-        if (lodash_1.default.isEmpty(expData.terms)) {
+        if (_.isEmpty(expData.terms)) {
             if (isNegated)
                 throw new Error("Invalid negated empty term!");
             return new RegoExp([], isNegated, false, null, parser);
         }
         let termsData = [];
-        if (lodash_1.default.isArray(expData.terms)) {
+        if (_.isArray(expData.terms)) {
             termsData = expData.terms;
         }
         else {
@@ -914,7 +989,6 @@ class RegoExp {
         return exp;
     }
 }
-exports.RegoExp = RegoExp;
 /**
  * Represents a special Rego Term type: reference term
  * You shouldn't use this class directly
@@ -922,30 +996,30 @@ exports.RegoExp = RegoExp;
  * @export
  * @class RegoRef
  */
-class RegoRef {
+export class RegoRef {
+    parts;
+    /**
+     * 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 = false;
     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.parts.length && this.parts[0]?.value === "input") ||
             this.isOperator()) {
             this.hasNoResolvableRef = true;
         }
     }
     clone() {
-        return new RegoRef(this.parts.map((p) => (Object.assign({}, p))));
+        return new RegoRef(this.parts.map((p) => ({ ...p })));
     }
     toData() {
         return {
@@ -1018,7 +1092,7 @@ class RegoRef {
             .map((refStr) => refStr.replace(/^\./, ""));
     }
     isOperator() {
-        return Object.keys(exports.RegoOperators).indexOf(this.fullRefString()) !== -1;
+        return Object.keys(RegoOperators).indexOf(this.fullRefString()) !== -1;
     }
     // --- the first var type won't count as collection lookup
     hasCollectionLookup() {
@@ -1046,40 +1120,39 @@ class RegoRef {
     }
     asOperator() {
         if (this.isOperator())
-            return exports.RegoOperators[this.fullRefString()];
+            return RegoOperators[this.fullRefString()];
         else
             return null;
     }
 }
-exports.RegoRef = RegoRef;
-function value2String(value) {
-    if (lodash_1.default.isBoolean(value) || lodash_1.default.isNumber(value))
+export function value2String(value) {
+    if (_.isBoolean(value) || _.isNumber(value))
         return value.toString();
     else
         return JSON.stringify(value);
 }
-exports.value2String = value2String;
-class RegoRuleSet {
+export class RegoRuleSet {
+    fullName = "";
+    name = "";
+    rules = [];
+    defaultRule = null;
+    value;
+    isCompleteEvaluated = false;
+    parser;
+    /**
+     * 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 = false;
     constructor(parser, rules, fullName = "", name = "") {
-        var _a, _b;
-        this.fullName = "";
-        this.name = "";
-        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) {
+        if (rules?.length) {
             const defaultRuleIdx = rules.findIndex((r) => r.isDefault);
             if (defaultRuleIdx !== -1) {
                 this.defaultRule = rules[defaultRuleIdx];
@@ -1089,13 +1162,13 @@ class RegoRuleSet {
         if (fullName) {
             this.fullName = fullName;
         }
-        else if ((_a = rules === null || rules === void 0 ? void 0 : rules[0]) === null || _a === void 0 ? void 0 : _a.fullName) {
+        else if (rules?.[0]?.fullName) {
             this.fullName = rules[0].fullName;
         }
         if (name) {
             this.name = name;
         }
-        else if ((_b = rules === null || rules === void 0 ? void 0 : rules[0]) === null || _b === void 0 ? void 0 : _b.name) {
+        else if (rules?.[0]?.name) {
             this.name = rules[0].name;
         }
         if (this.rules.length &&
@@ -1105,14 +1178,13 @@ class RegoRuleSet {
         this.evaluate();
     }
     evaluate() {
-        var _a;
         if (this.hasNoResolvableRef) {
             return this;
         }
         if (this.isCompleteEvaluated) {
             return this;
         }
-        if (!((_a = this.rules) === null || _a === void 0 ? void 0 : _a.length)) {
+        if (!this.rules?.length) {
             if (!this.defaultRule) {
                 this.isCompleteEvaluated = true;
                 this.value = undefined;
@@ -1174,7 +1246,7 @@ class RegoRuleSet {
         if (!rules.length) {
             return [];
         }
-        rules = lodash_1.default.flatMap(rules, (rule) => {
+        rules = _.flatMap(rules, (rule) => {
             // all resolvable expressions can all be ignored as:
             // - if the expression is resolved to "matched", it won't impact the result of the rule
             // - if the expression is resolved to "unmatched", the rule should be resolved to "unmatched" earlier.
@@ -1241,72 +1313,69 @@ class RegoRuleSet {
         return rules;
     }
 }
-exports.RegoRuleSet = RegoRuleSet;
 /**
  * OPA result Parser
  *
  * @export
  * @class OpaCompileResponseParser
  */
-class OpaCompileResponseParser {
-    constructor() {
-        /**
-         * If a warning is produced during the parsing
-         *
-         * @type {boolean}
-         * @memberof OpaCompileResponseParser
-         */
-        this.hasWarns = false;
-        /**
-         * Any warnings produced during the parsing
-         *
-         * @type {string[]}
-         * @memberof OpaCompileResponseParser
-         */
-        this.warns = [];
-        this.data = null;
-        /**
-         * Inital Rules parsed from result
-         * Only for debug purpose
-         *
-         * @type {RegoRule[]}
-         * @memberof OpaCompileResponseParser
-         */
-        this.originalRules = [];
-        /**
-         * Parsed, compressed & evaluated rules
-         *
-         * @type {RegoRule[]}
-         * @memberof OpaCompileResponseParser
-         */
-        this.rules = [];
-        /**
-         * Parsed, compressed & evaluated rule sets
-         *
-         * @type {RegoRuleSet[]}
-         * @memberof OpaCompileResponseParser
-         */
-        this.ruleSets = {};
-        this.queries = [];
-        /**
-         * A cache of all resolved rule result
-         *
-         * @type {{
-         *         [fullName: string]: CompleteRuleResult;
-         *     }}
-         * @memberof OpaCompileResponseParser
-         */
-        this.completeRuleResults = {};
-        /**
-         * The pseudo query rule name
-         * The parser will assign a random pseudo rule name to the query expressions you submit.
-         *
-         * @type {string}
-         * @memberof OpaCompileResponseParser
-         */
-        this.pseudoQueryRuleName = RegoRule.randomRuleName("default_rule_");
-        this.ruleDuplicationCheckCache = {};
-    }
+export default class OpaCompileResponseParser {
+    /**
+     * If a warning is produced during the parsing
+     *
+     * @type {boolean}
+     * @memberof OpaCompileResponseParser
+     */
+    hasWarns = false;
+    /**
+     * Any warnings produced during the parsing
+     *
+     * @type {string[]}
+     * @memberof OpaCompileResponseParser
+     */
+    warns = [];
+    data = null;
+    /**
+     * Inital Rules parsed from result
+     * Only for debug purpose
+     *
+     * @type {RegoRule[]}
+     * @memberof OpaCompileResponseParser
+     */
+    originalRules = [];
+    /**
+     * Parsed, compressed & evaluated rules
+     *
+     * @type {RegoRule[]}
+     * @memberof OpaCompileResponseParser
+     */
+    rules = [];
+    /**
+     * Parsed, compressed & evaluated rule sets
+     *
+     * @type {RegoRuleSet[]}
+     * @memberof OpaCompileResponseParser
+     */
+    ruleSets = {};
+    queries = [];
+    /**
+     * A cache of all resolved rule result
+     *
+     * @type {{
+     *         [fullName: string]: CompleteRuleResult;
+     *     }}
+     * @memberof OpaCompileResponseParser
+     */
+    completeRuleResults = {};
+    /**
+     * The pseudo query rule name
+     * The parser will assign a random pseudo rule name to the query expressions you submit.
+     *
+     * @type {string}
+     * @memberof OpaCompileResponseParser
+     */
+    pseudoQueryRuleName = RegoRule.randomRuleName("default_rule_");
+    ruleDuplicationCheckCache = {};
     setQueryRuleResult(val) {
         this.completeRuleResults[this.pseudoQueryRuleName] = {
             fullName: this.pseudoQueryRuleName,
@@ -1323,7 +1392,7 @@ class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     parse(json) {
-        if (lodash_1.default.isString(json)) {
+        if (_.isString(json)) {
             this.data = JSON.parse(json);
         }
         else {
@@ -1339,12 +1408,12 @@ class OpaCompileResponseParser {
         }
         this.data = this.data.result;
         if (!this.data.queries ||
-            !lodash_1.default.isArray(this.data.queries) ||
+            !_.isArray(this.data.queries) ||
             !this.data.queries.length) {
             this.setQueryRuleResult(false);
             return [];
         }
-        if (this.data.queries.findIndex((q) => !(q === null || q === void 0 ? void 0 : q.length)) !== -1) {
+        if (this.data.queries.findIndex((q) => !q?.length) !== -1) {
             //  when query is always true, the "queries" value in the result will contain an empty array
             this.setQueryRuleResult(true);
             return [];
@@ -1374,9 +1443,9 @@ class OpaCompileResponseParser {
         const packages = this.data.support;
         if (packages) {
             packages.forEach((p) => {
-                if (!lodash_1.default.isArray(p.rules) || !p.rules.length)
+                if (!_.isArray(p.rules) || !p.rules.length)
                     return;
-                const packageName = p.package && lodash_1.default.isArray(p.package.path)
+                const packageName = p.package && _.isArray(p.package.path)
                     ? RegoRef.convertToFullRefString(p.package.path)
                     : "";
                 const rules = p.rules;
@@ -1389,7 +1458,7 @@ class OpaCompileResponseParser {
             });
         }
         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)));
+        _.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;
     }
@@ -1402,7 +1471,7 @@ class OpaCompileResponseParser {
             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 { name, fullName, ...ruleData } = rule.toData();
         const jsonData = JSON.stringify(ruleData);
         const size = setData.size;
         setData.add(jsonData);
@@ -1525,10 +1594,8 @@ class OpaCompileResponseParser {
         this.hasWarns = true;
     }
 }
-exports.default = OpaCompileResponseParser;
-function unknown2Ref(unknown) {
+export function unknown2Ref(unknown) {
     const prefix = unknown.replace(/^input\./, "");
     return `data.partial.${prefix}`;
 }
-exports.unknown2Ref = unknown2Ref;
 //# sourceMappingURL=OpaCompileResponseParser.js.map