@freelog/freelog-cg-collection 1.0.0

package/index.js

@@ -0,0 +1,53 @@
+"use strict"
+
+const antlr4 = require("antlr4");
+const gen_dir = "./gen";
+const LexToken = require(`${gen_dir}/LexToken`);
+const {CollectionPolicyErrorLexerListener} = require("./CollectionPolicyErrorLexerListener");
+const {CollectionPolicyErrorListener} = require("./CollectionPolicyErrorListener");
+const {CollectionPolicyVisitor} = require("./gen/CollectionPolicyVisitor");
+const {CollectionPolicyCustomVisitor} = require("./CollectionPolicyCustomVisitor");
+const {CollectionPolicyParser} = require("./gen/CollectionPolicyParser");
+
+exports.compile = async function (policyText) {
+    let chars = new antlr4.InputStream(policyText);
+
+    let lexer = new LexToken.LexToken(chars);
+    lexer.removeErrorListeners();
+    let lexerErrorListener = new CollectionPolicyErrorLexerListener();
+    lexer.addErrorListener(lexerErrorListener);
+    let stream = new antlr4.CommonTokenStream(lexer);
+    let parser = new CollectionPolicyParser(stream);
+    parser.removeErrorListeners();
+    let errorListener = new CollectionPolicyErrorListener();
+    parser.addErrorListener(errorListener);
+    // 关闭恢复机制
+    // parser._errHandler = new antlr4.error.BailErrorStrategy();
+
+    let tree = parser.policy();
+    if (lexerErrorListener.errors.length !== 0) {
+        // console.error(`lexer -- ${lexerErrorListener.errors}`);
+        return {
+            errors: lexerErrorListener.errors,
+            errorObjects: lexerErrorListener.errorObjects
+        };
+    }
+    if (errorListener.errors.length !== 0) {
+        // console.error(`parse -- ${errorListener.errors}`);
+        return {
+            errors: errorListener.errors,
+            errorObjects: errorListener.errorObjects
+        };
+    }
+
+    let visitor = new CollectionPolicyCustomVisitor();
+    visitor.visit(tree);
+    // await visitor.verify();
+    // visitor.combine();
+
+    return {
+        audienceSection: visitor.audienceSection,
+        varDeclarationList: visitor.varDeclarationList,
+        stateMachine: visitor.stateMachine,
+    };
+}

package/indexTest.js

@@ -0,0 +1,23 @@
+const fs = require("fs");
+const policy_lang = require("./index");
+const {CollectionPolicyDecompiler} = require("./CollectionPolicyDecompiler");
+
+main();
+
+async function main() {
+    try {
+        let result = await policy_lang.compile(fs.readFileSync("./resources/zhaojn.sc", "utf-8"));
+        fs.writeFile("./resources/zhaojn.json", JSON.stringify(result, null, 4), (err) => {
+            if (err) throw err;
+        });
+    } catch (e) {
+        console.log(e);
+    }
+
+    // try {
+    //     let result = JSON.parse(fs.readFileSync("./resources/zhaojn.json", "utf-8"));
+    //     console.log(new CollectionPolicyDecompiler().decompile(result));
+    // } catch (e) {
+    //     console.log(e);
+    // }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@freelog/freelog-cg-collection",
+  "version": "1.0.0",
+  "main": "index.js",
+  "dependencies": {
+    "antlr4": "4.8.0",
+    "decimal.js": "^10.2.1",
+    "moment": "^2.29.1"
+  },
+  "devDependencies": {
+    "@types/chai": "^5.0.1",
+    "@types/mocha": "^5.2.7",
+    "@types/node": "^22.9.0",
+    "@types/sinon": "^17.0.3",
+    "chai": "^5.1.2",
+    "cross-env": "^6.0.3",
+    "mocha": "^10.8.2",
+    "nyc": "^17.1.0",
+    "sinon": "^19.0.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0"
+  },
+  "scripts": {
+    "test": "cross-env TS_NODE_PROJECT='test/tsconfig.test.json' mocha test/**/**.test.ts"
+  },
+  "mocha": {
+    "require": [
+      "ts-node/register",
+      "tsconfig-paths/register"
+    ]
+  }
+}

