@bdkinc/knex-ibmi 0.1.2 → 0.1.4

package/README.md

@@ -105,6 +105,7 @@ try {
 ```
 
 or as Typescript
+note: you will probably need to add skipLibCheck: true in your tsconfig compilerOptions if not there already. I plan to clean up the types so this is not an issue. 
 
 ```typescript
 import { knex } from "knex";

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import QueryCompiler from 'knex/lib/query/querycompiler';
 
 declare class IBMiSchemaCompiler extends SchemaCompiler {
     hasTable(tableName: any): void;
-    toSQL(): any;
+    toSQL(): any[];
 }
 
 declare class IBMiTableCompiler extends TableCompiler {
@@ -42,12 +42,14 @@ declare class IBMiQueryCompiler extends QueryCompiler {
 }
 
 declare class DB2Client extends knex.Client {
-    constructor(config: any);
+    constructor(config: Knex.Config<DB2Config>);
     _driver(): typeof odbc;
     printDebug(message: string): void;
+    printError(message: string): void;
+    printWarn(message: string): void;
     acquireRawConnection(): Promise<any>;
     destroyRawConnection(connection: Connection): Promise<void>;
-    _getConnectionString(connectionConfig: any): string;
+    _getConnectionString(connectionConfig: DB2ConnectionConfig): string;
     _query(connection: any, obj: any): Promise<any>;
     transaction(container: any, config: any, outerTx: any): Knex.Transaction;
     schemaCompiler(): IBMiSchemaCompiler;
@@ -75,7 +77,7 @@ interface DB2ConnectionParams {
     DECFLOATERROROPTION?: 0 | 1;
     DECFLOATROUNDMODE?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
     MAPDECIMALFLOATDESCRIBE?: 1 | 3;
-    ALLOWPROCCALLS: 0 | 1;
+    ALLOWPROCCALLS?: 0 | 1;
 }
 interface DB2ConnectionConfig {
     database: string;

package/dist/index.js

@@ -350,7 +350,7 @@ var DB2Client = class extends import_knex.knex.Client {
     super(config);
     this.driverName = "odbc";
     if (this.dialect && !this.config.client) {
-      this.logger.warn(
+      this.printWarn(
         `Using 'this.dialect' to identify the client is deprecated and support for it will be removed in the future. Please use configuration option 'client' instead.`
       );
     }
@@ -382,22 +382,31 @@ var DB2Client = class extends import_knex.knex.Client {
       this.logger.debug("knex-ibmi: " + message);
     }
   }
+  printError(message) {
+    if (process.env.DEBUG === "true") {
+      this.logger.error("knex-ibmi: " + message);
+    }
+  }
+  printWarn(message) {
+    if (process.env.DEBUG === "true") {
+      this.logger.warn("knex-ibmi: " + message);
+    }
+  }
   // Get a raw connection, called by the pool manager whenever a new
   // connection needs to be added to the pool.
   async acquireRawConnection() {
     this.printDebug("acquiring raw connection");
     const connectionConfig = this.config.connection;
-    this.printDebug(this._getConnectionString(connectionConfig));
+    this.printDebug(
+      // @ts-ignore
+      "connection config: " + this._getConnectionString(connectionConfig)
+    );
     if (this.config?.pool) {
       const poolConfig = {
-        connectionString: this._getConnectionString(connectionConfig),
-        connectionTimeout: (
-          // @ts-ignore
-          this.config?.acquireConnectionTimeout || 6e4
-        ),
         // @ts-ignore
+        connectionString: this._getConnectionString(connectionConfig),
+        connectionTimeout: this.config?.acquireConnectionTimeout || 6e4,
         initialSize: this.config?.pool?.min || 2,
-        // @ts-ignore
         maxSize: this.config?.pool?.max || 10,
         reuseConnection: true
       };
@@ -405,6 +414,7 @@ var DB2Client = class extends import_knex.knex.Client {
       return await pool.connect();
     }
     return await this.driver.connect(
+      // @ts-ignore
       this._getConnectionString(connectionConfig)
     );
   }
@@ -425,7 +435,6 @@ var DB2Client = class extends import_knex.knex.Client {
     return `${`DRIVER=${connectionConfig.driver};SYSTEM=${connectionConfig.host};HOSTNAME=${connectionConfig.host};PORT=${connectionConfig.port};DATABASE=${connectionConfig.database};UID=${connectionConfig.user};PWD=${connectionConfig.password};`}${connectionStringExtension}`;
   }
   // Runs the query on the specified connection, providing the bindings
-  // and any other necessary prep work.
   async _query(connection, obj) {
     if (!obj || typeof obj == "string")
       obj = { sql: obj };
@@ -437,8 +446,6 @@ var DB2Client = class extends import_knex.knex.Client {
         obj.response = { rows, rowCount: rows.length };
       }
     } else {
-      await connection.beginTransaction();
-      this.printDebug("transaction begun");
       try {
         const statement = await connection.createStatement();
         await statement.prepare(obj.sql);
@@ -446,6 +453,7 @@ var DB2Client = class extends import_knex.knex.Client {
           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(
@@ -470,15 +478,10 @@ var DB2Client = class extends import_knex.knex.Client {
           obj.response = { rows: result, rowCount: result.count };
         }
       } catch (err) {
-        this.printDebug(err);
-        await connection.rollback();
-        throw new Error(err);
-      } finally {
-        this.printDebug("transaction committed");
-        await connection.commit();
+        this.printError(err);
       }
     }
-    this.printDebug(obj.sql + obj.bindings ? JSON.stringify(obj.bindings) : "");
+    this.printDebug(obj);
     return obj;
   }
   transaction(container, config, outerTx) {

package/package.json

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

package/src/execution/ibmi-transaction.ts

@@ -2,17 +2,17 @@
 import Transaction from "knex/lib/execution/transaction";
 
 class IBMiTransaction extends Transaction {
-  async begin(connection) {
+  async begin(connection: any) {
     await connection.beginTransaction();
     return connection;
   }
 
-  async rollback(connection) {
+  async rollback(connection: any) {
     await connection.rollback();
     return connection;
   }
 
-  async commit(connection) {
+  async commit(connection: any) {
     await connection.commit();
     return connection;
   }

package/src/index.ts

@@ -9,13 +9,12 @@ import Transaction from "./execution/ibmi-transaction";
 import QueryCompiler from "./query/ibmi-querycompiler";
 
 class DB2Client extends knex.Client {
-  constructor(config) {
+  constructor(config: Knex.Config<DB2Config>) {
     super(config);
     this.driverName = "odbc";
 
     if (this.dialect && !this.config.client) {
-      // @ts-ignore
-      this.logger.warn(
+      this.printWarn(
         `Using 'this.dialect' to identify the client is deprecated and support for it will be removed in the future. Please use configuration option 'client' instead.`,
       );
     }
@@ -54,23 +53,38 @@ class DB2Client extends knex.Client {
     }
   }
 
+  printError(message: string) {
+    if (process.env.DEBUG === "true") {
+      // @ts-ignore
+      this.logger.error("knex-ibmi: " + message);
+    }
+  }
+
+  printWarn(message: string) {
+    if (process.env.DEBUG === "true") {
+      // @ts-ignore
+      this.logger.warn("knex-ibmi: " + message);
+    }
+  }
+
   // Get a raw connection, called by the pool manager whenever a new
   // connection needs to be added to the pool.
   async acquireRawConnection() {
     this.printDebug("acquiring raw connection");
     const connectionConfig = this.config.connection;
-    this.printDebug(this._getConnectionString(connectionConfig));
 
-    // @ts-ignore
+    this.printDebug(
+      // @ts-ignore
+      "connection config: " + this._getConnectionString(connectionConfig),
+    );
+
     if (this.config?.pool) {
+      // @ts-ignore
       const poolConfig = {
-        connectionString: this._getConnectionString(connectionConfig),
-        connectionTimeout:
-          // @ts-ignore
-          this.config?.acquireConnectionTimeout || 60000,
         // @ts-ignore
+        connectionString: this._getConnectionString(connectionConfig),
+        connectionTimeout: this.config?.acquireConnectionTimeout || 60000,
         initialSize: this.config?.pool?.min || 2,
-        // @ts-ignore
         maxSize: this.config?.pool?.max || 10,
         reuseConnection: true,
       };
@@ -79,6 +93,7 @@ class DB2Client extends knex.Client {
     }
 
     return await this.driver.connect(
+      // @ts-ignore
       this._getConnectionString(connectionConfig),
     );
   }
@@ -90,7 +105,7 @@ class DB2Client extends knex.Client {
     return await connection.close();
   }
 
-  _getConnectionString(connectionConfig) {
+  _getConnectionString(connectionConfig: DB2ConnectionConfig) {
     const connectionStringParams =
       connectionConfig.connectionStringParams || {};
     const connectionStringExtension = Object.keys(
@@ -108,7 +123,6 @@ class DB2Client extends knex.Client {
   }
 
   // Runs the query on the specified connection, providing the bindings
-  // and any other necessary prep work.
   async _query(connection: any, obj: any) {
     if (!obj || typeof obj == "string") obj = { sql: obj };
     const method = (
@@ -118,32 +132,29 @@ class DB2Client extends knex.Client {
     ).toLowerCase();
     obj.sqlMethod = method;
 
-    // Different functions are used since query() doesn't return # of rows affected,
-    // which is needed for queries that modify the database
-
     if (method === "select" || method === "first" || method === "pluck") {
       const rows: any = await connection.query(obj.sql, obj.bindings);
       if (rows) {
         obj.response = { rows, rowCount: rows.length };
       }
     } else {
-      await connection.beginTransaction();
-      this.printDebug("transaction begun");
       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);
         // 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) =>
+            rows: result.map((row: { [x: string]: any; }) =>
               result.columns && result.columns?.length > 0
                 ? row[result.columns[0].name]
                 : row,
@@ -167,16 +178,12 @@ class DB2Client extends knex.Client {
           obj.response = { rows: result, rowCount: result.count };
         }
       } catch (err: any) {
-        this.printDebug(err);
-        await connection.rollback();
-        throw new Error(err);
-      } finally {
-        this.printDebug("transaction committed");
-        await connection.commit();
+        this.printError(err);
       }
     }
 
-    this.printDebug(obj.sql + obj.bindings ? JSON.stringify(obj.bindings) : "");
+    this.printDebug(obj);
+
     return obj;
   }
 
@@ -258,7 +265,7 @@ interface DB2ConnectionParams {
   DECFLOATERROROPTION?: 0 | 1;
   DECFLOATROUNDMODE?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
   MAPDECIMALFLOATDESCRIBE?: 1 | 3;
-  ALLOWPROCCALLS: 0 | 1;
+  ALLOWPROCCALLS?: 0 | 1;
 }
 
 interface DB2ConnectionConfig {

package/src/knex-shim.d.ts

@@ -0,0 +1,283 @@
+declare module "knex/lib/execution/transaction" {
+  import { EventEmitter } from "node:events";
+  import { Knex } from "knex";
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+  interface Transaction extends Knex.Transaction {}
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+  class Transaction extends EventEmitter {
+    constructor(client: Knex.Client, container: any, config: any, outerTx: any);
+  }
+
+  export default Transaction;
+}
+
+declare module "knex/lib/query/querycompiler" {
+  // eslint-disable-next-line no-duplicate-imports
+  import { Knex } from "knex";
+
+  class QueryCompiler {
+    client: Knex.Client;
+    method: string;
+    options: any;
+    single: any;
+    queryComments: any[];
+    timeout: boolean;
+    cancelOnTimeout: boolean;
+    grouped: any;
+    formatter: any;
+    _emptyInsertValue: string;
+    first: () => any;
+    bindings: any[];
+    bindingsHolder: this;
+    builder: any;
+    tableName: string;
+
+    constructor(
+      client: Knex.Client,
+      builder: Knex.QueryBuilder,
+      bindings?: any,
+    );
+    toSQL(
+      method,
+      tz,
+    ): {
+      method: string;
+      options: any;
+      timeout: boolean;
+      cancelOnTimeout: boolean;
+      bindings: any[];
+      __knexQueryUid: string;
+      toNative: () => { sql: string; bindings: any[] };
+      sql?: string;
+      as?: string;
+    };
+
+    select(): string;
+    insert(): string | { sql: string; returning?: any };
+    with(): string;
+    comments(): string;
+    columns(): string;
+    join(): string;
+    where(): string;
+    union(): string;
+    group(): string;
+    having(): string;
+    order(): string;
+    limit(): string;
+    offset(): string;
+    lock(): string;
+    waitMode(): string;
+    wrap(str: string): string;
+
+    // Internal methods
+    _buildInsertValues(insertData: any): string;
+    _prepUpdate(data: any): any;
+  }
+
+  export default QueryCompiler;
+}
+
+declare module "knex/lib/schema/tablecompiler" {
+  // Eslint gets dumb about this
+  // eslint-disable-next-line no-duplicate-imports
+  import { Knex } from "knex";
+
+  class TableCompiler {
+    constructor(client: Knex.Client, tableBuilder?: Knex.TableBuilder);
+
+    client: Knex.Client;
+    tableBuilder: Knex.TableBuilder;
+    _commonBuilder: Knex.TableBuilder;
+    method: string;
+    schemaNameRaw: string;
+    tableNameRaw: string;
+    tableNameLikeRaw: string;
+    single: any;
+    grouped: any;
+    formatter: any;
+    bindings: any[];
+    bindingsHolder: this;
+    sequence: any[];
+    _formatting: boolean;
+    checksCount: number;
+
+    toSQL(): any[];
+    create(ifNot: boolean, like: boolean): void;
+    createIfNot(): void;
+    createLike(): void;
+    createLikeIfNot(): void;
+    alter(): void;
+    foreign(foreignData: any): void;
+    getColumnTypes(columns: any[]): any;
+    columnQueries(columns: any[]): void;
+    addColumns(columns: any[], prefix?: string): void;
+    alterColumns(columns: any[], colBuilders: any[]): void;
+    getColumns(method?: string): any[];
+    tableName(): string;
+    tableNameLike(): string;
+    alterTable(): void;
+    alterTableForCreate(columnTypes: any): void;
+    dropIndex(value: string): void;
+    dropUnique(columns: string | string[], indexName: string): void;
+    dropForeign(): void;
+    dropColumn(): void;
+    _setNullableState(column: string, nullable: boolean): void;
+    setNullable(column: string): void;
+    dropNullable(column: string): void;
+    dropChecks(checkConstraintNames: string[]): void;
+    check(
+      checkPredicate: string,
+      bindings: any[],
+      constraintName: string,
+    ): void;
+    _addChecks(): string;
+    _indexCommand(type: string, tableName: string, columns: string[]): string;
+    _getPrimaryKeys(): any[];
+    _canBeAddPrimaryKey(options: any): boolean;
+    _getIncrementsColumnNames(): any[];
+    _getBigIncrementsColumnNames(): any[];
+
+    pushQuery(query: string | { sql: string; bindings: any }): void;
+    pushAdditional(fn: any): void;
+    unshiftQuery(query: string | { sql: string; bindings: any }): void;
+
+    lowerCase: boolean;
+    createAlterTableMethods: any;
+    addColumnsPrefix: string;
+    alterColumnsPrefix: string;
+    modifyColumnPrefix: string;
+    dropColumnPrefix: string;
+
+    comment(val: any): void;
+  }
+
+  export default TableCompiler;
+}
+
+declare module "knex/lib/schema/columncompiler" {
+  // Eslint gets dumb about this
+  // eslint-disable-next-line no-duplicate-imports
+  import { Knex } from "knex";
+  import TableCompiler from "knex/lib/schema/tablecompiler";
+
+  class ColumnCompiler {
+    constructor(
+      client: Knex.Client,
+      tableCompiler?: TableCompiler,
+      columnBuilder?: Knex.ColumnBuilder,
+    );
+
+    client: Knex.Client;
+    tableCompiler: TableCompiler;
+    columnBuilder: Knex.ColumnBuilder;
+    _commonBuilder: Knex.ColumnBuilder;
+    args: any[];
+    type: string;
+    grouped: any;
+    modified: any;
+    isIncrements: boolean;
+    formatter: any;
+    bindings: any[];
+    bindingsHolder: this;
+    sequence: any[];
+    modifiers: string[];
+    checksCount: number;
+    _columnType: string;
+
+    _addCheckModifiers(): void;
+    defaults(label: string): any;
+    toSQL(): any[];
+    compileColumn(): string;
+    getColumnName(): string;
+    getColumnType(): string;
+    getModifiers(): string;
+
+    varchar(length: number): string;
+    floating(precision: number, scale: number): string;
+    decimal(precision: number, scale: number): string;
+    specifictype(type: string): string;
+
+    nullable(nullable: boolean): string;
+    notNullable(): string;
+    defaultTo(value: any): string;
+    increments(options?: { primaryKey: boolean }): string;
+    bigincrements(options?: { primaryKey: boolean }): string;
+
+    _pushAlterCheckQuery(checkPredicate: string, constraintName: string): void;
+    _checkConstraintName(constraintName: string): string;
+    _check(checkPredicate: string, constraintName: string): string;
+    checkPositive(constraintName: string): string;
+    checkNegative(constraintName: string): string;
+    _checkIn(values: any[], constraintName: string, not?: boolean): string;
+    checkIn(values: any[], constraintName: string): string;
+    checkNotIn(values: any[], constraintName: string): string;
+    checkBetween(intervals: any[], constraintName: string): string;
+    checkLength(
+      operator: string,
+      length: number,
+      constraintName: string,
+    ): string;
+  }
+
+  export default ColumnCompiler;
+}
+
+declare module "knex/lib/schema/compiler" {
+  // Eslint gets dumb about this
+  // eslint-disable-next-line no-duplicate-imports
+  import { Knex } from "knex";
+
+  class SchemaCompiler {
+    constructor(client: Knex.Client, builder?: Knex.TableBuilder);
+
+    client: Knex.Client;
+    builder: Knex.TableBuilder;
+    _commonBuilder: Knex.TableBuilder;
+    schema: any;
+    bindings: any[];
+    bindingsHolder: this;
+    formatter: any;
+    sequence: any[];
+    dropTablePrefix: string;
+    dropViewPrefix: string;
+    dropMaterializedViewPrefix: string;
+    alterViewPrefix: string;
+
+    createSchema(): void;
+    createSchemaIfNotExists(): void;
+    dropSchema(): void;
+    dropSchemaIfExists(): void;
+    dropTable(tableName: string): void;
+    dropTableIfExists(tableName: string): void;
+    dropView(viewName: string): void;
+    dropViewIfExists(viewName: string): void;
+    dropMaterializedView(viewName: string): void;
+    dropMaterializedViewIfExists(viewName: string): void;
+    renameView(from: string, to: string): void;
+    refreshMaterializedView(): void;
+    _dropView(viewName: string, ifExists: boolean, materialized: boolean): void;
+    raw(sql: string, bindings: any[]): void;
+    toSQL(): any[];
+    generateDdlCommands(): Promise<any>;
+    alterTable(): any;
+    createTable(): any;
+    createTableIfNotExists(): any;
+    createTableLike(): any;
+    createView(): any;
+    createViewOrReplace(): any;
+    createMaterializedView(): any;
+    alterView(): any;
+    pushQuery(): void;
+    pushAdditional(): void;
+    unshiftQuery(): void;
+
+    pushQuery(
+      query: string | { sql: string; bindings: any; output: any },
+    ): void;
+    pushAdditional(fn: any): void;
+    unshiftQuery(query: string | { sql: string; bindings: any }): void;
+  }
+
+  export default SchemaCompiler;
+}

package/src/query/ibmi-querycompiler.ts

@@ -4,7 +4,6 @@ import isObject from "lodash/isObject";
 import { rawOrFn as rawOrFn_ } from "knex/lib/formatter/wrappingFormatter";
 import { format } from "date-fns";
 import isEmpty from "lodash/isEmpty";
-import * as console from "console";
 
 class IBMiQueryCompiler extends QueryCompiler {
   insert() {