inline SQLs, consume Kronos ABAP API

DirigibleDatabaseClient.ts

@@ -0,0 +1,237 @@
+import { DB } from "sample-abap/node_modules/@abaplint/runtime/build/src";
+
+import { database, sql, update, query } from "sdk/db";
+
+import { logging } from "sdk/log";
+
+const DatabaseResultSetHelper = Java.type("org.eclipse.dirigible.components.data.management.helpers.DatabaseResultSetHelper");
+
+export class DirigibleDatabaseClient implements DB.DatabaseClient {
+
+  public readonly name = "dirigible-default-database";
+  private static readonly DEFAULT_DATA_SOURCE_NAME = "DefaultDB";
+
+  private readonly logger;
+  private connection: any;
+
+
+  public constructor() {
+    this.logger = logging.getLogger("org.eclipse.dirigible.DirigibleDatabaseClient");
+    this.logger.info("Initializing...")
+  }
+
+  public async connect() {
+    this.logger.debug("Creating connection...");
+    this.connection = database.getConnection(DirigibleDatabaseClient.DEFAULT_DATA_SOURCE_NAME);
+    this.connection.setAutoCommit(false);
+    // @ts-ignore
+    if (abap?.context?.databaseConnections && abap.context.databaseConnections["DEFAULT"] === this) {
+      // @ts-ignore
+      abap.builtin.sy.get().dbsys?.set(this.name);
+    }
+    this.logger.debug("Created connection");
+  }
+
+  public async disconnect() {
+    if (this.connection) {
+      this.logger.debug("Closing connection...");
+      this.connection.close();
+      this.logger.debug("Connection was closed");
+    }
+  }
+
+  public async execute(sql: string | string[]): Promise<void> {
+
+    if (typeof sql !== "string") {
+      for (const s of sql) {
+        await this.execute(s);
+      }
+      return;
+    }
+
+    if (sql === "") {
+      return;
+    }
+    if (!this.connection) {
+      const errorMessage = `SQL [${sql}] cannot be executed because the connection is not inialized`;
+      this.logger.error(errorMessage);
+      throw new Error(errorMessage);
+    }
+
+    this.logger.debug("Executing sql [{}]", sql);
+
+    try {
+      const statement = this.connection.createStatement();
+      const hasResultSet = statement.execute(sql);
+      if (hasResultSet) {
+        this.logger.debug("Executed sql [{}] has result set.", sql);
+      }
+    } catch (error) {
+      const errorMessage = `Failed to execute [${sql}]. Error: [${error}]`;
+      this.logger.error(errorMessage, error);
+      throw new Error(errorMessage);
+    }
+  }
+
+  public async beginTransaction() {
+    return; // todo
+  }
+
+  public async commit() {
+    if (this.connection) {
+      this.logger.debug("Committing current connection...");
+      this.connection.commit();
+      this.logger.debug("Current connection was committed");
+    } else {
+      this.logger.warn("Connection not initialized and cannot be committed");
+    }
+    return; // todo
+  }
+
+  public async rollback() {
+    if (this.connection) {
+      this.logger.debug("Rolling back current connection...");
+      this.connection.rollback();
+      this.logger.debug("Current connection was rollbacked");
+    } else {
+      this.logger.warn("Connection not initialized and cannot be rollbacked");
+    }
+  }
+
+  public async delete(options: DB.DeleteDatabaseOptions) {
+    let sqlDelete = sql.getDialect()//
+      .delete()//
+      .from(options.table)//
+      .build();
+
+    sqlDelete = sqlDelete + ` WHERE ${options.where}`;
+    return this.executeUpdate(sqlDelete);
+  }
+
+  public async update(options: DB.UpdateDatabaseOptions) {
+    let sqlUpdate = sql.getDialect()//
+      .update()//
+      .table(options.table)//
+      .build();
+
+    sqlUpdate = sqlUpdate + ` SET ${options.set.join(", ")} WHERE ${options.where}`;
+    return this.executeUpdate(sqlUpdate);
+  }
+
+  public async insert(options: DB.InsertDatabaseOptions) {
+    const insertBuilder = sql.getDialect()//
+      .insert()//
+      .table(options.table);
+
+    options.columns.forEach((columnName: string, index: number) => {
+      const columnValue = options.values[index];
+      insertBuilder.column(columnName).value(columnValue);
+    });
+
+    const sqlInsert = insertBuilder.build();
+    return this.executeUpdate(sqlInsert);
+  }
+
+  private executeUpdate(sql: string) {
+    this.logger.debug("Executing [{}]...", sql);
+
+    try {
+      const affectedRows = update.execute(sql);
+      this.logger.debug("Affected [{}] rows by executing [{}]", affectedRows, sql);
+
+      return this.createCRUDResult(affectedRows, 0)
+    } catch (error) {
+      this.logger.error(`Failed to execute [{}]. Error: [{}]`, sql, error);
+      return this.createErrorCRUDResult();
+    }
+  }
+
+  private createErrorCRUDResult() {
+    return this.createCRUDResult(0, 4);
+  }
+
+  private createCRUDResult(affectedRows: number, error: number) {
+    return {
+      dbcnt: affectedRows,
+      subrc: error
+    }
+  }
+
+  public async select(options: DB.SelectDatabaseOptions) {
+    let selectSQL = this.convertInputSelect(options.select, options.primaryKey);
+    this.logger.debug("Executing select [{}]...", selectSQL);
+
+    try {
+      const resultSet = query.execute(selectSQL);
+      const selectDatabaseResult = { rows: resultSet };
+      this.logger.debug("Result of select [{}]: [{}]", selectSQL, JSON.stringify(selectDatabaseResult));
+
+      return selectDatabaseResult;
+    } catch (error) {
+      this.logger.error(`Failed to execute [${selectSQL}]. Error: [${error}]`, error);
+      // @ts-ignore
+      if (abap.Classes["CX_SY_DYNAMIC_OSQL_SEMANTICS"] !== undefined) {
+        // @ts-ignore
+        throw await new abap.Classes["CX_SY_DYNAMIC_OSQL_SEMANTICS"]().constructor_({ sqlmsg: error.message || "" });
+      }
+      throw error;
+    }
+  }
+
+  private convertInputSelect(select: string, primaryKeys: string[] | undefined) {
+    let convertedSelect = select.replace(/ UP TO (\d+) ROWS(.*)/i, "$2 LIMIT $1");
+    if (primaryKeys) {
+      convertedSelect = convertedSelect.replace(/ ORDER BY PRIMARY KEY/i, " ORDER BY " + primaryKeys.join(", "));
+    } else {
+      convertedSelect = convertedSelect.replace(/ ORDER BY PRIMARY KEY/i, "");
+    }
+    convertedSelect = convertedSelect.replace(/ ASCENDING/ig, " ASC");
+    convertedSelect = convertedSelect.replace(/ DESCENDING/ig, " DESC");
+    convertedSelect = convertedSelect.replace(/~/g, ".");
+
+    return convertedSelect;
+  }
+
+  public async openCursor(options: DB.SelectDatabaseOptions): Promise<DB.DatabaseCursorCallbacks> {
+    if (!this.connection) {
+      const errorMessage = "Connection is not initialized. Consider calling connect method first.";
+      this.logger.error(errorMessage);
+      throw new Error(errorMessage);
+    }
+
+    const statement = this.connection.createStatement();
+
+    const selectSQL = options.select;
+    this.logger.debug("Executing [{}]...", selectSQL);
+
+    const resultSet = statement.executeQuery(selectSQL);
+
+    return {
+      fetchNextCursor: (packageSize: number) => this.fetchNextCursor.bind(this)(packageSize, resultSet),
+      closeCursor: () => this.closeCursor.bind(this)(resultSet),
+    };
+  }
+
+  private async fetchNextCursor(packageSize: number, resultSet: any): Promise<DB.SelectDatabaseResult> {
+    this.logger.debug("Fetching next cursor...");
+    const stringify = false;
+    const resultSetJson = DatabaseResultSetHelper.toJson(resultSet, packageSize, stringify);
+
+    const selectDatabaseResult = {
+      rows: JSON.parse(resultSetJson)
+    };
+    this.logger.debug("Retrieved data [{}]", JSON.stringify(selectDatabaseResult));
+
+    return selectDatabaseResult;
+  }
+
+  private async closeCursor(resultSet: any): Promise<void> {
+    if (resultSet && !resultSet.isClosed()) {
+      this.logger.debug("Closing result set...")
+      resultSet.close();
+      this.logger.debug("Result set was closed")
+    } else {
+      this.logger.warn("Result set is not defined or it is already closed.")
+    }
+  }
+}

