@bdkinc/knex-ibmi 0.0.6 → 0.0.8

package/README.md

@@ -17,8 +17,8 @@ This is an external dialect for [knex](https://github.com/tgriesser/knex). This
 Currently, this dialect has limited functionality compared to the Knex built-in dialects. Below are some of the limitations:
 
 - No streaming support
+- Updates return the value of the first column in that row. Make sure your identifier is the first column in the table. The returning option does not work on updates. 
 - Possibly other missing functionality
-- Uses a pool for all connections
 - Journaling must be handled separately. After a migration is ran journaling can be configured on the newly created tables. I recommend using the schema utility in the i access client solutions software. 
 
 ## Installing

package/dist/index.js

@@ -183,7 +183,57 @@ var import_querycompiler = __toESM(require("knex/lib/query/querycompiler"));
 var import_isObject2 = __toESM(require("lodash/isObject"));
 var import_wrappingFormatter = require("knex/lib/formatter/wrappingFormatter");
 var import_date_fns = require("date-fns");
+var import_isEmpty = __toESM(require("lodash/isEmpty"));
 var IBMiQueryCompiler = class extends import_querycompiler.default {
+  insert() {
+    const insertValues = this.single.insert || [];
+    let sql = `SELECT ${// @ts-ignore
+    this.single.returning ? (
+      // @ts-ignore
+      this.formatter.columnize(this.single.returning)
+    ) : "IDENTITY_VAL_LOCAL()"} FROM FINAL TABLE(`;
+    sql += this.with() + `insert into ${this.tableName} `;
+    const { returning } = this.single;
+    const returningSql = returning ? (
+      // @ts-ignore
+      this._returning("insert", returning) + " "
+    ) : "";
+    if (Array.isArray(insertValues)) {
+      if (insertValues.length === 0) {
+        return "";
+      }
+    } else if (typeof insertValues === "object" && (0, import_isEmpty.default)(insertValues)) {
+      return {
+        // @ts-ignore
+        sql: sql + returningSql + this._emptyInsertValue,
+        returning
+      };
+    }
+    sql += this._buildInsertData(insertValues, returningSql);
+    sql += ")";
+    return {
+      sql,
+      returning
+    };
+  }
+  _buildInsertData(insertValues, returningSql) {
+    let sql = "";
+    const insertData = this._prepInsert(insertValues);
+    if (typeof insertData === "string") {
+      sql += insertData;
+    } else {
+      if (insertData.columns.length) {
+        sql += `(${this.formatter.columnize(insertData.columns)}`;
+        sql += `) ${returningSql}values (` + // @ts-ignore
+        this._buildInsertValues(insertData) + ")";
+      } else if (insertValues.length === 1 && insertValues[0]) {
+        sql += returningSql + this._emptyInsertValue;
+      } else {
+        return "";
+      }
+    }
+    return sql;
+  }
   _prepInsert(data) {
     if ((0, import_isObject2.default)(data)) {
       if (data.hasOwnProperty("migration_time")) {
@@ -237,6 +287,33 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
       values
     };
   }
+  _returning(method, value, withTrigger) {
+    switch (method) {
+      case "update":
+      case "insert":
+        return value ? (
+          // @ts-ignore
+          `${withTrigger ? " into #out" : ""}`
+        ) : "";
+      case "del":
+        return value ? (
+          // @ts-ignore
+          `${withTrigger ? " into #out" : ""}`
+        ) : "";
+      case "rowcount":
+        return value ? ";select @@rowcount" : "";
+    }
+  }
+  columnizeWithPrefix(prefix, target) {
+    const columns = typeof target === "string" ? [target] : target;
+    let str = "", i = -1;
+    while (++i < columns.length) {
+      if (i > 0)
+        str += ", ";
+      str += prefix + this.wrap(columns[i]);
+    }
+    return str;
+  }
 };
 var ibmi_querycompiler_default = IBMiQueryCompiler;
 
@@ -315,22 +392,62 @@ var DB2Client = class extends import_knex.default.Client {
         obj.response = { rows, rowCount: rows.length };
       }
     } else {
+      const connection = await pool.connect();
+      await connection.beginTransaction();
       try {
-        const connection = await pool.connect();
         const statement = await connection.createStatement();
         await statement.prepare(obj.sql);
+        console.log({ obj });
         if (obj.bindings) {
           await statement.bind(obj.bindings);
         }
         const result = await statement.execute();
-        obj.response = { rows: [result.count], rowCount: result.count };
+        if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
+          obj.response = {
+            rows: result.map(
+              (row) => result.columns.length > 0 ? row[result.columns[0].name] : row
+            ),
+            rowCount: result.length
+          };
+        } else if (method === "update") {
+          let returningSelect = obj.sql.replace("update", "select * from ");
+          returningSelect = returningSelect.replace("where", "and");
+          returningSelect = returningSelect.replace("set", "where");
+          returningSelect = returningSelect.replace(this.tableName, "where");
+          const selectStatement = await connection.createStatement();
+          await selectStatement.prepare(returningSelect);
+          if (obj.bindings) {
+            await selectStatement.bind(obj.bindings);
+          }
+          const selected = await selectStatement.execute();
+          obj.response = { rows: selected.map(
+            (row) => selected.columns.length > 0 ? row[selected.columns[0].name] : row
+          ), rowCount: selected.length };
+        } else {
+          obj.response = { rows: result, rowCount: result.length };
+        }
       } catch (err) {
         console.error(err);
+        await connection.rollback();
         throw new Error(err);
+      } finally {
+        await connection.commit();
       }
     }
     return obj;
   }
