@abaplint/transpiler 2.0.7 → 2.0.10

package/build/src/expressions/simple_source3.d.ts

@@ -3,5 +3,7 @@ import { IExpressionTranspiler } from "./_expression_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SimpleSource3Transpiler implements IExpressionTranspiler {
+    private readonly addGet;
+    constructor(addGet?: boolean);
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/simple_source3.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleSource3Transpiler = void 0;
 const source_1 = require("./source");
 class SimpleSource3Transpiler {
+    constructor(addGet = false) {
+        this.addGet = addGet;
+    }
     transpile(node, traversal) {
-        return new source_1.SourceTranspiler().transpile(node, traversal);
+        return new source_1.SourceTranspiler(this.addGet).transpile(node, traversal);
     }
 }
 exports.SimpleSource3Transpiler = SimpleSource3Transpiler;

package/build/src/statements/select.d.ts

@@ -4,4 +4,6 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SelectTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private findKeys;
+    private concatCond;
 }

package/build/src/statements/select.js

@@ -11,6 +11,18 @@ class SelectTranspiler {
         let select = "SELECT ";
         select += ((_a = node.findFirstExpression(abaplint.Expressions.SQLFieldList)) === null || _a === void 0 ? void 0 : _a.concatTokens()) + " ";
         select += ((_b = node.findFirstExpression(abaplint.Expressions.SQLFrom)) === null || _b === void 0 ? void 0 : _b.concatTokens()) + " ";
+        const where = node.findFirstExpression(abaplint.Expressions.SQLCond);
+        if (where) {
+            select += "WHERE " + this.concatCond(where, traversal) + " ";
+        }
+        const orderBy = node.findFirstExpression(abaplint.Expressions.SQLOrderBy);
+        if (orderBy) {
+            select += orderBy.concatTokens() + " ";
+        }
+        const upTo = node.findFirstExpression(abaplint.Expressions.SQLUpTo);
+        if (upTo) {
+            select += upTo.concatTokens() + " ";
+        }
         for (const d of node.findAllExpressionsRecursive(abaplint.Expressions.Dynamic)) {
             const chain = d.findFirstExpression(abaplint.Expressions.FieldChain);
             if (chain) {
@@ -20,9 +32,42 @@ class SelectTranspiler {
             }
         }
         if (node.concatTokens().toUpperCase().startsWith("SELECT SINGLE ")) {
-            select += "LIMIT 1";
+            select += "UP TO 1 ROWS";
+        }
+        const keys = this.findKeys(node, traversal);
+        let primaryKey = "";
+        if (keys.length > 0) {
+            primaryKey = `, primaryKey: ${JSON.stringify(keys)}`;
+        }
+        return new chunk_1.Chunk().append(`await abap.statements.select(${target}, {select: "${select.trim()}"${primaryKey}});`, node, traversal);
+    }
+    findKeys(node, traversal) {
+        let keys = [];
+        const from = node.findAllExpressions(abaplint.Expressions.SQLFromSource).map(e => e.concatTokens());
+        if (from.length === 1) {
+            const tabl = traversal.findTable(from[0]);
+            if (tabl) {
+                keys = tabl.listKeys().map(k => k.toLowerCase());
+            }
+        }
+        return keys;
+    }
+    concatCond(cond, traversal) {
+        let ret = "";
+        for (const c of cond.getChildren()) {
+            if (c.get() instanceof abaplint.Expressions.SimpleSource3
+                && c instanceof abaplint.Nodes.ExpressionNode
+                && c.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
+                ret += " '\" + " + new expressions_1.SimpleSource3Transpiler(true).transpile(c, traversal).getCode() + " + \"'";
+            }
+            else if (c instanceof abaplint.Nodes.ExpressionNode) {
+                ret += " " + this.concatCond(c, traversal);
+            }
+            else {
+                ret += " " + c.concatTokens();
+            }
         }
-        return new chunk_1.Chunk().append(`await abap.statements.select(${target}, "${select.trim()}");`, node, traversal);
+        return ret.trim();
     }
 }
 exports.SelectTranspiler = SelectTranspiler;

package/build/src/statements/wait.js

@@ -3,22 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaitTranspiler = void 0;
 const abaplint = require("@abaplint/core");
 const chunk_1 = require("../chunk");
+const expressions_1 = require("../expressions");
 class WaitTranspiler {
     transpile(node, traversal) {
+        const options = [];
+        const seconds = node.findExpressionAfterToken("TO");
+        if (seconds) {
+            options.push("seconds: " + traversal.traverse(seconds).getCode());
+        }
         const concat = node.concatTokens().toUpperCase();
-        if (concat.includes(" FOR PUSH CHANNELS ") === false) {
-            return new chunk_1.Chunk().appendString("WAIT_TODO");
+        if (concat.includes(" UNTIL ") === false && seconds) {
+            const sec = new expressions_1.SourceTranspiler(true).transpile(seconds, traversal).getCode();
+            return new chunk_1.Chunk().appendString(`await new Promise(r => setTimeout(r, ${sec} * 1000));`);
         }
         const lookup = traversal.lookupClassOrInterface("KERNEL_PUSH_CHANNELS", node.getFirstToken());
-        const options = [];
         const cond = node.findFirstExpression(abaplint.Expressions.Cond);
         if (cond) {
             options.push("cond: " + traversal.traverse(cond).getCode());
         }
-        const seconds = node.findExpressionAfterToken("TO");
-        if (seconds) {
-            options.push("seconds: " + traversal.traverse(seconds).getCode());
-        }
         const call = `await ${lookup}.wait({${options.join(",")}});`;
         return new chunk_1.Chunk().append(`if (${lookup} === undefined) throw new Error("Wait, kernel class missing");\n${call}`, node, traversal);
     }

package/build/src/traversal.d.ts

@@ -32,6 +32,7 @@ export declare class Traversal {
     private findReadOrWriteReference;
     buildConstructorContents(scope: abaplint.ISpaghettiScopeNode | undefined, def: abaplint.IClassDefinition, inputName: string): string;
     findInterfaceDefinition(name: string, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IInterfaceDefinition | undefined;
+    findTable(name: string): abaplint.Objects.Table | undefined;
     findClassDefinition(name: string, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IClassDefinition | undefined;
     private dataFromInterfaces;
     determineType(node: abaplint.Nodes.ExpressionNode | abaplint.Nodes.StatementNode, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.AbstractType | undefined;

package/build/src/traversal.js

@@ -289,6 +289,10 @@ class Traversal {
         }
         return intf;
     }
+    findTable(name) {
+        const tabl = this.reg.getObject("TABL", name);
+        return tabl;
+    }
     findClassDefinition(name, scope) {
         let clas = scope === null || scope === void 0 ? void 0 : scope.findClassDefinition(name);
         if (clas === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.0.7",
+  "version": "2.0.10",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -28,11 +28,11 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.88.6",
+    "@abaplint/core": "^2.89.0",
     "source-map": "^0.7.3"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.0",
+    "@types/chai": "^4.3.1",
     "@types/mocha": "^9.1.0",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",