@magda/typescript-common 1.2.0-rc.0 → 2.0.0-alpha.0

package/dist/OpaCompileResponseParser.d.ts

@@ -95,6 +95,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 +111,43 @@ export declare class RegoRule {
      * @memberof RegoRule
      */
     toHumanReadableString(): string;
+    toData(): {
+        default: boolean;
+        value: RegoValue;
+        fullName: string;
+        name: string;
+        expressions: ({
+            negated: boolean;
+            index: number;
+            terms: {
+                type: string;
+                value: RegoTermValue;
+            }[];
+        } | {
+            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 +168,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.
@@ -217,7 +269,7 @@ export declare class RegoTerm {
      * @returns {string}
      * @memberof RegoTerm
      */
-    asOperator(): string;
+    asOperator(): "=" | "!=" | "<" | ">" | "<=" | ">=";
     /**
      * If it's a operator term
      *
@@ -232,6 +284,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;
 }
 /**
@@ -301,7 +370,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 +396,7 @@ export declare class RegoExp {
      * @returns {[string, RegoTerm[]]}
      * @memberof RegoExp
      */
-    toOperatorOperandsArray(): [string, RegoTerm[]];
+    toOperatorOperandsArray(): [RegoOperatorString, RegoTerm[]];
     /**
      * Try to evaluate the expression
      *
@@ -317,6 +404,31 @@ export declare class RegoExp {
      * @memberof RegoExp
      */
     evaluate(): this;
+    toData(index?: number): {
+        negated: boolean;
+        index: number;
+        terms: {
+            type: string;
+            value: RegoTermValue;
+        }[];
+    } | {
+        index: number;
+        terms: {
+            type: string;
+            value: RegoTermValue;
+        }[];
+        negated?: undefined;
+    };
+    toJSON(index?: number): string;
+    toConciseData(): {
+        negated: boolean;
+        operator: string;
+        operands: {
+            isRef: boolean;
+            value: RegoTermValue;
+        }[];
+    };
+    toConciseJSON(): string;
     static parseFromData(expData: any, parser: OpaCompileResponseParser): RegoExp;
 }
 /**
@@ -330,6 +442,11 @@ export declare class RegoRef {
     parts: RegoRefPart[];
     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 +457,7 @@ export declare class RegoRef {
     hasCollectionLookup(): boolean;
     isSimpleCollectionLookup(): boolean;
     isResolveAsCollectionValue(): boolean;
-    asOperator(): string;
+    asOperator(): RegoOperatorString | null;
 }
 export interface CompleteRuleResult {
     fullName: string;
@@ -350,6 +467,19 @@ 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;
+    constructor(parser: OpaCompileResponseParser, rules: RegoRule[], fullName?: string, name?: string);
+    evaluate(): RegoRuleSet;
+    isResolvable(): boolean;
+    getResidualRules(): RegoRule[];
+}
 /**
  * OPA result Parser
  *
@@ -387,6 +517,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
@@ -416,26 +555,9 @@ 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;
+    isRefResolvable(fullName: string): boolean;
+    getRefValue(fullName: string): any;
+    private resolveAllRuleSets;
     /**
      * Call to evaluate a rule
      *
@@ -466,15 +588,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;