@lcap/nasl 3.8.2-beta.8 → 3.8.3-beta.1

package/src/utils/index.ts

@@ -296,10 +296,6 @@ export function getAncestorExistingParamNames(baseNode: types.SyntaxNode) {
           names.add(param.name);
         });
         break;
-      case 'ForEachStatement':
-        names.add((node as ForEachStatement).item?.name);
-        names.add((node as ForEachStatement).index?.name);
-        break;
       case 'Interface':
       case 'Logic':
       case 'View':

package/src/utils/language-cache/constant.ts

@@ -13,6 +13,7 @@ export const NaslCacheLimit = 3 * 24 * 60 * 60 * 1000;
 /** 数据库储存表 */
 export enum StoreName {
   Nasl = 'Nasl',
+  OQLToTypeScript = 'OQLToTypeScript',
 }
 
 /**

package/src/utils/language-cache/nasl.ts

@@ -1,6 +1,12 @@
 import { isNode } from '../env';
 import { StoreName, DbName, NaslCacheLimit, tabId } from './constant';
 import { LanguageDatabase, NaslCacheData, NaslCacheUpdateData } from './types';
+import localforage from 'localforage';
+
+export const naslOQLCacheStore = localforage.createInstance({
+  description: 'OQL to TypeScript接口缓存',
+  storeName: StoreName.OQLToTypeScript
+});
 
 /** 缓存数据库 */
 const database = isNode

package/test/concepts/member-expression/__snapshots__/toJS.spec.ts.snap

@@ -6,7 +6,7 @@ exports[`member-expression:toJS app.enums.UserStatusEnum 1`] = `
 `;
 
 exports[`member-expression:toJS elements.table-view.data 1`] = `
-"this.__tableView_dataSource;
+"this.__tableView_data;
 "
 `;
 

package/test/concepts/member-expression/__snapshots__/toVue.spec.ts.snap

@@ -6,7 +6,7 @@ exports[`member-expression:toVue app.enums.UserStatusEnum 1`] = `
 `;
 
 exports[`member-expression:toVue elements.table-view.data 1`] = `
-"<template>__tableView_dataSource</template>
+"<template>__tableView_data</template>
 "
 `;
 

package/test/tdd/dataQuery/QueryFieldExpression/case1/ast.json

@@ -0,0 +1,7 @@
+{
+    "concept": "QueryFieldExpression",
+    "isDotStar": true,
+    "entityAsName": "OrderProduct",
+    "propertyName": "",
+    "asName": ""
+}

package/test/tdd/dataQuery/QueryFieldExpression/case1/natural.ts.txt

@@ -0,0 +1 @@
+OrderProduct

package/test/tdd/dataQuery/QueryFieldExpression/case2/ast.json

@@ -0,0 +1,7 @@
+{
+    "concept": "QueryFieldExpression",
+    "isDotStar": false,
+    "entityAsName": "OrderProduct",
+    "propertyName": "amount",
+    "asName": ""
+}

package/test/tdd/dataQuery/QueryFieldExpression/case2/natural.ts.txt

@@ -0,0 +1 @@
+OrderProduct.amount

package/test/tdd/transform/case1/ast.json