+  _selectAfterUpdate() {
+    const returnSelect = `; SELECT ${this.single.returning ? (
+      // @ts-ignore
+      this.formatter.columnize(this.single.returning)
+    ) : "*"} from ${this.tableName} `;
+    let whereStatement = [this.where()];
+    console.log({ whereStatement });
+    for (const [key, value] of Object.entries(this.single.update)) {
+      whereStatement.push(`WHERE ${key} = ${value}`);
+    }
+    return returnSelect + whereStatement.join(" and ");
+  }
   transaction(container, config, outerTx) {
     return new ibmi_transaction_default(this, ...arguments);
   }
@@ -366,6 +483,7 @@ var DB2Client = class extends import_knex.default.Client {
       case "del":
       case "delete":
       case "update":
+        return rows;
       case "counter":
         return resp.rowCount;
       default:

package/dist/index.mjs

@@ -148,7 +148,57 @@ import QueryCompiler from "knex/lib/query/querycompiler";
 import isObject2 from "lodash/isObject";
 import { rawOrFn as rawOrFn_ } from "knex/lib/formatter/wrappingFormatter";
 import { format } from "date-fns";
+import isEmpty from "lodash/isEmpty";
 var IBMiQueryCompiler = class extends QueryCompiler {
+  insert() {
+    const insertValues = this.single.insert || [];
+    let sql = `SELECT ${// @ts-ignore
+    this.single.returning ? (
+      // @ts-ignore
+      this.formatter.columnize(this.single.returning)
+    ) : "IDENTITY_VAL_LOCAL()"} FROM FINAL TABLE(`;
+    sql += this.with() + `insert into ${this.tableName} `;
+    const { returning } = this.single;
+    const returningSql = returning ? (
+      // @ts-ignore
+      this._returning("insert", returning) + " "
+    ) : "";
+    if (Array.isArray(insertValues)) {
+      if (insertValues.length === 0) {
+        return "";
+      }
+    } else if (typeof insertValues === "object" && isEmpty(insertValues)) {
+      return {
+        // @ts-ignore
+        sql: sql + returningSql + this._emptyInsertValue,
+        returning
+      };
+    }
+    sql += this._buildInsertData(insertValues, returningSql);
+    sql += ")";
+    return {
+      sql,
+      returning
+    };
+  }
+  _buildInsertData(insertValues, returningSql) {
+    let sql = "";
+    const insertData = this._prepInsert(insertValues);
+    if (typeof insertData === "string") {
+      sql += insertData;
+    } else {
+      if (insertData.columns.length) {
+        sql += `(${this.formatter.columnize(insertData.columns)}`;
+        sql += `) ${returningSql}values (` + // @ts-ignore
+        this._buildInsertValues(insertData) + ")";
+      } else if (insertValues.length === 1 && insertValues[0]) {
+        sql += returningSql + this._emptyInsertValue;
+      } else {
+        return "";
+      }
+    }
+    return sql;
+  }
   _prepInsert(data) {
     if (isObject2(data)) {
       if (data.hasOwnProperty("migration_time")) {
@@ -202,6 +252,33 @@ var IBMiQueryCompiler = class extends QueryCompiler {
       values
     };
   }
+  _returning(method, value, withTrigger) {
+    switch (method) {
+      case "update":
+      case "insert":
+        return value ? (
+          // @ts-ignore
+          `${withTrigger ? " into #out" : ""}`
+        ) : "";
+      case "del":
+        return value ? (
+          // @ts-ignore
+          `${withTrigger ? " into #out" : ""}`
+        ) : "";
+      case "rowcount":
+        return value ? ";select @@rowcount" : "";
+    }
+  }
+  columnizeWithPrefix(prefix, target) {
+    const columns = typeof target === "string" ? [target] : target;
+    let str = "", i = -1;
+    while (++i < columns.length) {
+      if (i > 0)
+        str += ", ";
+      str += prefix + this.wrap(columns[i]);
+    }
+    return str;
+  }
 };
 var ibmi_querycompiler_default = IBMiQueryCompiler;
 
@@ -280,22 +357,62 @@ var DB2Client = class extends knex.Client {
         obj.response = { rows, rowCount: rows.length };
       }
     } else {
+      const connection = await pool.connect();
+      await connection.beginTransaction();
       try {
-        const connection = await pool.connect();
         const statement = await connection.createStatement();
         await statement.prepare(obj.sql);
+        console.log({ obj });
         if (obj.bindings) {
           await statement.bind(obj.bindings);
         }
         const result = await statement.execute();
-        obj.response = { rows: [result.count], rowCount: result.count };
+        if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
+          obj.response = {
+            rows: result.map(
+              (row) => result.columns.length > 0 ? row[result.columns[0].name] : row
+            ),
+            rowCount: result.length
+          };
+        } else if (method === "update") {
+          let returningSelect = obj.sql.replace("update", "select * from ");
+          returningSelect = returningSelect.replace("where", "and");
+          returningSelect = returningSelect.replace("set", "where");
+          returningSelect = returningSelect.replace(this.tableName, "where");
+          const selectStatement = await connection.createStatement();
+          await selectStatement.prepare(returningSelect);
+          if (obj.bindings) {
+            await selectStatement.bind(obj.bindings);
+          }
+          const selected = await selectStatement.execute();
+          obj.response = { rows: selected.map(
+            (row) => selected.columns.length > 0 ? row[selected.columns[0].name] : row
+          ), rowCount: selected.length };
+        } else {
+          obj.response = { rows: result, rowCount: result.length };
+        }
       } catch (err) {
         console.error(err);
+        await connection.rollback();
         throw new Error(err);
+      } finally {
+        await connection.commit();
       }
     }
     return obj;
   }
