@abaplint/transpiler 2.7.1 → 2.7.2

package/build/src/db/index.js

@@ -4,6 +4,12 @@ exports.DatabaseSetup = void 0;
 /* eslint-disable max-len */
 const abaplint = require("@abaplint/core");
 const sqlite_database_schema_1 = require("./sqlite_database_schema");
+const pg_database_schema_1 = require("./pg_database_schema");
+/////////////////////////
+// NOTES
+/////////////////////////
+// Postgres is case sensitive, so all column names should be lower case
+// Sqlite escapes field names with single qoute, postgres with double
 class DatabaseSetup {
     constructor(reg) {
         this.reg = reg;
@@ -13,7 +19,7 @@ class DatabaseSetup {
             schemas: {
                 sqlite: new sqlite_database_schema_1.SQLiteDatabaseSchema(this.reg).run(),
                 hdb: ["todo"],
-                pg: ["todo"],
+                pg: new pg_database_schema_1.PGDatabaseSchema(this.reg).run(),
             },
             insert: this.buildInsert(options),
         };
@@ -57,7 +63,7 @@ class DatabaseSetup {
         const type = tabl.parseType(this.reg);
         if (type instanceof abaplint.BasicTypes.StructureType && type.getComponents().length >= 3) {
             // todo, this should take the client number from the settings
-            return `INSERT INTO t000 ('MANDT', 'CCCATEGORY', 'CCNOCLIIND') VALUES ('123', '', '');`;
+            return `INSERT INTO t000 ('mandt', 'cccategory', 'ccnocliind') VALUES ('123', '', '');`;
         }
         else {
             return "";
@@ -71,7 +77,7 @@ class DatabaseSetup {
         }
         let ret = "";
         for (const m of msag.getMessages()) {
-            ret += `INSERT INTO t100 ('SPRSL', 'ARBGB', 'MSGNR', 'TEXT') VALUES ('E', '${msag.getName().padEnd(20, " ")}', '${m.getNumber()}', '${this.escape(m.getMessage().padEnd(73, " "))}');\n`;
+            ret += `INSERT INTO t100 ("sprsl", "arbgb", "msgnr", "text") VALUES ('E', '${msag.getName().padEnd(20, " ")}', '${m.getNumber()}', '${this.escape(m.getMessage().padEnd(73, " "))}');\n`;
         }
         return ret;
     }

package/build/src/db/pg_database_schema.d.ts

@@ -0,0 +1,9 @@
+import * as abaplint from "@abaplint/core";
+export declare class PGDatabaseSchema {
+    private readonly reg;
+    constructor(reg: abaplint.IRegistry);
+    run(): string[];
+    private buildVIEW;
+    private buildTABL;
+    private toType;
+}

package/build/src/db/pg_database_schema.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PGDatabaseSchema = void 0;
+const abaplint = require("@abaplint/core");
+class PGDatabaseSchema {
+    constructor(reg) {
+        this.reg = reg;
+    }
+    run() {
+        const statements = [];
+        // CREATE TABLEs
+        for (const obj of this.reg.getObjects()) {
+            if (obj instanceof abaplint.Objects.Table
+                && obj.getTableCategory() === abaplint.Objects.TableCategory.Transparent) {
+                statements.push(this.buildTABL(obj).trim());
+            }
+        }
+        // CREATE VIEWs after TABLEs
+        // todo: what if the view is based on another view?
+        for (const obj of this.reg.getObjects()) {
+            if (obj instanceof abaplint.Objects.View) {
+                statements.push(this.buildVIEW(obj).trim());
+            }
+        }
+        return statements;
+    }
+    //////////////////
+    // https://www.sqlite.org/lang_createview.html
+    buildVIEW(view) {
+        const fields = view.getFields();
+        let firstTabname = "";
+        const columns = fields === null || fields === void 0 ? void 0 : fields.map((f) => {
+            firstTabname = "'" + f.TABNAME.toLowerCase() + "'";
+            return firstTabname + "." + f.FIELDNAME.toLowerCase() + " AS " + f.VIEWFIELD.toLowerCase();
+        }).join(", ");
+        let from = "";
+        let previous = "";
+        for (const j of view.getJoin() || []) {
+            if (previous === "") {
+                from += "'" + j.LTAB.toLowerCase() + "' INNER JOIN '" + j.RTAB.toLowerCase() + "' ON '" + j.LTAB.toLowerCase() + "'." + j.LFIELD.toLowerCase() + " = '" + j.RTAB.toLowerCase() + "'." + j.RFIELD.toLowerCase();
+            }
+            else if (previous === j.LTAB + "," + j.RTAB) {
+                from += " AND '" + j.LTAB.toLowerCase() + "'." + j.LFIELD.toLowerCase() + " = '" + j.RTAB.toLowerCase() + "'." + j.RFIELD.toLowerCase();
+            }
+            else {
+                from += " INNER JOIN '" + j.RTAB.toLowerCase() + "' ON '" + j.LTAB.toLowerCase() + "'." + j.LFIELD.toLowerCase() + " = '" + j.RTAB.toLowerCase() + "'." + j.RFIELD.toLowerCase();
+            }
+            previous = j.LTAB + "," + j.RTAB;
+        }
+        from = from.trim();
+        if (from === "") {
+            from = firstTabname;
+        }
+        return `CREATE VIEW '${view.getName().toLowerCase()}' AS SELECT ${columns} FROM ${from};\n`;
+    }
+    buildTABL(tabl) {
+        const type = tabl.parseType(this.reg);
+        if (!(type instanceof abaplint.BasicTypes.StructureType)) {
+            return "";
+        }
+        const fields = [];
+        const fieldsRaw = [];
+        for (const field of type.getComponents()) {
+            if (field.type instanceof abaplint.BasicTypes.StructureType) {
+                // is a GROUP NAME
+                continue;
+            }
+            fieldsRaw.push(field.name.toLowerCase());
+            fields.push("\"" + field.name.toLowerCase() + "\" " + this.toType(field.type, field.name, tabl.getName()));
+        }
+        // assumption: all transparent tables have primary keys
+        // add single quotes to field names to allow for keywords as field names
+        const key = ", PRIMARY KEY(" + tabl.listKeys(this.reg)
+            .filter(e => fieldsRaw.includes(e.toLowerCase()))
+            .map(e => "\"" + e.toLowerCase() + "\"").join(",") + ")";
+        return `CREATE TABLE "${tabl.getName().toLowerCase()}" (${fields.join(", ")}${key});\n`;
+    }
+    toType(type, fieldname, errorInfo) {
+        if (type instanceof abaplint.BasicTypes.CharacterType) {
+            return `NCHAR(${type.getLength()})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.TimeType) {
+            return `NCHAR(6)`;
+        }
+        else if (type instanceof abaplint.BasicTypes.DateType) {
+            return `NCHAR(8)`;
+        }
+        else if (type instanceof abaplint.BasicTypes.NumericType) {
+            // it will be fine, the runtime representation of numc is also text
+            return `NCHAR(${type.getLength()})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.StringType) {
+            return `TEXT`;
+        }
+        else if (type instanceof abaplint.BasicTypes.XStringType) {
+            // it will be fine, the runtime representation of xstring is also text
+            return `TEXT`;
+        }
+        else if (type instanceof abaplint.BasicTypes.HexType) {
+            return `NCHAR(${type.getLength() * 2})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.IntegerType) {
+            return `INT`;
+        }
+        else if (type instanceof abaplint.BasicTypes.FloatType
+            || type instanceof abaplint.BasicTypes.FloatingPointType) {
+            return `REAL`;
+        }
+        else if (type instanceof abaplint.BasicTypes.PackedType) {
+            return `DECIMAL(${type.getLength()},${type.getDecimals()})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.VoidType) {
+            throw `Type of ${errorInfo}-${fieldname} is VoidType(${type.getVoided()}), make sure the type is known, enable strict syntax checking`;
+        }
+        else {
+            throw "database_setup: " + errorInfo + "-" + fieldname + ", todo toType handle: " + type.constructor.name;
+        }
+    }
+}
+exports.PGDatabaseSchema = PGDatabaseSchema;
+//# sourceMappingURL=pg_database_schema.js.map

package/build/src/index.d.ts

@@ -1,7 +1,7 @@
 import * as abaplint from "@abaplint/core";
 import { config } from "./validation";
 import { IFile, IOutput, IProgress, ITranspilerOptions, IOutputFile } from "./types";
-export { config, ITranspilerOptions, IFile, IProgress, IOutputFile };
+export { config, ITranspilerOptions, IFile, IProgress, IOutputFile, IOutput };
 export declare class Transpiler {
     private readonly options;
     constructor(options?: ITranspilerOptions);

package/build/src/statements/class_implementation.js

@@ -23,7 +23,8 @@ class ClassImplementationTranspiler {
 static INTERNAL_TYPE = 'CLAS';
 static INTERNAL_NAME = '${traversal.buildInternalName(token.getStr(), def)}';
 static IMPLEMENTED_INTERFACES = [${this.findImplementedByClass(traversal, def, scope).map(e => `"` + e.toUpperCase() + `"`).join(",")}];
-static ATTRIBUTES = {${traversal.buildAttributes(def, scope).join(",\n")}};`, node, traversal);
+static ATTRIBUTES = {${traversal.buildAttributes(def, scope).join(",\n")}};
+static METHODS = {${traversal.buildMethods(def, scope).join(",\n")}};`, node, traversal);
     }
     findImplementedInterface(traversal, def, scope) {
         if (def === undefined || scope === undefined) {

package/build/src/structures/interface.js

@@ -20,6 +20,7 @@ class InterfaceTranspiler {
                 ret += `class ${name} {\n`;
                 ret += `static INTERNAL_TYPE = 'INTF';\n`;
                 ret += `static ATTRIBUTES = {${traversal.buildAttributes(def, scope).join(",\n")}};\n`;
+                ret += `static METHODS = {${traversal.buildMethods(def, scope).join(",\n")}};\n`;
             }
             else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndInterface) {
                 ret += "}\n";

package/build/src/traversal.d.ts

@@ -24,6 +24,8 @@ export declare class Traversal {
     private isClassAttribute;
     prefixAndName(t: abaplint.Token, filename?: string): string;
     private isStaticClassAttribute;
+    buildMethods(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined, _scope: abaplint.ISpaghettiScopeNode | undefined): string[];
+    private mapVisibility;
     buildAttributes(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined, scope: abaplint.ISpaghettiScopeNode | undefined, prefix?: string): string[];
     isBuiltinMethod(token: abaplint.Token): boolean;
     findMethodReference(token: abaplint.Token, scope: ISpaghettiScopeNode | undefined): undefined | {

package/build/src/traversal.js

@@ -169,6 +169,32 @@ class Traversal {
         }
         return undefined;
     }
+    buildMethods(def, _scope) {
+        const methods = [];
+        if (def === undefined) {
+            return methods;
+        }
+        for (const m of def.getMethodDefinitions().getAll()) {
+            const parameters = [];
+            for (const p of m.getParameters().getAll()) {
+                const type = new transpile_types_1.TranspileTypes().toType(p.getType());
+                const optional = m.getParameters().getOptional().includes(p.getName()) ? "X" : " ";
+                parameters.push(`"${p.getName().toUpperCase()}": {"type": () => {return ${type};}, "is_optional": "${optional}"}`);
+            }
+            methods.push(`"${m.getName().toUpperCase()}": {"visibility": "${this.mapVisibility(m.getVisibility())}", "parameters": {${parameters.join(", ")}}}`);
+        }
+        return methods;
+    }
+    mapVisibility(vis) {
+        switch (vis) {
+            case abaplint.Visibility.Private:
+                return "I";
+            case abaplint.Visibility.Protected:
+                return "O";
+            default:
+                return "U";
+        }
+    }
     buildAttributes(def, scope, prefix = "") {
         var _a, _b;
         const attr = [];
@@ -177,17 +203,7 @@ class Traversal {
         }
         for (const a of ((_a = def.getAttributes()) === null || _a === void 0 ? void 0 : _a.getAll()) || []) {
             const type = new transpile_types_1.TranspileTypes().toType(a.getType());
-            let runtime = "";
-            switch (a.getVisibility()) {
-                case abaplint.Visibility.Private:
-                    runtime = "I";
-                    break;
-                case abaplint.Visibility.Protected:
-                    runtime = "O";
-                    break;
-                default:
-                    runtime = "U";
-            }
+            const runtime = this.mapVisibility(a.getVisibility());
             const isClass = a.getMeta().includes("static" /* abaplint.IdentifierMeta.Static */) ? "X" : " ";
             attr.push(`"${prefix + a.getName().toUpperCase()}": {"type": () => {return ${type};}, "visibility": "${runtime}", "is_constant": " ", "is_class": "${isClass}"}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",