@@ -0,0 +1,243 @@
+{
+    "concept": "Logic",
+    "name": "load1",
+    "params": [
+        {
+            "concept": "Param",
+            "name": "startDateTime",
+            "typeAnnotation": {
+                "concept": "TypeAnnotation",
+                "typeKind": "primitive",
+                "typeNamespace": "nasl.core",
+                "typeName": "DateTime"
+            },
+            "cascader": false
+        }
+    ],
+    "returns": [
+        {
+            "concept": "Return",
+            "name": "result"
+        }
+    ],
+    "variables": [],
+    "body": [
+        {
+            "concept": "Start",
+            "folded": false
+        },
+        {
+            "concept": "Assignment",
+            "left": {
+                "concept": "Identifier",
+                "name": "result",
+                "folded": false
+            },
+            "right": {
+                "concept": "CallQueryComponent",
+                "select": {
+                    "concept": "QuerySelectExpression",
+                    "distinct": false,
+                    "star": true,
+                    "selectElements": [
+                        {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": true,
+                            "entityAsName": "OrderProduct",
+                            "propertyName": "",
+                            "folded": false
+                        },
+                        {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": true,
+                            "entityAsName": "OrderForm",
+                            "propertyName": "",
+                            "folded": false
+                        },
+                        {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": true,
+                            "entityAsName": "Product",
+                            "propertyName": "",
+                            "folded": false
+                        },
+                        {
+                            "concept": "QueryAggregateExpression",
+                            "asName": "totalAmount",
+                            "aggregateName": "SUM",
+                            "aggregateParam": {
+                                "concept": "QueryFieldExpression",
+                                "isDotStar": false,
+                                "entityAsName": "OrderProduct",
+                                "propertyName": "amount",
+                                "folded": false
+                            },
+                            "folded": false
+                        }
+                    ],
+                    "folded": false
+                },
+                "from": {
+                    "concept": "QueryFromExpression",
+                    "entityNamespace": "app.dataSources.defaultDS.entities",
+                    "entityName": "OrderProduct",
+                    "joinParts": [
+                        {
+                            "concept": "QueryJoinExpression",
+                            "entityNamespace": "app.dataSources.defaultDS.entities",
+                            "entityName": "OrderForm",
+                            "joinType": "INNER",
+                            "onExpressions": [
+                                {
+                                    "concept": "BinaryExpression",
+                                    "left": {
+                                        "concept": "QueryFieldExpression",
+                                        "isDotStar": false,
+                                        "entityAsName": "OrderProduct",
+                                        "propertyName": "orderId",
+                                        "folded": false
+                                    },
+                                    "right": {
+                                        "concept": "QueryFieldExpression",
+                                        "isDotStar": false,
+                                        "entityAsName": "OrderForm",
+                                        "propertyName": "id",
+                                        "folded": false
+                                    },
+                                    "operator": "==",
+                                    "folded": false
+                                }
+                            ],
+                            "joinParts": [],
+                            "folded": false
+                        },
+                        {
+                            "concept": "QueryJoinExpression",
+                            "entityNamespace": "app.dataSources.defaultDS.entities",
+                            "entityName": "Product",
+                            "joinType": "INNER",
+                            "onExpressions": [
+                                {
+                                    "concept": "BinaryExpression",
+                                    "left": {
+                                        "concept": "QueryFieldExpression",
+                                        "isDotStar": false,
+                                        "entityAsName": "OrderProduct",
+                                        "propertyName": "productId",
+                                        "folded": false
+                                    },
+                                    "right": {
+                                        "concept": "QueryFieldExpression",
+                                        "isDotStar": false,
+                                        "entityAsName": "Product",
+                                        "propertyName": "id",
+                                        "folded": false
+                                    },
+                                    "operator": "==",
+                                    "folded": false
+                                }
+                            ],
+                            "joinParts": [],
+                            "folded": false
+                        }
+                    ],
+                    "folded": false
+                },
+                "where": {
+                    "concept": "BinaryExpression",
+                    "left": {
+                        "concept": "BinaryExpression",
+                        "left": {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": false,
+                            "entityAsName": "OrderProduct",
+                            "propertyName": "createdBy",
+                            "folded": false
+                        },
+                        "right": {
+                            "concept": "StringLiteral",
+                            "value": "张三",
+                            "folded": false
+                        },
+                        "operator": "==",
+                        "folded": false
+                    },
+                    "right": {
+                        "concept": "BinaryExpression",
+                        "left": {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": false,
+                            "entityAsName": "OrderProduct",
+                            "propertyName": "createdTime",
+                            "folded": false
+                        },
+                        "right": {
+                            "concept": "Identifier",
+                            "name": "startDateTime",
+                            "folded": false
+                        },
+                        "operator": ">",
+                        "folded": false
+                    },
+                    "operator": "&&",
+                    "folded": false
+                },
+                "wherePlayground": [],
+                "groupBy": [
+                    {
+                        "concept": "QueryGroupByExpression",
+                        "groupElement": {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": false,
+                            "asName": "productId",
+                            "entityAsName": "OrderProduct",
+                            "propertyName": "productId",
+                            "folded": false
+                        },
+                        "folded": false
+                    },
+                    {
+                        "concept": "QueryGroupByExpression",
+                        "groupElement": {
+                            "concept": "QueryFieldExpression",
+                            "isDotStar": false,
+                            "asName": "productName",
+                            "entityAsName": "Product",
+                            "propertyName": "name",
+                            "folded": false
+                        },
+                        "folded": false
+                    }
+                ],
+                "having": null,
+                "havingPlayground": [],
+                "orderBy": [
+                    {
+                        "concept": "QueryOrderByExpression",
+                        "orderElement": {
+                            "concept": "Identifier",
+                            "namespace": "inner",
+                            "name": "productName",
+                            "folded": false
+                        },
+                        "order": {
+                            "concept": "StringLiteral",
+                            "value": "ASC",
+                            "folded": false
+                        },
+                        "folded": false
+                    }
+                ],
+                "limit": null,
+                "ideVersion": "2.22",
+                "folded": false
+            },
+            "folded": false
+        },
+        {
+            "concept": "End",
+            "folded": false
+        }
+    ],
+    "playground": []
+}