+  _selectAfterUpdate() {
+    const returnSelect = `; SELECT ${this.single.returning ? (
+      // @ts-ignore
+      this.formatter.columnize(this.single.returning)
+    ) : "*"} from ${this.tableName} `;
+    let whereStatement = [this.where()];
+    console.log({ whereStatement });
+    for (const [key, value] of Object.entries(this.single.update)) {
+      whereStatement.push(`WHERE ${key} = ${value}`);
+    }
+    return returnSelect + whereStatement.join(" and ");
+  }
   transaction(container, config, outerTx) {
     return new ibmi_transaction_default(this, ...arguments);
   }
@@ -331,6 +448,7 @@ var DB2Client = class extends knex.Client {
       case "del":
       case "delete":
       case "update":
+        return rows;
       case "counter":
         return resp.rowCount;
       default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bdkinc/knex-ibmi",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Knex dialect for IBMi",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/index.ts

@@ -110,24 +110,78 @@ class DB2Client extends knex.Client {
         obj.response = { rows, rowCount: rows.length };
       }
     } else {
+      const connection = await pool.connect();
+      await connection.beginTransaction();
       try {
-        const connection = await pool.connect();
         const statement = await connection.createStatement();
         await statement.prepare(obj.sql);
+        console.log({ obj });
         if (obj.bindings) {
           await statement.bind(obj.bindings);
         }
         const result = await statement.execute();
-        obj.response = { rows: [result.count], rowCount: result.count };
+        // this is hacky we check the SQL for the ID column
+        // most dialects return the ID of the inserted
+        // we check for the IDENTITY scalar function
+        // if that function is present, then we just return the value of the
+        // IDENTITY column
+        if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
+          obj.response = {
+            rows: result.map((row) =>
+              result.columns.length > 0 ? row[result.columns[0].name] : row,
+            ),
+            rowCount: result.length,
+          };
+        } else if (method === "update") {
+          // if is in update we need to run a separate select query
+          // this also feels hacky and should be cleaned up
+          // it would be a lot easier if the table-reference function
+          // worked the same for updates as it does inserts
+          // on DB2 LUW it does work so if they ever add it we need to fix
+          let returningSelect = obj.sql.replace("update", "select * from ");
+          returningSelect = returningSelect.replace("where", "and");
+          returningSelect = returningSelect.replace("set", "where");
+          returningSelect = returningSelect.replace(this.tableName, "where");
+          const selectStatement = await connection.createStatement();
+          await selectStatement.prepare(returningSelect);
+          if (obj.bindings) {
+            await selectStatement.bind(obj.bindings);
+          }
+          const selected = await selectStatement.execute();
+          obj.response = {rows: selected.map((row) =>
+            selected.columns.length > 0 ? row[selected.columns[0].name] : row,
+          ), rowCount: selected.length}
+        } else {
+          obj.response = { rows: result, rowCount: result.length };
+        }
       } catch (err: any) {
         console.error(err);
+        await connection.rollback()
         throw new Error(err);
+      } finally {
+        await connection.commit()
       }
