@bdkinc/knex-ibmi 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -1,21 +1,14 @@
-## 1.0.0 - 15 Feb 2019
-- Bump up to 1.0.0 to follow semver rules
-- Internal enhancements
+## 0.0.5 - July 23rd, 2023
+- add unique and dropUnique methods
 
-## 0.1.5 - 10 Dec 2018
-- Documentation updates
+## 0.0.4 - July 21st, 2023
+- remove unnecessary compiler methods
 
-## 0.1.4 - 18 Nov 2018
-- Support Node v6
+## 0.0.3 - July 19th, 2023
+- add transaction support
 
-## 0.1.3 - 17 Nov 2018
-- Don't show debug logs by default #6
+## 0.0.2 - July 15th, 2023
+- update readme and code examples
 
-## 0.1.2 - 5 Oct 2018
-- Make SQL method case-insensitive (fixes #3)
-
-## 0.1.1 - 4 Oct 2018
-- Fix raw queries not running as expected #3
-
-## 0.1.0 - 29 Sep 2018
-- Initial release
+## 0.0.1 - July 14th, 2023
+- Imported DB2 Dialect and re-wrote

package/dist/index.js

@@ -37,15 +37,11 @@ module.exports = __toCommonJS(src_exports);
 var process = __toESM(require("process"));
 var import_knex = __toESM(require("knex"));
 var odbc = __toESM(require("odbc"));
-var console2 = __toESM(require("console"));
+var console = __toESM(require("console"));
 
 // src/schema/ibmi-compiler.ts
 var import_compiler = __toESM(require("knex/lib/schema/compiler"));
-var console = __toESM(require("console"));
 var IBMiSchemaCompiler = class extends import_compiler.default {
-  constructor(client, builder) {
-    super(client, builder);
-  }
   hasTable(tableName) {
     const formattedTable = this.client.parameter(
       // @ts-ignore
@@ -73,7 +69,6 @@ var IBMiSchemaCompiler = class extends import_compiler.default {
     const sequence = this.builder._sequence;
     for (let i = 0, l = sequence.length; i < l; i++) {
       const query = sequence[i];
-      console.log(query.method, query);
       this[query.method].apply(this, query.args);
     }
     return this.sequence;
@@ -188,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")) {
@@ -242,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;
 
@@ -288,13 +360,13 @@ var DB2Client = class extends import_knex.default.Client {
   async acquireRawConnection() {
     this.printDebug("acquiring raw connection");
     const connectionConfig = this.config.connection;
-    console2.log(this._getConnectionString(connectionConfig));
+    console.log(this._getConnectionString(connectionConfig));
     return await this.driver.pool(this._getConnectionString(connectionConfig));
   }
   // Used to explicitly close a connection, called internally by the pool manager
   // when a connection times out or the pool is shutdown.
   async destroyRawConnection(connection) {
-    console2.log("destroy connection");
+    console.log("destroy connection");
     return await connection.close();
   }
   _getConnectionString(connectionConfig) {
@@ -324,18 +396,54 @@ var DB2Client = class extends import_knex.default.Client {
         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 = { 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") {
+          console.log(this.queryCompiler);
+          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();
+          console.log(selected.columns);
+          obj.response = { rows: selected, rowCount: selected.length };
+        } else {
+          obj.response = { rows: result, rowCount: result.length };
+        }
       } catch (err) {
-        console2.error(err);
+        console.error(err);
         throw new Error(err);
       }
     }
     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);
   }
@@ -357,7 +465,6 @@ var DB2Client = class extends import_knex.default.Client {
     const resp = obj.response;
     const method = obj.sqlMethod;
     const { rows } = resp;
-    console2.log({ method, rows });
     if (obj.output)
       return obj.output.call(runner, resp);
     switch (method) {
@@ -368,9 +475,11 @@ var DB2Client = class extends import_knex.default.Client {
       case "first":
         return rows[0];
       case "insert":
+        return rows;
       case "del":
       case "delete":
       case "update":
+        return rows;
       case "counter":
         return resp.rowCount;
       default:

package/dist/index.mjs

@@ -2,15 +2,11 @@
 import * as process from "process";
 import knex from "knex";
 import * as odbc from "odbc";
-import * as console2 from "console";
+import * as console from "console";
 
 // src/schema/ibmi-compiler.ts
 import SchemaCompiler from "knex/lib/schema/compiler";
-import * as console from "console";
 var IBMiSchemaCompiler = class extends SchemaCompiler {
-  constructor(client, builder) {
-    super(client, builder);
-  }
   hasTable(tableName) {
     const formattedTable = this.client.parameter(
       // @ts-ignore
@@ -38,7 +34,6 @@ var IBMiSchemaCompiler = class extends SchemaCompiler {
     const sequence = this.builder._sequence;
     for (let i = 0, l = sequence.length; i < l; i++) {
       const query = sequence[i];
-      console.log(query.method, query);
       this[query.method].apply(this, query.args);
     }
     return this.sequence;
@@ -153,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")) {
@@ -207,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;
 
@@ -253,13 +325,13 @@ var DB2Client = class extends knex.Client {
   async acquireRawConnection() {
     this.printDebug("acquiring raw connection");
     const connectionConfig = this.config.connection;
-    console2.log(this._getConnectionString(connectionConfig));
+    console.log(this._getConnectionString(connectionConfig));
     return await this.driver.pool(this._getConnectionString(connectionConfig));
   }
   // Used to explicitly close a connection, called internally by the pool manager
   // when a connection times out or the pool is shutdown.
   async destroyRawConnection(connection) {
-    console2.log("destroy connection");
+    console.log("destroy connection");
     return await connection.close();
   }
   _getConnectionString(connectionConfig) {
@@ -289,18 +361,54 @@ var DB2Client = class extends knex.Client {
         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 = { 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") {
+          console.log(this.queryCompiler);
+          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();
+          console.log(selected.columns);
+          obj.response = { rows: selected, rowCount: selected.length };
+        } else {
+          obj.response = { rows: result, rowCount: result.length };
+        }
       } catch (err) {
-        console2.error(err);
+        console.error(err);
         throw new Error(err);
       }
     }
     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);
   }
@@ -322,7 +430,6 @@ var DB2Client = class extends knex.Client {
     const resp = obj.response;
     const method = obj.sqlMethod;
     const { rows } = resp;
-    console2.log({ method, rows });
     if (obj.output)
       return obj.output.call(runner, resp);
     switch (method) {
@@ -333,9 +440,11 @@ var DB2Client = class extends knex.Client {
       case "first":
         return rows[0];
       case "insert":
+        return rows;
       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.5",
+  "version": "0.0.7",
   "description": "Knex dialect for IBMi",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/execution/ibmi-transaction.ts

@@ -1,5 +1,4 @@
 import Transaction from "knex/lib/execution/transaction";
-import * as console from "console";
 
 class IBMiTransaction extends Transaction {
   async begin(conn) {

package/src/index.ts

@@ -114,11 +114,45 @@ class DB2Client extends knex.Client {
         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 = { 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
+          console.log(this.queryCompiler)
+          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();
+          console.log(selected.columns)
+          obj.response = {rows: selected, rowCount: selected.length}
+        } else {
+          obj.response = { rows: result, rowCount: result.length };
+        }
       } catch (err: any) {
         console.error(err);
         throw new Error(err);
@@ -128,6 +162,21 @@ class DB2Client extends knex.Client {
     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);
@@ -154,13 +203,11 @@ class DB2Client extends knex.Client {
   }
 
   processResponse(obj: any, runner: any) {
-    // TODO: verify correctness
     if (obj === null) return null;
 
     const resp = obj.response;
     const method = obj.sqlMethod;
     const { rows } = resp;
-    console.log({ method, rows });
 
     if (obj.output) return obj.output.call(runner, resp);
 
@@ -172,9 +219,11 @@ class DB2Client extends knex.Client {
       case "first":
         return rows[0];
       case "insert":
+        return rows;
       case "del":
       case "delete":
       case "update":
+        return rows;
       case "counter":
         return resp.rowCount;
       default:

package/src/query/ibmi-querycompiler.ts

@@ -3,8 +3,79 @@ 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")) {
@@ -55,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;

package/src/schema/ibmi-compiler.ts

@@ -2,10 +2,6 @@ import SchemaCompiler from "knex/lib/schema/compiler";
 import * as console from "console";
 
 class IBMiSchemaCompiler extends SchemaCompiler {
-  constructor(client, builder) {
-    super(client, builder);
-  }
-
   hasTable(tableName) {
     // @ts-ignore
     const formattedTable = this.client.parameter(
@@ -42,7 +38,6 @@ class IBMiSchemaCompiler extends SchemaCompiler {
     const sequence = this.builder._sequence;
     for (let i = 0, l = sequence.length; i < l; i++) {
       const query = sequence[i];
-      console.log(query.method, query);
       this[query.method].apply(this, query.args);
     }
     // @ts-ignore