package/resources/event_definition.json

@@ -0,0 +1,169 @@
+[
+  {
+    "code": "S101",
+    "name": "SigningEvent",
+    "description": "acknowledge a resource",
+    "params": [
+      {
+        "name": "resourceName",
+        "type": "string"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "A101",
+    "name": "CycleEndEvent",
+    "description": "raise when n cycle ends",
+    "params": [
+      {
+        "name": "cycleCount",
+        "type": "decimal"
+      },
+      {
+        "name": "timeUnit",
+        "type": "timeUnit",
+        "enum": ["year","month","week","day","cycle"]
+      }
+    ],
+    "singleton": false
+  },
+  {
+    "code": "S201",
+    "name": "TransactionEvent",
+    "description": "one time transaction",
+    "params": [
+      {
+        "name": "amount",
+        "type": "decimal"
+      },
+      {
+        "name": "account",
+        "type": "none"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "S202",
+    "name": "SettlementEvent",
+    "description": "fired when settlement cleared",
+    "params": [
+      {
+        "name": "account",
+        "type": "none"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "A102",
+    "name": "TimeEvent",
+    "description": "fired on a pre-determined time",
+    "params": [
+      {
+        "name": "dateTime",
+        "type": "dateTime"
+      }
+    ],
+    "singleton": false
+  },
+  {
+    "code": "A103",
+    "name": "RelativeTimeEvent",
+    "description": "fired when certain amount of time elapsed",
+    "params": [
+      {
+        "name": "elapsed",
+        "type": "decimal"
+      },
+      {
+        "name": "timeUnit",
+        "type": "timeUnit",
+        "enum": ["year","month","week","day","cycle","hour","minute"]
+      }
+    ],
+    "singleton": false
+  },
+  {
+    "code": "S301",
+    "name": "ViewCountEvent",
+    "description": "reserve a target number of authorizations, fires when such number reached",
+    "params": [
+      {
+        "name": "amount",
+        "type": "decimal"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "S302",
+    "name": "ReContractCountEvent",
+    "description": "",
+    "params": [
+      {
+        "name": "amount",
+        "type": "decimal"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "S303",
+    "name": "PresentCountEvent",
+    "description": "",
+    "params": [
+      {
+        "name": "amount",
+        "type": "decimal"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "S210",
+    "name": "EscrowExceedAmount",
+    "description": "",
+    "params": [
+      {
+        "name": "account",
+        "type": "none"
+      },
+      {
+        "name": "amount",
+        "type": "decimal"
+      },
+      {
+        "name": "currencyUnit",
+        "type": "string",
+        "enum": ["feather","dollar","yuan","jiao","fen"]
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "S211",
+    "name": "EscrowConfiscated",
+    "description": "",
+    "params": [
+      {
+        "name": "account",
+        "type": "none"
+      }
+    ],
+    "singleton": true
+  },
+  {
+    "code": "S212",
+    "name": "EscrowRefunded",
+    "description": "",
+    "params": [
+      {
+        "name": "account",
+        "type": "none"
+      }
+    ],
+    "singleton": true
+  }
+]

package/resources/function_definite.json

@@ -0,0 +1,79 @@
+[
+  {
+    "name": "range",
+    "caller": "serviceState",
+    "params": [
+      {
+        "name": "index",
+        "type": "int"
+      },
+      {
+        "name": "limit",
+        "type": "int"
+      }
+    ],
+    "description": "取某个色块中的第${index}到${limit}之间的单品"
+  },
+  {
+    "name": "exclude",
+    "caller": "serviceState",
+    "params": [
+      {
+        "name": "a",
+        "type": "serviceState"
+      }
+    ],
+    "description": "取某个色块中的第${index}到${limit}之间的单品"
+  },
+  {
+    "name": "unionSet",
+    "caller": "serviceState",
+    "params": [
+      {
+        "name": "a",
+        "type": "serviceState"
+      }
+    ],
+    "description": "caller色块同a色块做并集运算"
+  },
+  {
+    "name": "intersection",
+    "caller": "serviceState",
+    "params": [
+      {
+        "name": "a",
+        "type": "serviceState"
+      }
+    ],
+    "description": "caller色块同a色块做交集运算"
+  },
+  {
+    "name": "set",
+    "caller": "serviceState",
+    "params": [
+      {
+        "name": "a",
+        "type": "string"
+      }
+    ],
+    "description": "将单品a添加到caller色块中"
+  },
+  {
+    "name": "unset",
+    "caller": "serviceState",
+    "params": [
+      {
+        "name": "a",
+        "type": "string"
+      }
+    ],
+    "description": "将单品a从caller色块中移除"
+  },
+  {
+    "name": "clean",
+    "caller": "serviceState",
+    "params": [
+    ],
+    "description": "清空caller色块中的单品"
+  }
+]

package/resources/test/CalculatorTest.json

@@ -0,0 +1,26 @@
+{
+  "type": "varGlobal",
+  "content": "amount=1+2*3",
+  "varName": "amount",
+  "varValue": "1+2*3",
+  "varValueObj": {
+    "expType": "expOp",
+    "var1": {
+      "expType": "number",
+      "value": "1"
+    },
+    "var2": {
+      "expType": "expOp",
+      "var1": {
+        "expType": "number",
+        "value": "2"
+      },
+      "var2": {
+        "expType": "number",
+        "value": "3"
+      },
+      "op": "*"
+    },
+    "op": "+"
+  }
+}

package/resources/test/FunctionHelperTest.json

@@ -0,0 +1,21 @@
+{
+  "funcName": "Max",
+  "paramList": [
+    {
+      "paramValue": "5",
+      "paramValueObj": {
+        "expType": "number",
+        "value": "5"
+      }
+    },
+    {
+      "paramValue": "6",
+      "paramValueObj": {
+        "expType": "number",
+        "value": "6"
+      }
+    }
+  ],
+  "expType": "functionCall",
+  "varChain": "Kit"
+}

package/resources/variable_definite.json

@@ -0,0 +1,10 @@
+[
+  {
+    "name": "this.all",
+    "type": "serviceState"
+  },
+  {
+    "name": "context.id",
+    "type": "serviceState"
+  }
+]

package/resources/zhaojn.json

@@ -0,0 +1,68 @@
+{
+    "audienceSection": {
+        "audiences": [
+            "PUBLIC"
+        ]
+    },
+    "varDeclarationList": [
+        {
+            "type": "varGlobal",
+            "content": "a=(-1)",
+            "varName": "a",
+            "varValue": "(-1)",
+            "varValueObj": {
+                "expType": "expParen",
+                "var1": {
+                    "expType": "expSigned",
+                    "var1": {
+                        "expType": "number",
+                        "value": "1"
+                    },
+                    "symbol": "-"
+                }
+            }
+        }
+    ],
+    "stateMachine": [
+        {
+            "stateName": "AUTH_VIP",
+            "assignments": [],
+            "events": [
+                {
+                    "type": "normal",
+                    "content": "Event.Transaction.Pay(amount=0.5*2,elemsNum=1)->AUTH_VIP",
+                    "eventName": "Pay",
+                    "eventParamList": [
+                        {
+                            "paramValue": "0.5*2",
+                            "paramValueObj": {
+                                "expType": "expOp",
+                                "var1": {
+                                    "expType": "number",
+                                    "value": "0.5"
+                                },
+                                "var2": {
+                                    "expType": "number",
+                                    "value": "2"
+                                },
+                                "op": "*"
+                            },
+                            "paramName": "amount"
+                        },
+                        {
+                            "paramValue": "1",
+                            "paramValueObj": {
+                                "expType": "number",
+                                "value": "1"
+                            },
+                            "paramName": "elemsNum"
+                        }
+                    ],
+                    "toState": "AUTH_VIP",
+                    "actions": [],
+                    "eventPath": "Transaction"
+                }
+            ]
+        }
+    ]
+}

package/resources/zhaojn.sc

@@ -0,0 +1,8 @@
+// 这里的echoSubject是用户组标的物，统一是用该标的物来取所有依托于该用户组的权限
+FOR PUBLIC
+
+// 用户组标的物
+a = (-1)
+
+AUTH_VIP Partial{set1}:
+    Event.Transaction.Pay(amount = 0.5 * 2, elemsNum = 1) -> AUTH_VIP

package/src/calculator/ExpArgsGroupCalculator.ts

@@ -0,0 +1,34 @@
+import {Calculator} from "../interface/Calculator";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {ExpHelper} from "../helper/ExpHelper";
+import {ExpArgsGroup} from "../model/exp-args-group/ExpArgsGroup";
+
+export class ExpArgsGroupCalculator implements Calculator {
+
+    private expHelper: ExpHelper;
+
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): any {
+        if (varObj.expType == "expArgsGroup") {
+            return this.generateExpArgsGroupValue(varObj as any, varContextCapable);
+        }
+
+        throw new Error("getExpValue fail [ExpArgsGroupCalculator]...");
+    }
+
+    generateExpArgsGroupValue(expArgsGroup: ExpArgsGroup, varContextCapable: VarContextCapable<any>) {
+        let result = {};
+        // @ts-ignore
+        if (expArgsGroup.paramList.length != 0) {
+            expArgsGroup.paramList.forEach(param => {
+                result[param.paramName] = this.expHelper.getExpValue(param.paramValueObj, varContextCapable);
+            });
+        }
+
+        return result;
+    }
+
+    setExpHelper(expHelper: ExpHelper) {
+        this.expHelper = expHelper;
+    }
+}

package/src/calculator/ExpBooleanCalculator.ts

@@ -0,0 +1,77 @@
+import {Calculator} from "../interface/Calculator";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {ExpHelper} from "../helper/ExpHelper";
+import {ExpBooleanOpCompare} from "../model/exp-boolean/ExpBooleanOpCompare";
+import {ExpBooleanOpLogic} from "../model/exp-boolean/ExpBooleanOpLogic";
+
+export class ExpBooleanCalculator implements Calculator {
+
+    private expHelper: ExpHelper;
+
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): boolean {
+        if (varObj.expType == "expBooleanOpLogic") {
+            return this.calculateExpBooleanOpLogic(varObj as any, varContextCapable);
+        }
+        if (varObj.expType == "expBooleanOpCompare") {
+            return this.calculateExpBooleanOpCompare(varObj as any, varContextCapable);
+        }
+        if (varObj.expType == "boolean") {
+            return varObj["value"] == "true";
+        }
+
+        throw new Error("getExpValue fail [ExpBooleanCalculator]...");
+    }
+
+    calculateExpBooleanOpLogic(expBooleanOpLogic: ExpBooleanOpLogic, varContextCapable: VarContextCapable<any>): boolean {
+        let var1 = this.expHelper.getExpValue(expBooleanOpLogic.var1, varContextCapable);
+        if (expBooleanOpLogic.op == "not") {
+            return !var1;
+        } else {
+            let var2 = this.expHelper.getExpValue(expBooleanOpLogic.var2, varContextCapable);
+            if (expBooleanOpLogic.op == "and") {
+                return var1 && var2;
+            }
+            if (expBooleanOpLogic.op == "or") {
+                return var1 || var2;
+            }
+        }
+
+        return false;
+    }
+
+    calculateExpBooleanOpCompare(expBooleanOpCompare: ExpBooleanOpCompare, varContextCapable: VarContextCapable<any>): boolean {
+        let var1 = this.expHelper.getExpValue(expBooleanOpCompare.var1, varContextCapable);
+        let var2 = this.expHelper.getExpValue(expBooleanOpCompare.var2, varContextCapable);
+        if (expBooleanOpCompare.op == "less" || expBooleanOpCompare.op == "<") {
+            return var1 < var2;
+        }
+        if (expBooleanOpCompare.op == "before") {
+            return var1 < var2;
+        }
+        if (expBooleanOpCompare.op == "lessOrEqual" || expBooleanOpCompare.op == "<=") {
+            return var1 <= var2;
+        }
+        if (expBooleanOpCompare.op == "greater" || expBooleanOpCompare.op == ">") {
+            return var1 > var2;
+        }
+        if (expBooleanOpCompare.op == "after") {
+            return var1 > var2;
+        }
+        if (expBooleanOpCompare.op == "greaterOrEqual" || expBooleanOpCompare.op == ">=") {
+            return var1 >= var2;
+        }
+        if (expBooleanOpCompare.op == "equal" || expBooleanOpCompare.op == "==") {
+            return var1 == var2;
+        }
+        if (expBooleanOpCompare.op == "notEqual" || expBooleanOpCompare.op == "!=") {
+            return var1 != var2;
+        }
+
+        return false;
+    }
+
+    setExpHelper(expHelper: ExpHelper) {
+        this.expHelper = expHelper;
+    }
+}

package/src/calculator/ExpCalculator.ts

@@ -0,0 +1,68 @@
+import {ExpOp} from "../model/exp/ExpOp";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {FunctionHelper} from "../helper/FunctionHelper";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {Calculator} from "../interface/Calculator";
+import {ExpHelper} from "../helper/ExpHelper";
+import {ExpSigned} from "../model/exp/ExpSigned";
+
+export class ExpCalculator implements Calculator {
+
+    private functionHelper: FunctionHelper;
+
+    private expHelper: ExpHelper;
+
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): any {
+        if (varObj.expType == "expOp") {
+            return this.calculateExpOp(varObj as any, varContextCapable);
+        }
+        if (varObj.expType == "number") {
+            return parseInt(varObj["value"]);
+        }
+        if (varObj.expType == "string") {
+            return varObj["value"];
+        }
+        if (varObj.expType == "entity") {
+            return varObj;
+        }
+        if (varObj.expType == "variableChain") {
+            return varContextCapable.getVarContext(varObj["content"]);
+        }
+        if (varObj.expType == "functionCall") {
+            return this.functionHelper.getFunctionValue(varObj as any, varContextCapable);
+        }
+        if (varObj.expType == "expParen") {
+            return this.expHelper.getExpValue(varObj["var1"], varContextCapable);
+        }
+        if (varObj.expType == "expSigned") {
+            return this.calculateExpSigned(varObj as any, varContextCapable);
+        }
+
+        throw new Error("getExpValue fail [ExpCalculator]...");
+    }
+
+    calculateExpOp(expOp: ExpOp, varContextCapable: VarContextCapable<any>): number {
+        let var1 = this.expHelper.getExpValue(expOp.var1, varContextCapable);
+        let var2 = this.expHelper.getExpValue(expOp.var2, varContextCapable);
+        let expStr = `${var1} ${expOp.op} ${var2}`;
+
+        return eval(expStr);
+    }
+
+    calculateExpSigned(expSigned: ExpSigned, varContextCapable: VarContextCapable<any>): number {
+        let var1 = this.expHelper.getExpValue(expSigned.var1, varContextCapable);
+        if (expSigned.symbol == "-") {
+            return -var1;
+        } else {
+            return var1;
+        }
+    }
+
+    setFunctionHelper(functionHelper: FunctionHelper) {
+        this.functionHelper = functionHelper;
+    }
+
+    setExpHelper(expHelper: ExpHelper) {
+        this.expHelper = expHelper;
+    }
+}