@bdkinc/knex-ibmi 0.0.1 → 0.0.3

package/src/index.ts

@@ -3,18 +3,46 @@ import { Connection } from "odbc";
 import 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() {
@@ -24,6 +52,9 @@ class DB2Client extends knex.Client {
   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;
   }
 
@@ -39,14 +70,14 @@ class DB2Client extends knex.Client {
   async acquireRawConnection() {
     this.printDebug("acquiring raw connection");
     const connectionConfig = this.config.connection;
-    return await this.driver.connect(
-      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: Connection) {
+    console.log("destroy connection");
     return await connection.close();
   }
 
@@ -69,33 +100,70 @@ class DB2Client extends knex.Client {
 
   // 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 });
+  async _query(pool: any, obj: any) {
+    // @ts-ignore
     // TODO: verify correctness
     if (!obj || typeof obj == "string") obj = { sql: obj };
     const method = (
-      obj.method !== "raw" ? obj.method : obj.sql.split(" ")[0]
+      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 connection.query(obj.sql, obj.bindings);
+      const rows: any = await pool.query(obj.sql, obj.bindings);
       if (rows) {
         obj.response = { rows, rowCount: rows.length };
       }
-      return obj;
+    } 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);
+      }
     }
-
-    const statement = await connection.createStatement();
-    await statement.prepare(obj.sql);
-    await statement.bind(obj.bindings);
-    obj.response = await statement.execute();
+    console.log({ obj });
 
     return obj;
   }
 
+  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;

package/src/query/ibmi-querycompiler.ts

@@ -0,0 +1,132 @@
+import QueryCompiler from "knex/lib/query/querycompiler";
+import has from "lodash/has";
+import isEmpty from "lodash/isEmpty";
+import omitBy from "lodash/omitBy";
+import isObject from "lodash/isObject";
+import {
+  wrap as wrap_,
+  rawOrFn as rawOrFn_,
+} from "knex/lib/formatter/wrappingFormatter";
+import { format, parseISO } from "date-fns";
+import * as console from "console";
+
+class IBMiQueryCompiler extends QueryCompiler {
+  _prepInsert(data) {
+    if (isObject(data)) {
+      console.log("data is object", data);
+      if (data.hasOwnProperty("migration_time")) {
+        console.log("data has migration_time", data.migration_time);
+        const parsed = new Date(data.migration_time);
+        console.log(parsed);
+        data.migration_time = format(parsed, "yyyy-MM-dd HH:mm:ss");
+        console.log(data.migration_time);
+      }
+      console.log("data date after change", data);
+    }
+    const isRaw = rawOrFn_(
+      data,
+      undefined,
+      this.builder,
+      this.client,
+      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,
+    };
+  }
+
+  _prepUpdate(data = {}): any[] {
+    const { counter = {} } = this.single;
+
+    for (const column of Object.keys(counter)) {
+      //Skip?
+      if (has(data, column)) {
+        //Needed?
+        this.client.logger.warn(
+          `increment/decrement called for a column that has already been specified in main .update() call. Ignoring increment/decrement and using value from .update() call.`,
+        );
+        continue;
+      }
+
+      let value = counter[column];
+
+      const symbol = value < 0 ? "-" : "+";
+
+      if (symbol === "-") {
+        value = -value;
+      }
+
+      data[column] = this.client.raw(`?? ${symbol} ?`, [column, value]);
+    }
+
+    data = omitBy(data, (value) => typeof value === "undefined");
+
+    const vals = [];
+    const columns = Object.keys(data);
+    let i = -1;
+
+    while (++i < columns.length) {
+      vals.push(
+        wrap_(
+          columns[i],
+          undefined,
+          this.builder,
+          this.client,
+          this.bindingsHolder,
+        ) +
+          " = " +
+          this.client.parameter(
+            data[columns[i]],
+            this.builder,
+            this.bindingsHolder,
+          ),
+      );
+    }
+
+    if (isEmpty(vals)) {
+      throw new Error(
+        [
+          "Empty .update() call detected!",
+          "Update data does not contain any values to update.",
+          "This will result in a faulty query.",
+          this.single.table ? `Table: ${this.single.table}.` : "",
+          this.single.update
+            ? `Columns: ${Object.keys(this.single.update)}.`
+            : "",
+        ].join(" "),
+      );
+    }
+
+    return vals;
+  }
+}
+
+export default IBMiQueryCompiler;

package/src/schema/ibmi-columncompiler.ts

@@ -0,0 +1,34 @@
+import ColumnCompiler from "knex/lib/schema/columncompiler";
+import * as console from "console";
+
+class IBMiColumnCompiler extends ColumnCompiler {
+  constructor(client, tableCompiler, columnBuilder) {
+    super(client, tableCompiler, columnBuilder);
+  }
+
+  increments(options = { primaryKey: true }) {
+    return (
+      "int not null generated always as identity (start with 1, increment by 1)" +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "")
+    );
+  }
+
+  datetime(withoutTz = false, precision) {
+    let useTz;
+    if (isObject(withoutTz)) {
+      ({ useTz, precision } = withoutTz);
+    } else {
+      useTz = !withoutTz;
+    }
+    useTz = typeof useTz === "boolean" ? useTz : true;
+    precision =
+      precision !== undefined && precision !== null
+        ? "(" + precision + ")"
+        : "";
+
+    console.log(useTz, precision);
+    return `${useTz ? "timestamptz" : "timestamp"}${precision}`;
+  }
+}
+
+export default IBMiColumnCompiler;

