@bdkinc/knex-ibmi 0.3.20 → 0.3.22

package/README.md

@@ -248,3 +248,16 @@ If that still doesn't work, then unixodbc is probably looking for the config fil
 A common case is that the configs are in `/etc` but your system expects them to be somewhere else.
 In such a case, override the path unixodbc looks in via the `ODBCSYSINI` and `ODBCINI` environment variables.
 E.g., `ODBCINI=/etc ODBCSYSINI=/etc`.
+
+## Bundling with Vite
+If you are bundling your application with Vite, then you will need to add this to your config.
+
+```javascript
+// vite.config.js
+
+export default {
+  optimizeDeps: {
+    exclude: ["@mapbox"],
+  }
+}
+```

package/dist/index.d.ts

@@ -48,6 +48,26 @@ declare class IBMiQueryCompiler extends QueryCompiler {
     columnizeWithPrefix(prefix: string, target: any): string;
 }
 
+interface QueryObject {
+    response?: {
+        rows: any[];
+        rowCount: number;
+    };
+    sqlMethod: SqlMethod;
+    output?: (runner: any, response: any) => any;
+    pluck?: (row: any) => any;
+    select?: boolean;
+}
+declare enum SqlMethod {
+    SELECT = "select",
+    PLUCK = "pluck",
+    FIRST = "first",
+    INSERT = "insert",
+    DELETE = "del",
+    DELETE_ALT = "delete",
+    UPDATE = "update",
+    COUNTER = "counter"
+}
 declare class DB2Client extends knex.Client {
     constructor(config: Knex.Config<DB2Config>);
     _driver(): typeof odbc;
@@ -58,19 +78,28 @@ declare class DB2Client extends knex.Client {
     acquireRawConnection(): Promise<any>;
     destroyRawConnection(connection: any): Promise<any>;
     _getConnectionString(connectionConfig: DB2ConnectionConfig): string;
-    _query(connection: any, obj: any): Promise<any>;
+    _query(connection: Connection, obj: any): Promise<any>;
+    private normalizeQueryObject;
+    private determineQueryMethod;
+    private isSelectMethod;
+    private executeSelectQuery;
+    private executeStatementQuery;
+    private formatStatementResponse;
     _stream(connection: Connection, obj: {
         sql: string;
         bindings: any[];
     }, stream: any, options: {
         fetchSize?: number;
     }): Promise<unknown>;
+    private _createCursorStream;
     transaction(container: any, config: any, outerTx: any): Knex.Transaction;
     schemaCompiler(tableBuilder: any): IBMiSchemaCompiler;
     tableCompiler(tableBuilder: any): IBMiTableCompiler;
     columnCompiler(tableCompiler: any, columnCompiler: any): IBMiColumnCompiler;
     queryCompiler(builder: Knex.QueryBuilder, bindings?: any[]): IBMiQueryCompiler;
-    processResponse(obj: any, runner: any): any;
+    processResponse(obj: QueryObject | null, runner: any): any;
+    private validateResponse;
+    private processSqlMethod;
 }
 interface DB2PoolConfig {
     min?: number;
@@ -91,8 +120,20 @@ interface DB2ConnectionParams {
     DECFLOATERROROPTION?: 0 | 1;
     DECFLOATROUNDMODE?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
     MAPDECIMALFLOATDESCRIBE?: 1 | 3;
+    TFT?: 0 | 1 | 2 | 3 | 4;
+    TSP?: 0 | 1 | 2 | 3;
+    TSFT?: 0 | 1;
+    XMLCURIMPPARSE?: 0 | 1;
+    XMLDECLARATION?: 1 | 2 | 3 | 4;
     ALLOWPROCCALLS?: 0 | 1;
     XDYNAMIC?: 0 | 1;
+    DFTPKGLIB?: string;
+    PKG?: 0 | 1 | 2;
+    BLOCKFETCH?: 0 | 1;
+    COMPRESSION?: 0 | 1;
+    CONCURRENCY?: 0 | 1;
+    CURSORSENSITIVITY?: 0 | 1 | 2;
+    EXTCOLINFO?: "SQL_DESC_AUTO_UNIQUE_VALUE" | "SQL_DESC_BASE_COLUMN_NAME" | "SQL_DESC_BASE_TABLE_NAME and SQL_DESC_TABLE_NAME" | "SQL_DESC_LABEL" | "SQL_DESC_SCHEMA_NAME" | "SQL_DESC_SEARCHABLE" | "SQL_DESC_UNNAMED" | "SQL_DESC_UPDATABLE";
 }
 interface DB2ConnectionConfig {
     database: string;

package/dist/index.js

@@ -205,17 +205,13 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
   _buildInsertData(insertValues, returningSql) {
     let sql = "";
     const insertData = this._prepInsert(insertValues);
-    if (typeof insertData === "string") {
-      sql += insertData;
+    if (insertData.columns.length) {
+      sql += `(${this.formatter.columnize(insertData.columns)}`;
+      sql += `) ${returningSql}values (` + this._buildInsertValues(insertData) + ")";
+    } else if (insertValues.length === 1 && insertValues[0]) {
+      sql += returningSql + this._emptyInsertValue;
     } else {
-      if (insertData.columns.length) {
-        sql += `(${this.formatter.columnize(insertData.columns)}`;
-        sql += `) ${returningSql}values (` + this._buildInsertValues(insertData) + ")";
-      } else if (insertValues.length === 1 && insertValues[0]) {
-        sql += returningSql + this._emptyInsertValue;
-      } else {
-        return "";
-      }
+      return "";
     }
     return sql;
   }
@@ -280,6 +276,7 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
     const { returning } = this.single;
     let sql = "";
     if (returning) {
+      console.error("IBMi DB2 does not support returning in update statements, only inserts");
       sql += `select ${this.formatter.columnize(this.single.returning)} from FINAL TABLE(`;
     }
     sql += withSQL + `update ${this.single.only ? "only " : ""}${this.tableName} set ` + updates.join(", ") + (where ? ` ${where}` : "") + (order ? ` ${order}` : "") + (limit ? ` ${limit}` : "");
@@ -360,7 +357,6 @@ var DB2Client = class extends import_knex.knex.Client {
     if (this.logger.error) {
       this.logger.error("knex-ibmi: " + message);
     }
-    throw new Error(message);
   }
   printWarn(message) {
     if (import_node_process.default.env.DEBUG === "true") {
@@ -413,42 +409,61 @@ var DB2Client = class extends import_knex.knex.Client {
   }
   // Runs the query on the specified connection, providing the bindings
   async _query(connection, obj) {
-    if (!obj || typeof obj == "string") {
-      obj = { sql: obj };
-    }
-    const method = (obj.hasOwnProperty("method") && obj.method !== "raw" ? obj.method : obj.sql.split(" ")[0]).toLowerCase();
-    obj.sqlMethod = method;
-    if (method === "select" || method === "first" || method === "pluck") {
-      const rows = await connection.query(obj.sql, obj.bindings);
-      if (rows) {
-        obj.response = { rows, rowCount: rows.length };
-      }
+    const queryObject = this.normalizeQueryObject(obj);
+    const method = this.determineQueryMethod(queryObject);
+    queryObject.sqlMethod = method;
+    if (this.isSelectMethod(method)) {
+      await this.executeSelectQuery(connection, queryObject);
     } else {
-      try {
-        const statement = await connection.createStatement();
-        await statement.prepare(obj.sql);
-        if (obj.bindings) {
-          await statement.bind(obj.bindings);
-        }
-        const result = await statement.execute();
-        this.printDebug(result);
-        if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
-          obj.response = {
-            rows: result.map(
-              (row) => result.columns && result.columns?.length > 0 ? row[result.columns[0].name] : row
-            ),
-            rowCount: result.count
-          };
-        } else {
-          obj.response = { rows: result, rowCount: result.count };
-        }
-      } catch (err) {
-        this.printError(JSON.stringify(err));
-      }
+      await this.executeStatementQuery(connection, queryObject);
+    }
+    this.printDebug(queryObject);
+    return queryObject;
+  }
+  normalizeQueryObject(obj) {
+    if (!obj || typeof obj === "string") {
+      return { sql: obj };
     }
-    this.printDebug(obj);
     return obj;
   }
+  determineQueryMethod(obj) {
+    return (obj.hasOwnProperty("method") && obj.method !== "raw" ? obj.method : obj.sql.split(" ")[0]).toLowerCase();
+  }
+  isSelectMethod(method) {
+    return method === "select" || method === "first" || method === "pluck";
+  }
+  async executeSelectQuery(connection, obj) {
+    const rows = await connection.query(obj.sql, obj.bindings);
+    if (rows) {
+      obj.response = { rows, rowCount: rows.length };
+    }
+  }
+  async executeStatementQuery(connection, obj) {
+    try {
+      const statement = await connection.createStatement();
+      await statement.prepare(obj.sql);
+      if (obj.bindings) {
+        await statement.bind(obj.bindings);
+      }
+      const result = await statement.execute();
+      this.printDebug(String(result));
+      obj.response = this.formatStatementResponse(result);
+    } catch (err) {
+      this.printError(JSON.stringify(err));
+    }
+  }
+  formatStatementResponse(result) {
+    if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
+      return {
+        rows: result.map(
+          (row) => result.columns && result.columns?.length > 0 ? row[result.columns[0].name] : row
+        ),
+        rowCount: result.count
+      };
+    } else {
+      return { rows: result, rowCount: result.count };
+    }
+  }
   async _stream(connection, obj, stream, options) {
     if (!obj.sql) throw new Error("A query is required to stream results");
     return new Promise((resolve, reject) => {
@@ -464,29 +479,9 @@ var DB2Client = class extends import_knex.knex.Client {
         (error, cursor) => {
           if (error) {
             this.printError(JSON.stringify(error, null, 2));
+            return;
           }
-          const readableStream = new import_node_stream.Readable({
-            objectMode: true,
-            read() {
-              cursor.fetch((error2, result) => {
-                if (error2) {
-                  console.log(JSON.stringify(error2, null, 2));
-                }
-                if (!cursor.noData) {
-                  this.push(result);
-                } else {
-                  cursor.close((error3) => {
-                    if (error3) {
-                      console.log(JSON.stringify(error3, null, 2));
-                    }
-                    if (result) {
-                      this.push(result);
-                    }
-                  });
-                }
-              });
-            }
-          });
+          const readableStream = this._createCursorStream(cursor);
           readableStream.on("error", (err) => {
             reject(err);
             stream.emit("error", err);
@@ -496,6 +491,32 @@ var DB2Client = class extends import_knex.knex.Client {
       );
     });
   }
+  _createCursorStream(cursor) {
+    const parentThis = this;
+    return new import_node_stream.Readable({
+      objectMode: true,
+      read() {
+        cursor.fetch((error, result) => {
+          if (error) {
+            parentThis.printError(JSON.stringify(error, null, 2));
+          }
+          if (!cursor.noData) {
+            this.push(result);
+          } else {
+            cursor.close((closeError) => {
+              if (closeError) {
+                parentThis.printError(JSON.stringify(closeError, null, 2));
+              }
+              if (result) {
+                this.push(result);
+              }
+              this.push(null);
+            });
+          }
+        });
+      }
+    });
+  }
   transaction(container, config, outerTx) {
     return new ibmi_transaction_default(this, container, config, outerTx);
   }
@@ -513,30 +534,40 @@ var DB2Client = class extends import_knex.knex.Client {
   }
   processResponse(obj, runner) {
     if (obj === null) return null;
-    const resp = obj.response;
-    const method = obj.sqlMethod;
-    if (!resp) {
+    const validationResult = this.validateResponse(obj);
+    if (validationResult !== null) return validationResult;
+    const { response } = obj;
+    if (obj.output) {
+      return obj.output(runner, response);
+    }
+    return this.processSqlMethod(obj);
+  }
+  validateResponse(obj) {
+    if (!obj.response) {
       this.printDebug("response undefined" + obj);
+      return void 0;
     }
-    const { rows, rowCount } = resp;
-    if (obj.output) return obj.output.call(runner, resp);
-    switch (method) {
-      case "select":
+    if (!obj.response.rows) {
+      return this.printError("rows undefined" + obj);
+    }
+    return null;
+  }
+  processSqlMethod(obj) {
+    const { rows, rowCount } = obj.response;
+    switch (obj.sqlMethod) {
+      case "select" /* SELECT */:
         return rows;
-      case "pluck":
+      case "pluck" /* PLUCK */:
         return rows.map(obj.pluck);
-      case "first":
+      case "first" /* FIRST */:
         return rows[0];
-      case "insert":
+      case "insert" /* INSERT */:
         return rows;
-      case "del":
-      case "delete":
-      case "update":
-        if (obj.select) {
-          return rows;
-        }
-        return rowCount;
-      case "counter":
+      case "del" /* DELETE */:
+      case "delete" /* DELETE_ALT */:
+      case "update" /* UPDATE */:
+        return obj.select ? rows : rowCount;
+      case "counter" /* COUNTER */:
         return rowCount;
       default:
         return rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bdkinc/knex-ibmi",
-  "version": "0.3.20",
+  "version": "0.3.22",
   "description": "Knex dialect for IBMi",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",