@magda/typescript-common 1.2.1 → 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
@@ -95,6 +124,13 @@ export declare class RegoRule {
      * @memberof RegoRule
      */
     evaluate(): this;
+    /**
+     * Whether or not the rule is resolvable (i.e. we can tell whether it's matched or not) now.
+     *
+     * @return {*}  {boolean}
+     * @memberof RegoRule
+     */
+    isResolvable(): boolean;
     /**
      * Generate Human Readable string of this rule
      * If it's fully evaluated, the output will be true or false (or actual rule value)
@@ -104,6 +140,57 @@ export declare class RegoRule {
      * @memberof RegoRule
      */
     toHumanReadableString(): string;
+    toData(): {
+        default: boolean;
+        value: RegoValue;
+        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: {
+                type: string;
+                value: RegoTermValue;
+            }[];
+            negated?: undefined;
+        })[];
+    };
+    toJson(): string;
+    toConciseData(): {
+        default: boolean;
+        value: RegoValue;
+        fullName: string;
+        name: string;
+        expressions: {
+            negated: boolean;
+            operator: string;
+            operands: {
+                isRef: boolean;
+                value: RegoTermValue;
+            }[];
+        }[];
+    };
+    toConciseJSON(): string;
     /**
      * Create RegoRule from Opa response data
      *
@@ -124,8 +211,16 @@ export interface RegoRefPart {
     value: string;
 }
 export declare const RegoOperators: {
-    [k: string]: string;
+    readonly eq: "=";
+    readonly equal: "=";
+    readonly neq: "!=";
+    readonly lt: "<";
+    readonly gt: ">";
+    readonly lte: "<=";
+    readonly gte: ">=";
 };
+export declare type RegoOperatorAstString = keyof typeof RegoOperators;
+export declare type RegoOperatorString = typeof RegoOperators[RegoOperatorAstString];
 export declare type RegoTermValue = RegoRef | RegoValue;
 /**
  * RegoTerm represent the basic elements that creates an expressions.
@@ -141,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;
     /**
@@ -149,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
      *
@@ -217,7 +323,7 @@ export declare class RegoTerm {
      * @returns {string}
      * @memberof RegoTerm
      */
-    asOperator(): string;
+    asOperator(): "=" | "!=" | "<" | ">" | "<=" | ">=";
     /**
      * If it's a operator term
      *
@@ -232,6 +338,23 @@ export declare class RegoTerm {
      * @memberof RegoTerm
      */
     getValue(): RegoValue;
+    /**
+     * Whether or not the RegoTerm is resolvable
+     *
+     * @return {*}  {boolean}
+     * @memberof RegoTerm
+     */
+    isValueResolvable(): boolean;
+    toData(): {
+        type: string;
+        value: RegoTermValue;
+    };
+    toJson(): string;
+    toConciseData(): {
+        isRef: boolean;
+        value: RegoTermValue;
+    };
+    toConciseJSON(): string;
     static parseFromData(data: any, parser: OpaCompileResponseParser): RegoTerm;
 }
 /**
@@ -248,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`
@@ -286,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
      *
@@ -301,7 +443,25 @@ export declare class RegoExp {
      * @memberof RegoExp
      */
     getValue(): number | Object;
-    isMatch(): boolean;
+    /**
+     * Whether or not a expression should be considered as "matched".
+     * If all expressions of a rule are "matched", the rule will be considered as "matched".
+     * Thus, the rule has a value.
+     *
+     * Please note: if an expression's value is `0`, empty string "", null etc, the expression is considered as "matched".
+     * We only consider an expression as "Not Matched" when the expression has value `false` or is undefined.
+     *
+     * @return {boolean}
+     * @memberof RegoExp
+     */
+    isMatched(): boolean;
+    /**
+     * Whether or not the expression is resolvable now.
+     *
+     * @return {boolean}
+     * @memberof RegoExp
+     */
+    isResolvable(): boolean;
     /**
      * Convert operator term to string and put rest operands into an array.
      * And then return a [Operator, Operands] structure
@@ -309,7 +469,7 @@ export declare class RegoExp {
      * @returns {[string, RegoTerm[]]}
      * @memberof RegoExp
      */