package/src/schema/ibmi-compiler.ts

@@ -0,0 +1,50 @@
+import SchemaCompiler from "knex/lib/schema/compiler";
+import * as console from "console";
+
+class IBMiSchemaCompiler extends SchemaCompiler {
+  constructor(client, builder) {
+    super(client, builder);
+  }
+
+  hasTable(tableName) {
+    const formattedTable = this.client.parameter(
+      prefixedTableName(this.schema, tableName),
+      this.builder,
+      this.bindingsHolder,
+    );
+    const bindings = [tableName.toUpperCase()];
+    let sql =
+      `SELECT TABLE_NAME FROM QSYS2.SYSTABLES ` +
+      `WHERE TYPE = 'T' AND TABLE_NAME = ${formattedTable}`;
+    if (this.schema) {
+      sql += " AND TABLE_SCHEMA = ?";
+      bindings.push(this.schema);
+    }
+
+    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,109 @@
+import TableCompiler from "knex/lib/schema/tablecompiler";
+
+class IBMiTableCompiler extends TableCompiler {
+  constructor(client, tableBuilder) {
+    super(client, tableBuilder);
+  }
+
+  unique(columns, indexName) {
+    /** @type {string | undefined} */
+    let deferrable;
+    let useConstraint = false;
+    let predicate;
+    if (typeof indexName === "object") {
+      ({ indexName, deferrable, useConstraint, predicate } = indexName);
+    }
+    if (deferrable && deferrable !== 'not deferrable') {
+      this.client.logger.warn(
+        `ibmi: unique index [${indexName}] will not be deferrable ${deferrable} because mssql does not support deferred constraints.`
+      );
+    }
+    if (useConstraint && predicate) {
+      throw new Error('ibmi cannot create constraint with predicate');
+    }
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('unique', this.tableNameRaw, columns);
+
+    if (!Array.isArray(columns)) {
+      columns = [columns];
+    }
+
+    if (useConstraint) {
+      // mssql supports unique indexes and unique constraints.
+      // unique indexes cannot be used with foreign key relationships hence unique constraints are used instead.
+      this.pushQuery(
+        `ALTER TABLE ${this.tableName()} ADD CONSTRAINT ${indexName} UNIQUE (${this.formatter.columnize(
+          columns
+        )})`
+      );
+    } else {
+      // default to making unique index that allows null https://stackoverflow.com/a/767702/360060
+      // to be more or less compatible with other DBs (if any of the columns is NULL then "duplicates" are allowed)
+      const predicateQuery = predicate
+        ? ' ' + this.client.queryCompiler(predicate).where()
+        : ' WHERE ' +
+        columns
+          .map((column) => this.formatter.columnize(column) + ' IS NOT NULL')
+          .join(' AND ');
+      this.pushQuery(
+        `CREATE UNIQUE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
+          columns
+        )})${predicateQuery}`
+      );
+    }
+  }
+
+  createQuery(columns, ifNot, like) {
+    let createStatement = ifNot
+      ? `if object_id('${this.tableName()}', 'U') is null `
+      : "";
+
+    if (like) {
+      // This query copy only columns and not all indexes and keys like other databases.
+      createStatement += `SELECT * INTO ${this.tableName()} FROM ${this.tableNameLike()} WHERE 0=1`;
+    } else {
+      createStatement +=
+        "CREATE TABLE " +
+        this.tableName() +
+        (this._formatting ? " (\n    " : " (") +
+        columns.sql.join(this._formatting ? ",\n    " : ", ") +
+        this._addChecks() +
+        ")";
+    }
+
+    this.pushQuery(createStatement);
+
+    if (this.single.comment) {
+      this.comment(this.single.comment);
+    }
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
+  }
+
+  // All of the columns to "add" for the query
+  addColumns(columns, prefix) {
+    prefix = prefix || this.addColumnsPrefix;
+
+    if (columns.sql.length > 0) {
+      const columnSql = columns.sql.map((column) => {
+        return prefix + column;
+      });
+      this.pushQuery({
+        sql:
+          (this.lowerCase ? 'alter table ' : 'ALTER TABLE ') +
+          this.tableName() +
+          ' ' +
+          columnSql.join(' '),
+        bindings: columns.bindings,
+      });
+    }
+  }
+
+  async commit(conn, value) {
+    return await conn.commit();
+  }
+}
+
+export default IBMiTableCompiler