+
     }
 
     return obj;
   }
 
+  _selectAfterUpdate() {
+    const returnSelect = `; SELECT ${
+      this.single.returning
+        ? // @ts-ignore
+          this.formatter.columnize(this.single.returning)
+        : "*"
+    } from ${this.tableName} `;
+    let whereStatement = [this.where()];
+    console.log({ whereStatement });
+    for (const [key, value] of Object.entries(this.single.update)) {
+      whereStatement.push(`WHERE ${key} = ${value}`);
+    }
+    return returnSelect + whereStatement.join(" and ");
+  }
+
   transaction(container: any, config: any, outerTx: any): Knex.Transaction {
     // @ts-ignore
     return new Transaction(this, ...arguments);
@@ -174,6 +228,7 @@ class DB2Client extends knex.Client {
       case "del":
       case "delete":
       case "update":
+        return rows;
       case "counter":
         return resp.rowCount;
       default:

package/src/query/ibmi-querycompiler.ts

@@ -2,8 +2,80 @@ import QueryCompiler from "knex/lib/query/querycompiler";
 import isObject from "lodash/isObject";
 import { rawOrFn as rawOrFn_ } from "knex/lib/formatter/wrappingFormatter";
 import { format } from "date-fns";
+import * as console from "console";
+import isEmpty from "lodash/isEmpty";
 
 class IBMiQueryCompiler extends QueryCompiler {
+  insert() {
+    // @ts-ignore
+    const insertValues = this.single.insert || [];
+    // we need to return a value
+    // we need to wrap the insert statement in a select statement
+    // we use the "IDENTITY_VAL_LOCAL()" function to return the IDENTITY
+    // unless specified in a return
+    // @ts-ignore
+    let sql = `SELECT ${
+      // @ts-ignore
+      this.single.returning
+        ? // @ts-ignore
+          this.formatter.columnize(this.single.returning)
+        : "IDENTITY_VAL_LOCAL()"
+    } FROM FINAL TABLE(`;
+    // @ts-ignore
+    sql += this.with() + `insert into ${this.tableName} `;
+    // @ts-ignore
+    const { returning } = this.single;
+    const returningSql = returning
+      ? // @ts-ignore
+        this._returning("insert", returning) + " "
+      : "";
+
+    if (Array.isArray(insertValues)) {
+      if (insertValues.length === 0) {
+        return "";
+      }
+    } else if (typeof insertValues === "object" && isEmpty(insertValues)) {
+      return {
+        // @ts-ignore
+        sql: sql + returningSql + this._emptyInsertValue,
+        returning,
+      };
+    }
+
+    // @ts-ignore
+    sql += this._buildInsertData(insertValues, returningSql);
+    sql += ")";
+
+    return {
+      sql,
+      returning,
+    };
+  }
+
+  _buildInsertData(insertValues, returningSql) {
+    let sql = "";
+    const insertData = this._prepInsert(insertValues);
+    if (typeof insertData === "string") {
+      sql += insertData;
+    } else {
+      if (insertData.columns.length) {
+        // @ts-ignore
+        sql += `(${this.formatter.columnize(insertData.columns)}`;
+        sql +=
+          `) ${returningSql}values (` +
+          // @ts-ignore
+          this._buildInsertValues(insertData) +
+          ")";
+      } else if (insertValues.length === 1 && insertValues[0]) {
+        // @ts-ignore
+        sql += returningSql + this._emptyInsertValue;
+      } else {
+        return "";
+      }
+    }
+    return sql;
+  }
+
   _prepInsert(data) {
     if (isObject(data)) {
       if (data.hasOwnProperty("migration_time")) {
@@ -54,6 +126,36 @@ class IBMiQueryCompiler extends QueryCompiler {
       values,
     };
   }
+
+  _returning(method, value, withTrigger) {
+    // currently a placeholder in case I need to update return values
+    switch (method) {
+      case "update":
+      case "insert":
+        return value
+          ? // @ts-ignore
+            `${withTrigger ? " into #out" : ""}`
+          : "";
+      case "del":
+        return value
+          ? // @ts-ignore
+            `${withTrigger ? " into #out" : ""}`
+          : "";
+      case "rowcount":
+        return value ? ";select @@rowcount" : "";
+    }
+  }
+
+  columnizeWithPrefix(prefix, target) {
+    const columns = typeof target === "string" ? [target] : target;
+    let str = "",
+      i = -1;
+    while (++i < columns.length) {
+      if (i > 0) str += ", ";
+      str += prefix + this.wrap(columns[i]);
+    }
+    return str;
+  }
 }
 
 export default IBMiQueryCompiler;