-    toOperatorOperandsArray(): [string, RegoTerm[]];
+    toOperatorOperandsArray(): [RegoOperatorString, RegoTerm[]];
     /**
      * Try to evaluate the expression
      *
@@ -317,6 +477,45 @@ export declare class RegoExp {
      * @memberof RegoExp
      */
     evaluate(): this;
+    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: {
+            type: string;
+            value: RegoTermValue;
+        }[];
+        negated?: undefined;
+    };
+    toJSON(index?: number, ignoreIndex?: boolean, ignoreNegated?: boolean): string;
+    toConciseData(): {
+        negated: boolean;
+        operator: string;
+        operands: {
+            isRef: boolean;
+            value: RegoTermValue;
+        }[];
+    };
+    toConciseJSON(): string;
     static parseFromData(expData: any, parser: OpaCompileResponseParser): RegoExp;
 }
 /**
@@ -328,8 +527,24 @@ 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(): {
+        type: string;
+        value: RegoRefPart[];
+    };
+    toJson(): string;
     static parseFromData(data: any): RegoRef;
     static convertToFullRefString(parts: RegoRefPart[]): string;
     removeAllPrefixs(str: string, removalPrefixs?: string[]): string;
@@ -340,7 +555,7 @@ export declare class RegoRef {
     hasCollectionLookup(): boolean;
     isSimpleCollectionLookup(): boolean;
     isResolveAsCollectionValue(): boolean;
-    asOperator(): string;
+    asOperator(): RegoOperatorString | null;
 }
 export interface CompleteRuleResult {
     fullName: string;
@@ -350,6 +565,30 @@ export interface CompleteRuleResult {
     residualRules?: RegoRule[];
 }
 export declare function value2String(value: RegoValue): string;
+export declare class RegoRuleSet {
+    fullName: string;
+    name: string;
+    rules: RegoRule[];
+    defaultRule: RegoRule | null;
+    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;
+    getResidualRules(): RegoRule[];
+}
 /**
  * OPA result Parser
  *
@@ -387,6 +626,15 @@ export default class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     rules: RegoRule[];
+    /**
+     * Parsed, compressed & evaluated rule sets
+     *
+     * @type {RegoRuleSet[]}
+     * @memberof OpaCompileResponseParser
+     */
+    ruleSets: {
+        [fullName: string]: RegoRuleSet;
+    };
     queries: RegoExp[];
     /**
      * A cache of all resolved rule result
@@ -407,6 +655,7 @@ export default class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     readonly pseudoQueryRuleName: string;
+    private ruleDuplicationCheckCache;
     private setQueryRuleResult;
     /**
      * Parse OPA result Response
@@ -416,26 +665,10 @@ export default class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     parse(json: any): RegoRule[];
-    /**
-     * Tried to merge rules outcome so that the ref value can be established easier
-     * After this step, any rules doesn't involve unknown should be merged to one value
-     * This will help to generate more concise query later.
-     * `CompleteRule` rule involves no `unknowns`
-     *
-     * Only for internal usage
-     *
-     * @private
-     * @memberof OpaCompileResponseParser
-     */
-    private calculateCompleteRuleResult;
-    /**
-     * Only for internal usage
-     *
-     * @returns
-     * @private
-     * @memberof OpaCompileResponseParser
-     */
-    private reduceDependencies;
+    addRule(rule: RegoRule): void;
+    isRefResolvable(fullName: string): boolean;
+    getRefValue(fullName: string): any;
+    private resolveAllRuleSets;
     /**
      * Call to evaluate a rule
      *
@@ -466,15 +699,6 @@ export default class OpaCompileResponseParser {
      * @memberof OpaCompileResponseParser
      */
     evaluateAsHumanReadableString(): string;
-    /**
-     * Only for internal usage
-     *
-     * @param {RegoRule} rule
-     * @returns {CompleteRuleResult}
-     * @private
-     * @memberof OpaCompileResponseParser
-     */
-    private createCompleteRuleResult;
     reportWarns(msg: string): void;
 }
 export declare function unknown2Ref(unknown: string): string;