@bdkinc/knex-ibmi 0.0.2 → 0.0.4

package/src/index.ts

@@ -1,129 +1,197 @@
-import * as process from "process";
-import { Connection } from "odbc";
-import knex from "knex";
-import * as odbc from "odbc";
-import * as console from "console";
-
-class DB2Client extends knex.Client {
-  constructor(config) {
-    super(config);
-    this.driverName = "odbc";
-
-    if (this.driverName && config.connection) {
-      this.initializeDriver();
-      if (!config.pool || (config.pool && config.pool.max !== 0)) {
-        this.initializePool(config);
-      }
-    }
-  }
-
-  _driver() {
-    return odbc;
-  }
-
-  wrapIdentifierImpl(value: any) {
-    // override default wrapper ("). we don't want to use it since
-    // it makes identifiers case-sensitive in DB2
-    return value;
-  }
-
-  printDebug(message: string) {
-    if (process.env.DEBUG === "true") {
-      // @ts-ignore
-      this.logger.debug(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;
-    return await this.driver.connect(
-      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: Connection) {
-    return await connection.close();
-  }
-
-  _getConnectionString(connectionConfig) {
-    const connectionStringParams =
-      connectionConfig.connectionStringParams || {};
-    const connectionStringExtension = Object.keys(
-      connectionStringParams,
-    ).reduce((result, key) => {
-      const value = connectionStringParams[key];
-      return `${result}${key}=${value};`;
-    }, "");
-
-    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: Connection, obj: any) {
-    console.log({ obj });
-    // TODO: verify correctness
-    if (!obj || typeof obj == "string") obj = { sql: obj };
-    const method = (
-      obj.method !== "raw" ? obj.method : obj.sql.split(" ")[0]
-    ).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 };
-      }
-      return obj;
-    }
-
-    const statement = await connection.createStatement();
-    await statement.prepare(obj.sql);
-    await statement.bind(obj.bindings);
-    obj.response = await statement.execute();
-
-    return obj;
-  }
-
-  processResponse(obj: any, runner: any) {
-    // TODO: verify correctness
-    if (obj === null) return null;
-
-    const resp = obj.response;
-    const method = obj.sqlMethod;
-    const { rows } = resp;
-
-    if (obj.output) return obj.output.call(runner, resp);
-
-    switch (method) {
-      case "select":
-      case "pluck":
-      case "first": {
-        if (method === "pluck") return rows.map(obj.pluck);
-        return method === "first" ? rows[0] : rows;
-      }
-      case "insert":
-      case "del":
-      case "delete":
-      case "update":
-      case "counter":
-        return resp.rowCount;
-      default:
-        return resp;
-    }
-  }
-}
-
-export const DB2Dialect = DB2Client;
-export default DB2Client;
+import * as process from "process";
+import { Connection } from "odbc";
+import knex, { Knex } from "knex";
+import * as odbc from "odbc";
+import * as console from "console";
+import SchemaCompiler from "./schema/ibmi-compiler";
+import TableCompiler from "./schema/ibmi-tablecompiler";
+import ColumnCompiler from "./schema/ibmi-columncompiler";
+import Transaction from "./execution/ibmi-transaction";
+import QueryCompiler from "./query/ibmi-querycompiler";
+
+class DB2Client extends knex.Client {
+  constructor(config) {
+    super(config);
+
+    this.driverName = "odbc";
+
+    if (this.dialect && !this.config.client) {
+      // @ts-ignore
+      this.logger.warn(
+        `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.`,
+      );
+    }
+
+    const dbClient = this.config.client || this.dialect;
+    if (!dbClient) {
+      throw new Error(
+        `knex: Required configuration option 'client' is missing.`,
+      );
+    }
+
+    if (config.version) {
+      this.version = config.version;
+    }
+
+    if (this.driverName && config.connection) {
+      this.initializeDriver();
+      if (!config.pool || (config.pool && config.pool.max !== 0)) {
+        this.initializePool(config);
+      }
+    }
+    this.valueForUndefined = this.raw("DEFAULT");
+    if (config.useNullAsDefault) {
+      this.valueForUndefined = null;
+    }
+  }
+
+  _driver() {
+    return odbc;
+  }
+
+  wrapIdentifierImpl(value: any) {
+    // override default wrapper ("). we don't want to use it since
+    // it makes identifiers case-sensitive in DB2
+    if (value.includes("knex_migrations")) {
+      return value.toUpperCase();
+    }
+    return value;
+  }
+
+  printDebug(message: string) {
+    if (process.env.DEBUG === "true") {
+      // @ts-ignore
+      this.logger.debug(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;
+    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: Connection) {
+    console.log("destroy connection");
+    return await connection.close();
+  }
+
+  _getConnectionString(connectionConfig) {
+    const connectionStringParams =
+      connectionConfig.connectionStringParams || {};
+    const connectionStringExtension = Object.keys(
+      connectionStringParams,
+    ).reduce((result, key) => {
+      const value = connectionStringParams[key];
+      return `${result}${key}=${value};`;
+    }, "");
+
+    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(pool: any, obj: any) {
+    // @ts-ignore
+    // TODO: verify correctness
+    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;
+
+    // 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 pool.query(obj.sql, obj.bindings);
+      if (rows) {
+        obj.response = { rows, rowCount: rows.length };
+      }
+    } else {
+      try {
+        const connection = await pool.connect();
+        const statement = await connection.createStatement();
+        await statement.prepare(obj.sql);
+        if (obj.bindings) {
+          await statement.bind(obj.bindings);
+        }
+        const result = await statement.execute();
+        obj.response = { rows: [result.count], rowCount: result.count };
+      } catch (err: any) {
+        console.error(err);
+        throw new Error(err);
+      }
+    }
+    console.log({ obj });
+
+    return obj;
+  }
+
+  transaction(container: any, config: any, outerTx: any): Knex.Transaction {
+    // @ts-ignore
+    return new Transaction(this, ...arguments);
+  }
+
+  schemaCompiler() {
+    // @ts-ignore
+    return new SchemaCompiler(this, ...arguments);
+  }
+
+  tableCompiler() {
+    // @ts-ignore
+    return new TableCompiler(this, ...arguments);
+  }
+
+  columnCompiler() {
+    // @ts-ignore
+    return new ColumnCompiler(this, ...arguments);
+  }
+
+  queryCompiler() {
+    // @ts-ignore
+    return new QueryCompiler(this, ...arguments);
+  }
+
+  processResponse(obj: any, runner: any) {
+    // TODO: verify correctness
+    if (obj === null) return null;
+
+    const resp = obj.response;
+    const method = obj.sqlMethod;
+    const { rows } = resp;
+
+    if (obj.output) return obj.output.call(runner, resp);
+
+    switch (method) {
+      case "select":
+      case "pluck":
+      case "first": {
+        if (method === "pluck") return rows.map(obj.pluck);
+        return method === "first" ? rows[0] : rows;
+      }
+      case "insert":
+      case "del":
+      case "delete":
+      case "update":
+      case "counter":
+        return resp.rowCount;
+      default:
+        return resp;
+    }
+  }
+}
+
+export const DB2Dialect = DB2Client;
+export default DB2Client;

package/src/query/ibmi-querycompiler.ts

@@ -0,0 +1,59 @@
+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";
+
+class IBMiQueryCompiler extends QueryCompiler {
+  _prepInsert(data) {
+    if (isObject(data)) {
+      if (data.hasOwnProperty("migration_time")) {
+        const parsed = new Date(data.migration_time);
+        data.migration_time = format(parsed, "yyyy-MM-dd HH:mm:ss");
+      }
+    }
+
+    const isRaw = rawOrFn_(
+      data,
+      undefined,
+      // @ts-ignore
+      this.builder,
+      // @ts-ignore
+      this.client,
+      // @ts-ignore
+      this.bindingsHolder,
+    );
+    if (isRaw) return isRaw;
+    let columns: any[] = [];
+    const values: any[] = [];
+    if (!Array.isArray(data)) data = data ? [data] : [];
+    let i = -1;
+    while (++i < data.length) {
+      if (data[i] == null) break;
+      if (i === 0) columns = Object.keys(data[i]).sort();
+      const row = new Array(columns.length);
+      const keys = Object.keys(data[i]);
+      let j = -1;
+      while (++j < keys.length) {
+        const key = keys[j];
+        let idx = columns.indexOf(key);
+        if (idx === -1) {
+          columns = columns.concat(key).sort();
+          idx = columns.indexOf(key);
+          let k = -1;
+          while (++k < values.length) {
+            values[k].splice(idx, 0, undefined);
+          }
+          row.splice(idx, 0, undefined);
+        }
+        row[idx] = data[i][key];
+      }
+      values.push(row);
+    }
+    return {
+      columns,
+      values,
+    };
+  }
+}
+
+export default IBMiQueryCompiler;

package/src/schema/ibmi-columncompiler.ts

@@ -0,0 +1,13 @@
+import ColumnCompiler from "knex/lib/schema/columncompiler";
+
+class IBMiColumnCompiler extends ColumnCompiler {
+  increments(options = { primaryKey: true }) {
+    return (
+      "int not null generated always as identity (start with 1, increment by 1)" +
+      // @ts-ignore
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "")
+    );
+  }
+}
+
+export default IBMiColumnCompiler;

package/src/schema/ibmi-compiler.ts

@@ -0,0 +1,57 @@
+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(
+      // @ts-ignore
+      prefixedTableName(this.schema, tableName),
+      // @ts-ignore
+      this.builder,
+      // @ts-ignore
+      this.bindingsHolder,
+    );
+    const bindings = [tableName.toUpperCase()];
+    let sql =
+      `SELECT TABLE_NAME FROM QSYS2.SYSTABLES ` +
+      `WHERE TYPE = 'T' AND TABLE_NAME = ${formattedTable}`;
+    // @ts-ignore
+    if (this.schema) {
+      sql += " AND TABLE_SCHEMA = ?";
+      // @ts-ignore
+      bindings.push(this.schema);
+    }
+
+    // @ts-ignore
+    this.pushQuery({
+      sql,
+      bindings,
+      output: (resp) => {
+        return resp.rowCount > 0;
+      },
+    });
+  }
+
+  toSQL() {
+    // @ts-ignore
+    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
+    return this.sequence;
+  }
+}
+
+function prefixedTableName(prefix, table) {
+  return prefix ? `${prefix}.${table}` : table;
+}
+
+export default IBMiSchemaCompiler;