package/test/tdd/transform/case1/natural.ts.md

@@ -0,0 +1,20 @@
+```ts
+function load1(startDateTime: DateTime) {
+    let result;
+    result = FROM(app.dataSources.defaultDS.entities.OrderProductEntity, OrderProduct => $
+    .INNER_JOIN(app.dataSources.defaultDS.entities.OrderFormEntity, OrderForm => ON(OrderProduct.orderId == OrderForm.id)
+    .INNER_JOIN(app.dataSources.defaultDS.entities.ProductEntity, Product => ON(OrderProduct.productId == Product.id)
+    .WHERE(OrderProduct.createdBy == '张三' && OrderProduct.createdTime > startDateTime)
+    .GROUP_BY(OrderProduct.productId, Product.name)
+    .ORDER_BY([productName, 'ASC'])
+    .SELECT({
+        orderProduct: OrderProduct,
+        orderForm: OrderForm,
+        product: Product,
+        totalAmount: SUM(OrderProduct.amount),
+        productId: OrderProduct.productId,
+        productName: Product.name,
+    }))));
+    return result;
+}
+```

package/test/tdd/transform/case2/ast.json

@@ -0,0 +1,207 @@
+{
+    "concept": "Logic",
+    "name": "loadDashboardTableView_1",
+    "params": [
+        {
+            "concept": "Param",
+            "name": "page",
+            "typeAnnotation": {
+                "concept": "TypeAnnotation",
+                "typeKind": "primitive",
+                "typeNamespace": "nasl.core",
+                "typeName": "Long"
+            },
+            "cascader": false
+        },
+        {
+            "concept": "Param",
+            "name": "size",
+            "typeAnnotation": {
+                "concept": "TypeAnnotation",
+                "typeKind": "primitive",
+                "typeNamespace": "nasl.core",
+                "typeName": "Long"
+            },
+            "cascader": false
+        },
+        {
+            "concept": "Param",
+            "name": "sort",
+            "typeAnnotation": {
+                "concept": "TypeAnnotation",
+                "typeKind": "primitive",
+                "typeNamespace": "nasl.core",
+                "typeName": "String"
+            },
+            "cascader": false
+        },
+        {
+            "concept": "Param",
+            "name": "order",
+            "typeAnnotation": {
+                "concept": "TypeAnnotation",
+                "typeKind": "primitive",
+                "typeNamespace": "nasl.core",
+                "typeName": "String"
+            },
+            "cascader": false
+        },
+        {
+            "concept": "Param",
+            "name": "filter",
+            "typeAnnotation": {
+                "concept": "TypeAnnotation",
+                "typeKind": "reference",
+                "typeNamespace": "app.dataSources.defaultDS.entities",
+                "typeName": "Student"
+            },
+            "cascader": false
+        }
+    ],
+    "returns": [
+        {
+            "concept": "Return",
+            "name": "result"
+        }
+    ],
+    "variables": [],
+    "body": [
+        {
+            "concept": "Start",
+            "folded": false
+        },
+        {
+            "concept": "Assignment",
+            "left": {
+                "concept": "Identifier",
+                "name": "result",
+                "folded": false
+            },
+            "right": {
+                "concept": "Paginate",
+                "list": {
+                    "concept": "CallQueryComponent",
+                    "select": {
+                        "concept": "QuerySelectExpression",
+                        "distinct": false,
+                        "star": true,
+                        "selectElements": [
+                            {
+                                "concept": "QueryFieldExpression",
+                                "isDotStar": true,
+                                "entityAsName": "Student",
+                                "propertyName": "",
+                                "folded": false
+                            }
+                        ],
+                        "folded": false
+                    },
+                    "from": {
+                        "concept": "QueryFromExpression",
+                        "entityNamespace": "app.dataSources.defaultDS.entities",
+                        "entityName": "Student",
+                        "joinParts": [],
+                        "folded": false
+                    },
+                    "where": {
+                        "concept": "BinaryExpression",
+                        "left": {
+                            "concept": "BinaryExpression",
+                            "left": {
+                                "concept": "QueryFieldExpression",
+                                "isDotStar": false,
+                                "entityAsName": "Student",
+                                "propertyName": "name",
+                                "folded": false
+                            },
+                            "right": {
+                                "concept": "MemberExpression",
+                                "object": {
+                                    "concept": "Identifier",
+                                    "name": "filter",
+                                    "folded": false
+                                },
+                                "property": {
+                                    "concept": "Identifier",
+                                    "name": "name",
+                                    "folded": false
+                                },
+                                "folded": false
+                            },
+                            "operator": "like",
+                            "folded": false
+                        },
+                        "right": {
+                            "concept": "BinaryExpression",
+                            "left": {
+                                "concept": "QueryFieldExpression",
+                                "isDotStar": false,
+                                "entityAsName": "Student",
+                                "propertyName": "age",
+                                "folded": false
+                            },
+                            "right": {
+                                "concept": "MemberExpression",
+                                "object": {
+                                    "concept": "Identifier",
+                                    "name": "filter",
+                                    "folded": false
+                                },
+                                "property": {
+                                    "concept": "Identifier",
+                                    "name": "age",
+                                    "folded": false
+                                },
+                                "folded": false
+                            },
+                            "operator": "==",
+                            "folded": false
+                        },
+                        "operator": "&&",
+                        "folded": false
+                    },
+                    "wherePlayground": [],
+                    "groupBy": [],
+                    "having": null,
+                    "havingPlayground": [],
+                    "orderBy": [
+                        {
+                            "concept": "QueryOrderByExpression",
+                            "orderElement": {
+                                "concept": "Identifier",
+                                "name": "sort",
+                                "folded": false
+                            },
+                            "order": {
+                                "concept": "Identifier",
+                                "name": "order",
+                                "folded": false
+                            },
+                            "folded": false
+                        }
+                    ],
+                    "limit": null,
+                    "ideVersion": "2.22",
+                    "folded": false
+                },
+                "page": {
+                    "concept": "Identifier",
+                    "name": "page",
+                    "folded": false
+                },
+                "size": {
+                    "concept": "Identifier",
+                    "name": "size",
+                    "folded": false
+                },
+                "folded": false
+            },
+            "folded": false
+        },
+        {
+            "concept": "End",
+            "folded": false
+        }
+    ],
+    "playground": []
+}