build-mac.sh

@@ -4,4 +4,4 @@ rm -rf dist
 npm run transpile
 npm run lint
 find . -name '*.mjs' -print0 | xargs -0 sed -i '' 's/%23/#/g'
-esbuild run.mjs --bundle --outdir=dist --format=esm --target=es2022 --external:tls --external:net --external:util --external:util/types --external:crypto --external:zlib --external:http --external:https --external:fs --external:path --external:url --external:sdk/http --inject:./polyfills/buffer.js --inject:./polyfills/process.js --out-extension:.js=.mjs
+esbuild run.mjs --bundle --outdir=dist --format=esm --target=es2022 --external:tls --external:net --external:util --external:util/types --external:crypto --external:zlib --external:http --external:https --external:fs --external:path --external:url --external:sdk --inject:./polyfills/buffer.js --inject:./polyfills/process.js --out-extension:.js=.mjs

db/employee.table

@@ -0,0 +1,28 @@
+{
+    "name": "employees",
+    "type": "TABLE",
+    "columns": [
+        {
+            "name": "id",
+            "type": "INTEGER",
+            "length": "0",
+            "nullable": "false",
+            "primaryKey": "true",
+            "defaultValue": ""
+        },
+        {
+            "name": "firstName",
+            "type": "VARCHAR",
+            "length": "50",
+            "nullable": "false",
+            "primaryKey": "false"
+        },
+        {
+            "name": "lastName",
+            "type": "VARCHAR",
+            "length": "50",
+            "nullable": "false",
+            "primaryKey": "false"
+        }
+    ]
+}

