@bdkinc/knex-ibmi 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+## 1.0.0 - 15 Feb 2019
+- Bump up to 1.0.0 to follow semver rules
+- Internal enhancements
+
+## 0.1.5 - 10 Dec 2018
+- Documentation updates
+
+## 0.1.4 - 18 Nov 2018
+- Support Node v6
+
+## 0.1.3 - 17 Nov 2018
+- Don't show debug logs by default #6
+
+## 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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Henry Williams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+[![npm version](http://img.shields.io/npm/v/knex-db2.svg)](https://npmjs.org/package/knex-db2)
+[![Build Status](https://travis-ci.org/henryjw/knex-db2.svg?branch=master)](https://travis-ci.org/henryjw/knex-db2)
+[![Known Vulnerabilities](https://snyk.io/test/npm/knex-db2/badge.svg)](https://snyk.io/test/npm/knex-db2)
+[![dependencies Status](https://david-dm.org/henryjw/knex-db2/status.svg)](https://david-dm.org/henryjw/knex-db2)
+[![devDependencies Status](https://david-dm.org/henryjw/knex-db2/dev-status.svg)](https://david-dm.org/henryjw/knex-db2?type=dev)
+
+**Disclaimer: this library is in early stages of development. Use at your own risk. Please submit an issue for any bugs encounter or any questions you have.**
+
+## Description
+
+This is an external dialect for [knex](https://github.com/tgriesser/knex). This library is only tested on IBMi. Here are the IBM OSS Docs https://ibmi-oss-docs.readthedocs.io/en/latest/odbc/README.html
+
+## Limitations
+
+Currently this dialect has limited functionality compared to the Knex built-in dialects. Below are some of the limitations:
+
+- No transaction support
+- No streaming support
+- Possibly other missing functionality
+
+## Supported functionality
+
+- Query building
+- Query execution (see [Limitations](#Limitations))
+
+## Installing
+
+`npm install https://github.com/bdkinc/knex-ibmi`
+
+Requires Node v14 or higher.
+
+## Dependencies
+
+`npm install odbc` see [ODBC dependencies](#odbc-dependencies) if you run into any issues
+
+`npm install knex`
+
+## Usage
+This library is written in typescript and compiled to both commonjs and esm. 
+
+```javascript
+const Knex = require("knex");
+const { Db2Dialect } = require("knex-ibmi");
+
+const knex = Knex({
+  client: Db2Dialect,
+  connection: {
+    host: "localhost",
+    database: "knextest",
+    port: 50000,
+    user: "db2inst1",
+    password: "db2inst1-pwd",
+    driver: "IBM i Access ODBC Driver",
+    connectionStringParams: {
+      ALLOWPROCCALLS: 1,
+      CMT: 0,
+    },
+  },
+  pool: {
+    min: 2,
+    max: 10,
+  },
+});
+
+const query = knex.select("*").from("table1").where("x", "y");
+
+query
+  .then((result) => console.log(result))
+  .catch((err) => console.error(err))
+  .finally(() => process.exit());
+```
+
+or as ESM
+
+```javascript
+import knex from "knex";
+import { Db2Dialect } from "knex-ibmi";
+
+const knex = Knex({
+  client: Db2Dialect,
+  connection: {
+    host: "localhost",
+    database: "knextest",
+    port: 50000,
+    user: "db2inst1",
+    password: "db2inst1-pwd",
+    driver: "IBM i Access ODBC Driver",
+    connectionStringParams: {
+      ALLOWPROCCALLS: 1,
+      CMT: 0,
+    },
+  },
+  pool: {
+    min: 2,
+    max: 10,
+  },
+});
+
+const query = knex.select("*").from("table1").where("x", "y");
+
+query
+  .then((result) => console.log(result))
+  .catch((err) => console.error(err))
+  .finally(() => process.exit());
+```
+
+## ODBC dependencies
+
+- make: `sudo apt install make`
+- g++: `sudo apt install g++`
+- unix odbc: `sudo apt-get install unixodbc unixodbc-dev`
+
+## Configuring your driver
+
+If you don't know the name of your installed driver, then look in look in `odbcinst.ini`. You can find the full path of the file by running `odbcinst -j`.
+There you should see an entry like the one below:
+
+```
+[IBM i Access ODBC Driver 64-bit]       <= driver name enclosed in square brackets
+Description=IBM i Access for Linux 64-bit ODBC Driver
+Driver=/opt/ibm/iaccess/lib64/libcwbodbc.so
+Setup=/opt/ibm/iaccess/lib64/libcwbodbcs.so
+Threading=0
+DontDLClose=1
+UsageCount=1
+```
+
+If that still doesn't work, then unixodbc is probably looking for the config files in the wrong directory. A common case is that the configs are in `/etc` but your system expects them to be somewhere else. In such case, override the path unixodbc looks in via the `ODBCSYSINI` and `ODBCINI` environment variables.
+E.g., `ODBCINI=/etc ODBCSYSINI=/etc`.
+
+## Installing default driver
+
+### Download driver
+
+https://github.com/ibmdb/node-ibm_db#-download-clidriver-based-on-your-platform--architecture-from-the-below-ibm-hosted-url
+
+### Install driver
+
+- Extract downloaded file. This will create a `clidriver` folder with the driver contents
+- Copy this folder to wherever your system keeps drivers. If you're not sure where to put it, just copy it to `/opt/ibm`.
+- Add the configuration your `/etc/odbcinst.ini` file. Below is what the contents of the file should look like if your odbc path is `/opt`
+
+```
+[IBM Cli Driver]
+Description=IBM CLI Driver for Linux 64-bit
+Driver=/opt/ibm/clidriver/lib/libdb2.soSetup=libdb2.so.1
+hreading=0
+DontDLClose=1
+UsageCount=1
+```

package/dist/index.js

@@ -0,0 +1,138 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DB2Dialect: () => DB2Dialect,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var process = __toESM(require("process"));
+var import_knex = __toESM(require("knex"));
+var odbc = __toESM(require("odbc"));
+var DB2Client = class extends import_knex.default.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) {
+    return value;
+  }
+  printDebug(message) {
+    if (process.env.DEBUG === "true") {
+      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) {
+    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, obj) {
+    if (!obj || typeof obj == "string")
+      obj = { sql: obj };
+    const 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 };
+      }
+      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, runner) {
+    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;
+    }
+  }
+};
+var DB2Dialect = DB2Client;
+var src_default = DB2Client;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DB2Dialect
+});

package/dist/index.mjs

@@ -0,0 +1,103 @@
+// src/index.ts
+import * as process from "process";
+import knex from "knex";
+import * as odbc from "odbc";
+var DB2Client = class 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) {
+    return value;
+  }
+  printDebug(message) {
+    if (process.env.DEBUG === "true") {
+      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) {
+    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, obj) {
+    if (!obj || typeof obj == "string")
+      obj = { sql: obj };
+    const 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 };
+      }
+      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, runner) {
+    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;
+    }
+  }
+};
+var DB2Dialect = DB2Client;
+var src_default = DB2Client;
+export {
+  DB2Dialect,
+  src_default as default
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@bdkinc/knex-ibmi",
+  "version": "0.0.1",
+  "description": "Knex dialect for IBMi",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "exports": {
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "engineStrict": true,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs",
+    "lint:scripts": "eslint . --ext .ts",
+    "format:scripts": "prettier . --write"
+  },
+  "keywords": [
+    "knex",
+    "dialect",
+    "querybuilder",
+    "db2",
+    "ibm",
+    "ibmi",
+    "odbc"
+  ],
+  "author": {
+    "name": "BDKinc",
+    "web": "https://github.com/bdkinc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/bdkinc/knex-ibmi.git"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@faker-js/faker": "^8.0.2",
+    "@types/knex": "^0.16.1",
+    "@typescript-eslint/eslint-plugin": "^5.61.0",
+    "@typescript-eslint/parser": "^5.61.0",
+    "debug": "^4.3.4",
+    "eslint": "^8.44.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "prettier": "^3.0.0",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.6.0",
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.6"
+  },
+  "files": [
+    "src",
+    "dist",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "knex": "^2",
+    "odbc": "^2.4.8"
+  }
+}

package/src/index.ts

@@ -0,0 +1,129 @@
+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;