package/test/tdd/transform/case2/natural.ts.md

@@ -0,0 +1,12 @@
+```ts
+function loadDashboardTableView_1(page: Long, size: Long, sort: String, order: String, filter: app.dataSources.defaultDS.entities.Student) {
+    let result;
+    result = PAGINATE(FROM(app.dataSources.defaultDS.entities.StudentEntity, Student => $
+    .WHERE(LIKE(Student.name, filter.name) && Student.age == filter.age)
+    .ORDER_BY([sort, order])
+    .SELECT(({
+        student: Student,
+    }))), page, size)
+    return result;
+}
+```

package/test/tdd.test.js

@@ -0,0 +1,10 @@
+const path = require('path');
+const { loadCase, createTestTree } = require('./utils');
+const { suite, test } = require('mocha');
+const { expect } = require('chai');
+const nasl = require('../out');
+
+// createTestTree(path.join(__dirname, 'tdd'), (dir, fileName) => {
+//     const { astJSON, naturalTS } = loadCase(path.join(dir, fileName));
+//     expect(nasl.BaseNode.from(astJSON).toNaturalTS()).equals(naturalTS);
+// })();

package/test/tdd.transform.test.js

@@ -0,0 +1,38 @@
+const path = require('path');
+const { loadCase, createTestTree } = require('./utils');
+const { suite, test } = require('mocha');
+const { expect } = require('chai');
+const nasl = require('../out');
+const fs = require('fs-extra')
+
+suite('transform', () => {
+  test('case1', () => {
+    const { astJSON, naturalTS } = loadCase('transform/case1');
+    const expectedJSON = JSON.parse(JSON.stringify(nasl.BaseNode.from(astJSON)));
+    const actualJSON = JSON.parse(JSON.stringify(nasl.transformTSCode(naturalTS)));
+    fs.outputJSONSync(path.join(__dirname, '../tmp', 'case1.parsed.json'), actualJSON, { spaces: 4 });
+    fs.outputJSONSync(path.join(__dirname, '../tmp', 'case1.source.json'), expectedJSON, { spaces: 4 });
+    try {
+      expect(actualJSON).to.deep.equal(expectedJSON);
+    } catch(err) {
+      // console.log('expectedJSON:', JSON.stringify(expectedJSON, null, 2));
+      // console.log('actualJSON:', JSON.stringify(expectedJSON, null, 2));
+      throw err;
+    }
+  });
+
+  test('case2', () => {
+    const { astJSON, naturalTS } = loadCase('transform/case2');
+    const expectedJSON = JSON.parse(JSON.stringify(nasl.BaseNode.from(astJSON)));
+    const actualJSON = JSON.parse(JSON.stringify(nasl.transformTSCode(naturalTS)));
+    fs.outputJSONSync(path.join(__dirname, '../tmp', 'case2.parsed.json'), actualJSON, { spaces: 4 });
+    fs.outputJSONSync(path.join(__dirname, '../tmp', 'case2.source.json'), expectedJSON, { spaces: 4 });
+    try {
+      expect(actualJSON).to.deep.equal(expectedJSON);
+    } catch(err) {
+      // console.log('expectedJSON:', JSON.stringify(expectedJSON, null, 2));
+      // console.log('actualJSON:', JSON.stringify(expectedJSON, null, 2));
+      throw err;
+    }
+  });
+});