run.mjs

@@ -1,6 +1,15 @@
 import { initializeABAP } from './output/init.mjs';
 import { zcl_hello_world } from './output/zcl_hello_world.clas.mjs';
 
+import { DirigibleDatabaseClient } from "./DirigibleDatabaseClient";
+
+function initDefaultDataSource() {
+    console.log("!!! Init default data source for ABAP...");
+    abap.context.databaseConnections["DEFAULT"] = new DirigibleDatabaseClient();
+    console.log("!!! Default data source for ABAP was initialized");
+}
 await initializeABAP();
+initDefaultDataSource();
 
 await zcl_hello_world.run();
+

src/zcl_dirigible_employee_dao.clas.abap

@@ -0,0 +1,43 @@
+CLASS zcl_dirigible_employee_dao DEFINITION PUBLIC.
+
+  PUBLIC SECTION.
+
+    TYPES:
+      BEGIN OF ty_employee,
+        id         TYPE n LENGTH 10,
+        firstName  TYPE string,
+        lastName   TYPE string,
+      END OF ty_employee,
+      ty_employees TYPE TABLE OF ty_employee WITH EMPTY KEY.
+
+    CLASS-METHODS:
+      select_all
+        RETURNING VALUE(rv_result) TYPE string.
+
+ENDCLASS.
+
+CLASS zcl_dirigible_employee_dao IMPLEMENTATION.
+
+  METHOD select_all.
+    DATA: lt_employees TYPE ty_employees,
+          ls_employee  TYPE ty_employee,
+          lv_result    TYPE string.
+
+    SELECT id, firstName, lastName 
+      FROM employees 
+      INTO TABLE lt_employees.
+
+    LOOP AT lt_employees INTO ls_employee.
+      CONCATENATE lv_result
+                  'ID:' ls_employee-id
+                  ' First Name:' ls_employee-firstName
+                  ' Last Name:' ls_employee-lastName
+                  cl_abap_char_utilities=>cr_lf
+                  INTO lv_result
+                  SEPARATED BY space.
+    ENDLOOP.
+
+    rv_result = lv_result.
+  ENDMETHOD.
+
+ENDCLASS.

src/zcl_hello_world.clas.abap

@@ -1,12 +1,38 @@
 CLASS zcl_hello_world DEFINITION PUBLIC FINAL CREATE PUBLIC.
+
   PUBLIC SECTION.
     CLASS-METHODS run.
+
+  PRIVATE SECTION.
+    DATA: lo_employee_dao TYPE REF TO zcl_dirigible_employee_dao.
+
 ENDCLASS.
 
 CLASS zcl_hello_world IMPLEMENTATION.
+
   METHOD run.
+    DATA: lv_result TYPE string.
+
+    CREATE OBJECT lo_employee_dao.
+
     zcl_dirigible_response=>println(
       EXPORTING
-        message_in     = 'hello world' ).
+        message_in = 'Hello world!' ).
+
+    zcl_dirigible_response=>println(
+      EXPORTING
+        message_in = 'Selecting all employees...' ).
+
+    lv_result = lo_employee_dao->select_all( ).
+
+    zcl_dirigible_response=>println(
+      EXPORTING
+        message_in = 'Employees selected.' ).
+
+    zcl_dirigible_response=>println(
+      EXPORTING
+        message_in = 'Employee Data:'
+        data_in    = lv_result ).
   ENDMETHOD.
-ENDCLASS.
+
+ENDCLASS.