package/src/schema/ibmi-tablecompiler.ts

@@ -0,0 +1,70 @@
+import TableCompiler from "knex/lib/schema/tablecompiler";
+
+class IBMiTableCompiler extends TableCompiler {
+  createQuery(columns, ifNot, like) {
+    let createStatement = ifNot
+      // @ts-ignore
+      ? `if object_id('${this.tableName()}', 'U') is null `
+      : "";
+
+    if (like) {
+      // This query copy only columns and not all indexes and keys like other databases.
+      // @ts-ignore
+      createStatement += `SELECT * INTO ${this.tableName()} FROM ${this.tableNameLike()} WHERE 0=1`;
+    } else {
+      createStatement +=
+        "CREATE TABLE " +
+        // @ts-ignore
+        this.tableName() +
+        // @ts-ignore
+        (this._formatting ? " (\n    " : " (") +
+        // @ts-ignore
+        columns.sql.join(this._formatting ? ",\n    " : ", ") +
+        // @ts-ignore
+        this._addChecks() +
+        ")";
+    }
+
+    // @ts-ignore
+    this.pushQuery(createStatement);
+
+    // @ts-ignore
+    if (this.single.comment) {
+      // @ts-ignore
+      this.comment(this.single.comment);
+    }
+    if (like) {
+      // @ts-ignore
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
+  }
+
+  // All of the columns to "add" for the query
+  addColumns(columns, prefix) {
+    // @ts-ignore
+    prefix = prefix || this.addColumnsPrefix;
+
+    if (columns.sql.length > 0) {
+      const columnSql = columns.sql.map((column) => {
+        return prefix + column;
+      });
+      // @ts-ignore
+      this.pushQuery({
+        sql:
+          // @ts-ignore
+          (this.lowerCase ? 'alter table ' : 'ALTER TABLE ') +
+          // @ts-ignore
+          this.tableName() +
+          ' ' +
+          columnSql.join(' '),
+        bindings: columns.bindings,
+      });
+    }
+  }
+
+  async commit(conn, value) {
+    return await conn.commit();
+  }
+}
+
+export default IBMiTableCompiler