package/test/utils.js

@@ -0,0 +1,40 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { suite, test } = require('mocha');
+
+function unwrapCodeBlock(code) {
+    return code.replace(/^\s*```ts\n/, '').replace(/\n```\s*$/, '');
+}
+
+exports.loadCase = function loadCase(dirPath) {
+    dirPath = path.resolve(__dirname, 'tdd', dirPath);
+
+    const astJSON = fs.readJSONSync(path.join(dirPath, 'ast.json'), 'utf-8');
+    const naturalTS = unwrapCodeBlock(fs.readFileSync(path.join(dirPath, 'natural.ts.md'), 'utf-8'));
+
+    return { astJSON, naturalTS };
+};
+
+exports.createTestTree = function createTestTree(dirPath, cb) {
+    function createTestList(dir) {
+        const list = fs
+            .readdirSync(dir)
+            .filter((fileName) => !fileName.startsWith('.') && !['node_modules', 'out'].includes(fileName));
+        const hasCase = list.some((fileName) => fileName.startsWith('case'));
+        
+        if (hasCase) {
+            return () => {
+                list.forEach((fileName) => {
+                    test(fileName, () => cb(dir, fileName));
+                });
+            }
+        } else {
+            return () => {
+                list.forEach((fileName) => {
+                    suite(fileName, createTestList(path.join(dir, fileName)));
+                });
+            }
+        }
+    }
+    return createTestList(dirPath);
+};