@bdkinc/knex-ibmi 0.3.22 → 0.4.3

package/dist/index.js

@@ -1,12 +1,12 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
 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 __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,49 +28,80 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// node_modules/lodash/isObject.js
-var require_isObject = __commonJS({
-  "node_modules/lodash/isObject.js"(exports2, module2) {
-    function isObject2(value) {
-      var type = typeof value;
-      return value != null && (type == "object" || type == "function");
-    }
-    module2.exports = isObject2;
-  }
-});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   DB2Dialect: () => DB2Dialect,
-  default: () => src_default
+  IBMiMigrationRunner: () => IBMiMigrationRunner,
+  createIBMiMigrationRunner: () => createIBMiMigrationRunner,
+  default: () => index_default
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 var import_node_process = __toESM(require("process"));
-var import_knex = require("knex");
+var import_knex = __toESM(require("knex"));
 var import_odbc = __toESM(require("odbc"));
 
 // src/schema/ibmi-compiler.ts
-var import_compiler = __toESM(require("knex/lib/schema/compiler"));
+var import_compiler = __toESM(require("knex/lib/schema/compiler.js"));
 var IBMiSchemaCompiler = class extends import_compiler.default {
   hasTable(tableName) {
-    const formattedTable = this.client.parameter(
-      prefixedTableName(this.schema, tableName),
-      this.builder,
-      this.bindingsHolder
-    );
-    const bindings = [tableName];
-    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);
+    const upperName = String(tableName).toUpperCase();
+    let schemaName = null;
+    let actualTableName = upperName;
+    if (upperName.includes(".")) {
+      const parts = upperName.split(".");
+      schemaName = parts[0];
+      actualTableName = parts[1];
+    }
+    const builderSchema = this.builder._schema;
+    if (builderSchema) {
+      schemaName = builderSchema.toUpperCase();
+    }
+    let sql;
+    let bindings;
+    if (schemaName) {
+      sql = `select count(*) as table_count from QSYS2.SYSTABLES where UPPER(TABLE_NAME) = ? AND UPPER(TABLE_SCHEMA) = ?`;
+      bindings = [actualTableName, schemaName];
+    } else {
+      sql = `select count(*) as table_count from QSYS2.SYSTABLES where UPPER(TABLE_NAME) = ?`;
+      bindings = [actualTableName];
     }
     this.pushQuery({
       sql,
       bindings,
-      output: (resp) => {
-        return resp.rowCount > 0;
+      output: (runner, resp) => {
+        if (!resp) {
+          return false;
+        }
+        if (Array.isArray(resp) && resp.length > 0) {
+          const firstRow = resp[0];
+          if (firstRow && typeof firstRow === "object") {
+            const count = firstRow.table_count || firstRow.TABLE_COUNT || firstRow.count || firstRow.COUNT || 0;
+            return count > 0;
+          }
+        }
+        if (typeof resp === "object" && resp !== null) {
+          const keys = Object.keys(resp);
+          for (const key of keys) {
+            if (!isNaN(parseInt(key))) {
+              const row = resp[key];
+              if (row && typeof row === "object") {
+                const count = row.table_count || row.TABLE_COUNT || row.count || row.COUNT || 0;
+                return count > 0;
+              }
+            }
+          }
+          if (resp.rows && Array.isArray(resp.rows) && resp.rows.length > 0) {
+            const firstRow = resp.rows[0];
+            if (firstRow && typeof firstRow === "object") {
+              const count = firstRow.table_count || firstRow.TABLE_COUNT || firstRow.count || firstRow.COUNT || 0;
+              return count > 0;
+            }
+          }
+        }
+        return false;
       }
     });
   }
@@ -83,14 +114,10 @@ var IBMiSchemaCompiler = class extends import_compiler.default {
     return this.sequence;
   }
 };
-function prefixedTableName(prefix, table) {
-  return prefix ? `${prefix}.${table}` : table;
-}
 var ibmi_compiler_default = IBMiSchemaCompiler;
 
 // src/schema/ibmi-tablecompiler.ts
-var import_tablecompiler = __toESM(require("knex/lib/schema/tablecompiler"));
-var import_isObject = __toESM(require_isObject());
+var import_tablecompiler = __toESM(require("knex/lib/schema/tablecompiler.js"));
 var IBMiTableCompiler = class extends import_tablecompiler.default {
   createQuery(columns, ifNot, like) {
     let createStatement = ifNot ? `if object_id('${this.tableName()}', 'U') is null ` : "";
@@ -114,21 +141,24 @@ var IBMiTableCompiler = class extends import_tablecompiler.default {
   unique(columns, indexName) {
     let deferrable = "";
     let predicate;
-    if ((0, import_isObject.default)(indexName)) {
-      deferrable = indexName.deferrable;
+    let finalIndexName;
+    if (typeof indexName === "object" && indexName !== null) {
+      deferrable = indexName.deferrable || "";
       predicate = indexName.predicate;
-      indexName = indexName.indexName;
+      finalIndexName = indexName.indexName;
+    } else {
+      finalIndexName = indexName;
     }
     if (deferrable && deferrable !== "not deferrable") {
       this.client.logger.warn?.(
-        `IBMi: unique index \`${indexName}\` will not be deferrable ${deferrable}.`
+        `IBMi: unique index \`${finalIndexName}\` will not be deferrable ${deferrable}.`
       );
     }
-    indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
+    const wrappedIndexName = finalIndexName ? this.formatter.wrap(finalIndexName) : this._indexCommand("unique", this.tableNameRaw, columns);
     columns = this.formatter.columnize(columns);
     const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : "";
     this.pushQuery(
-      `create unique index ${indexName} on ${this.tableName()} (${columns})${predicateQuery}`
+      `create unique index ${wrappedIndexName} on ${this.tableName()} (${columns})${predicateQuery}`
     );
   }
   // All of the columns to "add" for the query
@@ -151,74 +181,264 @@ var IBMiTableCompiler = class extends import_tablecompiler.default {
 var ibmi_tablecompiler_default = IBMiTableCompiler;
 
 // src/schema/ibmi-columncompiler.ts
-var import_columncompiler = __toESM(require("knex/lib/schema/columncompiler"));
+var import_columncompiler = __toESM(require("knex/lib/schema/columncompiler.js"));
 var IBMiColumnCompiler = class extends import_columncompiler.default {
   increments(options = { primaryKey: true }) {
     return "int not null generated always as identity (start with 1, increment by 1)" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
   }
+  // Add more IBM i DB2 specific column types for better support
+  bigIncrements(options = { primaryKey: true }) {
+    return "bigint not null generated always as identity (start with 1, increment by 1)" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
+  }
+  varchar(length) {
+    return length ? `varchar(${length})` : "varchar(255)";
+  }
+  char(length) {
+    return length ? `char(${length})` : "char(1)";
+  }
+  text() {
+    return "clob(1M)";
+  }
+  mediumtext() {
+    return "clob(16M)";
+  }
+  longtext() {
+    return "clob(2G)";
+  }
+  binary(length) {
+    return length ? `binary(${length})` : "binary(1)";
+  }
+  varbinary(length) {
+    return length ? `varbinary(${length})` : "varbinary(255)";
+  }
+  // IBM i DB2 decimal with precision/scale
+  decimal(precision, scale) {
+    if (precision && scale) {
+      return `decimal(${precision}, ${scale})`;
+    } else if (precision) {
+      return `decimal(${precision})`;
+    }
+    return "decimal(10, 2)";
+  }
+  // IBM i DB2 timestamp
+  timestamp(options) {
+    if (options?.useTz) {
+      return "timestamp with time zone";
+    }
+    return "timestamp";
+  }
+  datetime(options) {
+    return this.timestamp(options);
+  }
+  // IBM i DB2 date and time types
+  date() {
+    return "date";
+  }
+  time() {
+    return "time";
+  }
+  // JSON support (IBM i 7.3+)
+  json() {
+    return "clob(16M) check (json_valid(json_column))";
+  }
+  jsonb() {
+    return "clob(16M) check (json_valid(jsonb_column))";
+  }
+  // UUID support using CHAR(36)
+  uuid() {
+    return "char(36)";
+  }
 };
 var ibmi_columncompiler_default = IBMiColumnCompiler;
 
 // src/execution/ibmi-transaction.ts
-var import_transaction = __toESM(require("knex/lib/execution/transaction"));
+var import_transaction = __toESM(require("knex/lib/execution/transaction.js"));
 var IBMiTransaction = class extends import_transaction.default {
   begin(connection) {
-    return connection.beginTransaction();
+    try {
+      return connection.beginTransaction();
+    } catch (error) {
+      if (this.isConnectionClosed(error)) {
+        console.warn(
+          "IBM i DB2: Connection closed during transaction begin, DDL operations may have caused implicit commit"
+        );
+        throw new Error(
+          "Connection closed during transaction begin - consider using migrations.disableTransactions: true"
+        );
+      }
+      throw error;
+    }
   }
   rollback(connection) {
-    return connection.rollback();
+    try {
+      return connection.rollback();
+    } catch (error) {
+      console.warn(
+        "IBM i DB2: Rollback encountered an error (likely closed connection):",
+        error?.message || error
+      );
+      return Promise.resolve();
+    }
   }
   commit(connection) {
-    return connection.commit();
+    try {
+      return connection.commit();
+    } catch (error) {
+      if (this.isConnectionClosed(error)) {
+        console.warn(
+          "IBM i DB2: Connection closed during commit - DDL operations cause implicit commits"
+        );
+        throw new Error(
+          "Connection closed during commit - this is expected with DDL operations on IBM i DB2"
+        );
+      }
+      throw error;
+    }
+  }
+  isConnectionClosed(error) {
+    const message = String(error?.message || error || "").toLowerCase();
+    return message.includes("connection") && (message.includes("closed") || message.includes("invalid") || message.includes("terminated") || message.includes("not connected"));
   }
 };
 var ibmi_transaction_default = IBMiTransaction;
 
 // src/query/ibmi-querycompiler.ts
-var import_querycompiler = __toESM(require("knex/lib/query/querycompiler"));
-var import_wrappingFormatter = require("knex/lib/formatter/wrappingFormatter");
-var import_date_fns = require("date-fns");
+var import_querycompiler = __toESM(require("knex/lib/query/querycompiler.js"));
+var import_wrappingFormatter = require("knex/lib/formatter/wrappingFormatter.js");
 var IBMiQueryCompiler = class extends import_querycompiler.default {
+  constructor() {
+    super(...arguments);
+    // Cache for column metadata to improve performance with repeated operations
+    __publicField(this, "columnCache", /* @__PURE__ */ new Map());
+  }
+  // Override select method to add IBM i optimization hints
+  select() {
+    const originalResult = super.select.call(this);
+    return originalResult;
+  }
+  formatTimestampLocal(date) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const y = date.getFullYear();
+    const m = pad(date.getMonth() + 1);
+    const d = pad(date.getDate());
+    const hh = pad(date.getHours());
+    const mm = pad(date.getMinutes());
+    const ss = pad(date.getSeconds());
+    return `${y}-${m}-${d} ${hh}:${mm}:${ss}`;
+  }
   insert() {
     const insertValues = this.single.insert || [];
-    let sql = `select ${this.single.returning ? this.formatter.columnize(this.single.returning) : "IDENTITY_VAL_LOCAL()"} from FINAL TABLE(`;
-    sql += this.with() + `insert into ${this.tableName} `;
     const { returning } = this.single;
-    const returningSql = returning ? this._returning("insert", returning, void 0) + " " : "";
-    if (Array.isArray(insertValues)) {
-      if (insertValues.length === 0) {
-        return "";
+    if (this.isEmptyInsertValues(insertValues)) {
+      if (this.isEmptyObject(insertValues)) {
+        return this.buildEmptyInsertResult(returning);
       }
-    } else if (typeof insertValues === "object" && Object.keys(insertValues).length === 0) {
+      return "";
+    }
+    const ibmiConfig = this.client?.config?.ibmi || {};
+    const multiRowStrategy = ibmiConfig.multiRowInsert || "auto";
+    const isArrayInsert = Array.isArray(insertValues) && insertValues.length > 1;
+    const originalValues = isArrayInsert ? insertValues.slice() : insertValues;
+    const forceSingleRow = multiRowStrategy === "disabled" || multiRowStrategy === "sequential" && isArrayInsert;
+    let workingValues = insertValues;
+    if (forceSingleRow && isArrayInsert) {
+      workingValues = [insertValues[0]];
+      this.single.insert = workingValues;
+    }
+    const standardInsert = super.insert();
+    const insertSql = typeof standardInsert === "object" && standardInsert.sql ? standardInsert.sql : standardInsert;
+    const multiRow = isArrayInsert && !forceSingleRow;
+    if (multiRow && returning === "*") {
+      if (this.client?.printWarn) {
+        this.client.printWarn("multi-row insert with returning * may be large");
+      }
+    }
+    const selectColumns = returning ? this.formatter.columnize(returning) : multiRow ? "*" : "IDENTITY_VAL_LOCAL()";
+    const sql = `select ${selectColumns} from FINAL TABLE(${insertSql})`;
+    if (multiRowStrategy === "sequential" && isArrayInsert) {
+      const first = originalValues[0];
+      const columns = Object.keys(first).sort();
       return {
-        sql: sql + returningSql + this._emptyInsertValue,
-        returning
+        sql,
+        returning: void 0,
+        _ibmiSequentialInsert: {
+          columns,
+          rows: originalValues,
+          tableName: this.tableName,
+          returning: returning || null,
+          identityOnly: !returning
+        }
       };
     }
-    sql += this._buildInsertData(insertValues, returningSql);
-    sql += ")";
-    return {
-      sql,
-      returning
-    };
+    return { sql, returning: void 0 };
+  }
+  isEmptyInsertValues(insertValues) {
+    return Array.isArray(insertValues) && insertValues.length === 0 || this.isEmptyObject(insertValues);
+  }
+  isEmptyObject(insertValues) {
+    return insertValues !== null && typeof insertValues === "object" && !Array.isArray(insertValues) && Object.keys(insertValues).length === 0;
+  }
+  buildEmptyInsertResult(returning) {
+    const selectColumns = returning ? this.formatter.columnize(returning) : "IDENTITY_VAL_LOCAL()";
+    const returningSql = returning ? this._returning("insert", returning, void 0) + " " : "";
+    const insertSql = [
+      this.with(),
+      `insert into ${this.tableName}`,
+      returningSql + this._emptyInsertValue
+    ].filter(Boolean).join(" ");
+    const sql = `select ${selectColumns} from FINAL TABLE(${insertSql})`;
+    return { sql, returning };
   }
   _buildInsertData(insertValues, returningSql) {
-    let sql = "";
     const insertData = this._prepInsert(insertValues);
-    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 "";
+    if (insertData.columns.length > 0) {
+      const parts = [];
+      parts.push("(" + this.formatter.columnize(insertData.columns) + ") ");
+      if (returningSql) parts.push(returningSql);
+      parts.push("values ");
+      const rowsSql = [];
+      for (const row of insertData.values) {
+        const placeholders = row.map(() => "?").join(", ");
+        rowsSql.push("(" + placeholders + ")");
+      }
+      parts.push(rowsSql.join(", "));
+      return parts.join("");
+    }
+    if (Array.isArray(insertValues) && insertValues.length === 1 && insertValues[0]) {
+      return (returningSql || "") + this._emptyInsertValue;
+    }
+    return "";
+  }
+  generateCacheKey(data) {
+    if (Array.isArray(data) && data.length > 0) {
+      return Object.keys(data[0] || {}).sort().join("|");
+    }
+    if (data && typeof data === "object") {
+      return Object.keys(data).sort().join("|");
+    }
+    return "";
+  }
+  buildFromCache(data, cachedColumns) {
+    const dataArray = Array.isArray(data) ? data : data ? [data] : [];
+    const values = [];
+    for (const item of dataArray) {
+      if (item == null) {
+        break;
+      }
+      const row = cachedColumns.map((column) => item[column] ?? void 0);
+      values.push(row);
     }
-    return sql;
+    return {
+      columns: cachedColumns,
+      values
+    };
   }
   _prepInsert(data) {
-    if (typeof data === "object" && data.migration_time) {
+    if (typeof data === "object" && data?.migration_time) {
       const parsed = new Date(data.migration_time);
-      data.migration_time = (0, import_date_fns.format)(parsed, "yyyy-MM-dd HH:mm:ss");
+      if (!isNaN(parsed.getTime())) {
+        data.migration_time = this.formatTimestampLocal(parsed);
+      }
     }
     const isRaw = (0, import_wrappingFormatter.rawOrFn)(
       data,
@@ -230,42 +450,29 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
     if (isRaw) {
       return isRaw;
     }
-    let columns = [];
-    const values = [];
-    if (!Array.isArray(data)) {
-      data = data ? [data] : [];
+    const dataArray = Array.isArray(data) ? data : data ? [data] : [];
+    if (dataArray.length === 0) {
+      return { columns: [], values: [] };
     }
-    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, void 0);
-          }
-          row.splice(idx, 0, void 0);
-        }
-        row[idx] = data[i][key];
-      }
-      values.push(row);
+    const firstItem = dataArray[0];
+    if (!firstItem || typeof firstItem !== "object") {
+      return { columns: [], values: [] };
     }
-    return {
-      columns,
-      values
-    };
+    const cacheKey = this.generateCacheKey(firstItem);
+    let columns;
+    if (cacheKey && this.columnCache.has(cacheKey)) {
+      columns = this.columnCache.get(cacheKey);
+    } else {
+      columns = Object.keys(firstItem).sort();
+      if (cacheKey && columns.length > 0)
+        this.columnCache.set(cacheKey, columns);
+    }
+    const values = [];
+    for (const item of dataArray) {
+      if (!item || typeof item !== "object") continue;
+      values.push(columns.map((c) => item[c] ?? void 0));
+    }
+    return { columns, values };
   }
   update() {
     const withSQL = this.with();
@@ -274,17 +481,61 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
     const order = this.order();
     const limit = this.limit();
     const { returning } = this.single;
-    let sql = "";
+    const optimizationHints = "";
+    const baseUpdateSql = [
+      withSQL,
+      `update ${this.single.only ? "only " : ""}${this.tableName}`,
+      "set",
+      updates.join(", "),
+      where,
+      order,
+      limit,
+      optimizationHints
+    ].filter(Boolean).join(" ");
     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(`;
+      const selectColumns = this.formatter.columnize(this.single.returning);
+      const expectedSql = `select ${selectColumns} from FINAL TABLE(${baseUpdateSql})`;
+      return {
+        sql: expectedSql,
+        returning,
+        _ibmiUpdateReturning: {
+          updateSql: baseUpdateSql,
+          selectColumns,
+          whereClause: where,
+          tableName: this.tableName
+        }
+      };
     }
-    sql += withSQL + `update ${this.single.only ? "only " : ""}${this.tableName} set ` + updates.join(", ") + (where ? ` ${where}` : "") + (order ? ` ${order}` : "") + (limit ? ` ${limit}` : "");
-    if (returning) {
-      sql += `)`;
+    return { sql: baseUpdateSql, returning };
+  }
+  // Emulate DELETE ... RETURNING by compiling a FINAL TABLE wrapper for display and attaching metadata
+  del() {
+    const baseDelete = super.del();
+    const { returning } = this.single;
+    if (!returning) {
+      return { sql: baseDelete, returning: void 0 };
     }
-    return { sql, returning };
+    const deleteSql = typeof baseDelete === "object" && baseDelete.sql ? baseDelete.sql : baseDelete;
+    const selectColumns = this.formatter.columnize(returning);
+    const expectedSql = `select ${selectColumns} from FINAL TABLE(${deleteSql})`;
+    return {
+      sql: expectedSql,
+      returning,
+      _ibmiDeleteReturning: {
+        deleteSql,
+        selectColumns,
+        whereClause: this.where(),
+        tableName: this.tableName
+      }
+    };
   }
+  /**
+   * Handle returning clause for IBMi DB2 queries
+   * Note: IBMi DB2 has limited support for RETURNING clauses
+   * @param method - The SQL method (insert, update, delete)
+   * @param value - The returning value
+   * @param withTrigger - Trigger support (currently unused)
+   */
   _returning(method, value, withTrigger) {
     switch (method) {
       case "update":
@@ -294,24 +545,238 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
         return value ? `${withTrigger ? " into #out" : ""}` : "";
       case "rowcount":
         return value ? "select @@rowcount" : "";
+      default:
+        return "";
+    }
+  }
+  getOptimizationHints(queryType, data) {
+    const hints = [];
+    if (queryType === "select") {
+      hints.push("WITH UR");
     }
+    return hints.length > 0 ? " " + hints.join(" ") : "";
+  }
+  getSelectOptimizationHints(sql) {
+    const hints = [];
+    hints.push("WITH UR");
+    return hints.length > 0 ? " " + hints.join(" ") : "";
   }
   columnizeWithPrefix(prefix, target) {
     const columns = typeof target === "string" ? [target] : target;
-    let str = "";
-    let i = -1;
-    while (++i < columns.length) {
-      if (i > 0) str += ", ";
-      str += prefix + this.wrap(columns[i]);
+    const parts = [];
+    for (let i = 0; i < columns.length; i++) {
+      if (i > 0) parts.push(", ");
+      parts.push(prefix + this.wrap(columns[i]));
     }
-    return str;
+    return parts.join("");
   }
 };
 var ibmi_querycompiler_default = IBMiQueryCompiler;
 
 // src/index.ts
 var import_node_stream = require("stream");
-var DB2Client = class extends import_knex.knex.Client {
+
+// src/migrations/ibmi-migration-runner.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var IBMiMigrationRunner = class {
+  constructor(knex2, config) {
+    __publicField(this, "knex");
+    __publicField(this, "config");
+    this.knex = knex2;
+    this.config = {
+      directory: "./migrations",
+      tableName: "KNEX_MIGRATIONS",
+      schemaName: void 0,
+      extension: "js",
+      ...config
+    };
+  }
+  getFullTableName() {
+    return this.config.schemaName ? `${this.config.schemaName}.${this.config.tableName}` : this.config.tableName;
+  }
+  async latest() {
+    try {
+      console.log(
+        "\u{1F680} IBM i DB2 Migration Runner - bypassing Knex locking system"
+      );
+      const tableName = this.getFullTableName();
+      const migrationTableExists = await this.knex.schema.hasTable(
+        tableName
+      );
+      if (!migrationTableExists) {
+        console.log(`\u{1F4DD} Creating migration table: ${tableName}`);
+        await this.knex.schema.createTable(tableName, (table) => {
+          table.increments("id").primary();
+          table.string("name");
+          table.integer("batch");
+          table.timestamp("migration_time");
+        });
+        console.log("\u2705 Migration table created");
+      }
+      const completed = await this.knex(tableName).select("NAME").orderBy("ID");
+      const completedNames = completed.map((c) => c.NAME);
+      console.log(`\u{1F4CB} Found ${completedNames.length} completed migrations`);
+      const migrationFiles = this.getMigrationFiles();
+      console.log(`\u{1F4C1} Found ${migrationFiles.length} migration files`);
+      const newMigrations = migrationFiles.filter(
+        (file) => !completedNames.includes(file)
+      );
+      if (newMigrations.length === 0) {
+        console.log("\u2705 No new migrations to run");
+        return;
+      }
+      console.log(`\u{1F3AF} Running ${newMigrations.length} new migrations:`);
+      newMigrations.forEach((file) => console.log(`  - ${file}`));
+      const batchResult = await this.knex(tableName).max("BATCH as max_batch");
+      const nextBatch = (batchResult[0]?.max_batch || 0) + 1;
+      console.log(`\u{1F4CA} Using batch number: ${nextBatch}`);
+      for (const migrationFile of newMigrations) {
+        console.log(`
+\u{1F504} Running migration: ${migrationFile}`);
+        try {
+          const migrationPath = this.getMigrationPath(migrationFile);
+          const migration = await import(migrationPath);
+          if (!migration.up || typeof migration.up !== "function") {
+            throw new Error(`Migration ${migrationFile} has no 'up' function`);
+          }
+          console.log(`  \u26A1 Executing migration...`);
+          await migration.up(this.knex);
+          await this.knex(tableName).insert({
+            name: migrationFile,
+            batch: nextBatch,
+            migration_time: /* @__PURE__ */ new Date()
+          });
+          console.log(`  \u2705 Migration ${migrationFile} completed successfully`);
+        } catch (error) {
+          console.error(
+            `  \u274C Migration ${migrationFile} failed:`,
+            error.message
+          );
+          throw error;
+        }
+      }
+      console.log(`
+\u{1F389} All migrations completed successfully!`);
+    } catch (error) {
+      console.error("\u274C Migration runner failed:", error.message);
+      throw error;
+    }
+  }
+  async rollback(steps = 1) {
+    try {
+      console.log(`\u{1F504} Rolling back ${steps} migration batch(es)...`);
+      const tableName = this.getFullTableName();
+      const batchesToRollback = await this.knex(tableName).distinct("BATCH").orderBy("BATCH", "desc").limit(steps);
+      if (batchesToRollback.length === 0) {
+        console.log("\u2705 No migrations to rollback");
+        return;
+      }
+      const batchNumbers = batchesToRollback.map((b) => b.BATCH);
+      console.log(`\u{1F4CA} Rolling back batches: ${batchNumbers.join(", ")}`);
+      const migrationsToRollback = await this.knex(tableName).select("NAME").whereIn("BATCH", batchNumbers).orderBy("ID", "desc");
+      console.log(`\u{1F3AF} Rolling back ${migrationsToRollback.length} migrations:`);
+      migrationsToRollback.forEach((m) => console.log(`  - ${m.NAME}`));
+      for (const migrationRecord of migrationsToRollback) {
+        const migrationFile = migrationRecord.NAME;
+        console.log(`
+\u{1F504} Rolling back migration: ${migrationFile}`);
+        try {
+          const migrationPath = this.getMigrationPath(migrationFile);
+          const migration = await import(migrationPath);
+          if (migration.down && typeof migration.down === "function") {
+            console.log(`  \u26A1 Executing rollback...`);
+            await migration.down(this.knex);
+          } else {
+            console.log(
+              `  \u26A0\uFE0F Migration ${migrationFile} has no 'down' function, skipping rollback`
+            );
+          }
+          await this.knex(tableName).where("NAME", migrationFile).del();
+          console.log(
+            `  \u2705 Migration ${migrationFile} rolled back successfully`
+          );
+        } catch (error) {
+          console.error(
+            `  \u274C Migration ${migrationFile} rollback failed:`,
+            error.message
+          );
+          throw error;
+        }
+      }
+      console.log(`
+\u{1F389} Rollback completed successfully!`);
+    } catch (error) {
+      console.error("\u274C Rollback failed:", error.message);
+      throw error;
+    }
+  }
+  async currentVersion() {
+    try {
+      const tableName = this.getFullTableName();
+      const migrationTableExists = await this.knex.schema.hasTable(
+        tableName
+      );
+      if (!migrationTableExists) {
+        return null;
+      }
+      const result = await this.knex(tableName).select("NAME").orderBy("ID", "desc").first();
+      return result?.NAME || null;
+    } catch (error) {
+      console.error("\u274C Error getting current version:", error.message);
+      return null;
+    }
+  }
+  async listExecuted() {
+    try {
+      const tableName = this.getFullTableName();
+      const migrationTableExists = await this.knex.schema.hasTable(
+        tableName
+      );
+      if (!migrationTableExists) {
+        return [];
+      }
+      const completed = await this.knex(tableName).select("NAME").orderBy("ID");
+      return completed.map((c) => c.NAME);
+    } catch (error) {
+      console.error("\u274C Error listing executed migrations:", error.message);
+      return [];
+    }
+  }
+  async listPending() {
+    try {
+      const allFiles = this.getMigrationFiles();
+      const executed = await this.listExecuted();
+      return allFiles.filter((file) => !executed.includes(file));
+    } catch (error) {
+      console.error("\u274C Error listing pending migrations:", error.message);
+      return [];
+    }
+  }
+  getMigrationFiles() {
+    const { directory, extension } = this.config;
+    if (!import_fs.default.existsSync(directory)) {
+      throw new Error(`Migration directory does not exist: ${directory}`);
+    }
+    const validExtensions = ["js", "ts", "mjs", "cjs"];
+    const extensionToCheck = extension || "js";
+    return import_fs.default.readdirSync(directory).filter((file) => {
+      if (extension && extension !== "js") {
+        return file.endsWith(`.${extension}`);
+      }
+      return validExtensions.some((ext) => file.endsWith(`.${ext}`));
+    }).sort();
+  }
+  getMigrationPath(filename) {
+    return import_path.default.resolve(this.config.directory, filename);
+  }
+};
+function createIBMiMigrationRunner(knex2, config) {
+  return new IBMiMigrationRunner(knex2, config);
+}
+
+// src/index.ts
+var DB2Client = class extends import_knex.default.Client {
   constructor(config) {
     super(config);
     this.driverName = "odbc";
@@ -340,10 +805,25 @@ var DB2Client = class extends import_knex.knex.Client {
       this.valueForUndefined = null;
     }
   }
+  // Helper method to safely stringify objects that might have circular references
+  safeStringify(obj, indent = 0) {
+    try {
+      return JSON.stringify(obj, null, indent);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("circular")) {
+        return `[Circular structure - ${typeof obj}]`;
+      }
+      return `[Stringify error - ${typeof obj}]`;
+    }
+  }
   _driver() {
     return import_odbc.default;
   }
   wrapIdentifierImpl(value) {
+    if (!value) return value;
+    if (value.includes("KNEX_MIGRATIONS") || value.includes("knex_migrations")) {
+      return value.toUpperCase();
+    }
     return value;
   }
   printDebug(message) {
@@ -376,6 +856,7 @@ var DB2Client = class extends import_knex.knex.Client {
     this.printDebug(
       "connection config: " + this._getConnectionString(connectionConfig)
     );
+    let connection;
     if (this.config?.pool) {
       const poolConfig = {
         connectionString: this._getConnectionString(connectionConfig),
@@ -385,11 +866,13 @@ var DB2Client = class extends import_knex.knex.Client {
         reuseConnection: true
       };
       const pool = await this.driver.pool(poolConfig);
-      return await pool.connect();
+      connection = await pool.connect();
+    } else {
+      connection = await this.driver.connect(
+        this._getConnectionString(connectionConfig)
+      );
     }
-    return await this.driver.connect(
-      this._getConnectionString(connectionConfig)
-    );
+    return connection;
   }
   // Used to explicitly close a connection, called internally by the pool manager
   // when a connection times out or the pool is shutdown.
@@ -405,20 +888,180 @@ var DB2Client = class extends import_knex.knex.Client {
       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}`;
+    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
   async _query(connection, obj) {
     const queryObject = this.normalizeQueryObject(obj);
     const method = this.determineQueryMethod(queryObject);
     queryObject.sqlMethod = method;
-    if (this.isSelectMethod(method)) {
-      await this.executeSelectQuery(connection, queryObject);
-    } else {
-      await this.executeStatementQuery(connection, queryObject);
+    if (queryObject._ibmiUpdateReturning) {
+      return await this.executeUpdateReturning(connection, queryObject);
+    }
+    if (queryObject._ibmiSequentialInsert) {
+      return await this.executeSequentialInsert(connection, queryObject);
+    }
+    if (queryObject._ibmiDeleteReturning) {
+      return await this.executeDeleteReturning(connection, queryObject);
+    }
+    if (import_node_process.default.env.DEBUG === "true" && queryObject.sql && (queryObject.sql.toLowerCase().includes("create table") || queryObject.sql.toLowerCase().includes("knex_migrations"))) {
+      this.printDebug(
+        `Executing ${method} query: ${queryObject.sql.substring(0, 200)}...`
+      );
+      if (queryObject.bindings?.length) {
+        this.printDebug(`Bindings: ${JSON.stringify(queryObject.bindings)}`);
+      }
+    }
+    try {
+      const startTime = Date.now();
+      if (this.isSelectMethod(method)) {
+        await this.executeSelectQuery(connection, queryObject);
+      } else {
+        await this.executeStatementQuery(connection, queryObject);
+      }
+      const endTime = Date.now();
+      if (import_node_process.default.env.DEBUG === "true" && queryObject.sql && (queryObject.sql.toLowerCase().includes("create table") || queryObject.sql.toLowerCase().includes("knex_migrations"))) {
+        this.printDebug(`${method} completed in ${endTime - startTime}ms`);
+      }
+      this.printDebug(`Query completed: ${method} (${endTime - startTime}ms)`);
+      return queryObject;
+    } catch (error) {
+      const wrappedError = this.wrapError(error, method, queryObject);
+      if (this.isConnectionError(error)) {
+        this.printError(
+          `Connection error during ${method} query: ${error.message}`
+        );
+        if (this.shouldRetryQuery(queryObject, method)) {
+          return await this.retryQuery(connection, queryObject, method);
+        }
+        throw wrappedError;
+      }
+      throw wrappedError;
+    }
+  }
+  /**
+   * Execute UPDATE with returning clause using transaction + SELECT approach
+   * Since IBM i DB2 doesn't support FINAL TABLE with UPDATE, we:
+   * 1. Execute the UPDATE statement
+   * 2. Execute a SELECT to get the updated values using the same WHERE clause
+   */
+  async executeUpdateReturning(connection, obj) {
+    const { _ibmiUpdateReturning } = obj;
+    const { updateSql, selectColumns, whereClause, tableName } = _ibmiUpdateReturning;
+    this.printDebug(
+      "Executing UPDATE with returning using transaction approach"
+    );
+    try {
+      const updateObj = {
+        sql: updateSql,
+        bindings: obj.bindings,
+        sqlMethod: "update"
+      };
+      await this.executeStatementQuery(connection, updateObj);
+      const selectSql = whereClause ? `select ${selectColumns} from ${tableName} ${whereClause}` : `select ${selectColumns} from ${tableName}`;
+      const updateSqlParts = updateSql.split(" where ");
+      const setClausePart = updateSqlParts[0];
+      const setBindingCount = (setClausePart.match(/\?/g) || []).length;
+      const whereBindings = obj.bindings ? obj.bindings.slice(setBindingCount) : [];
+      const selectObj = {
+        sql: selectSql,
+        bindings: whereBindings,
+        sqlMethod: "select",
+        response: void 0
+      };
+      await this.executeSelectQuery(connection, selectObj);
+      obj.response = selectObj.response;
+      obj.sqlMethod = "update";
+      obj.select = true;
+      return obj;
+    } catch (error) {
+      this.printError(`UPDATE with returning failed: ${error.message}`);
+      throw this.wrapError(error, "update_returning", obj);
+    }
+  }
+  async executeSequentialInsert(connection, obj) {
+    const meta = obj._ibmiSequentialInsert;
+    const { rows, columns, tableName, returning, identityOnly } = meta;
+    this.printDebug("Executing sequential multi-row insert");
+    const insertedRows = [];
+    const transactional = this.config?.ibmi?.sequentialInsertTransactional === true;
+    let beganTx = false;
+    if (transactional) {
+      try {
+        await connection.query("BEGIN");
+        beganTx = true;
+      } catch (e) {
+        this.printWarn(
+          "Could not begin transaction for sequential insert; proceeding without"
+        );
+      }
+    }
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const colList = columns.join(", ");
+      const placeholders = columns.map(() => "?").join(", ");
+      const singleValues = columns.map((c) => row[c]);
+      const baseInsert = `insert into ${tableName} (${colList}) values (${placeholders})`;
+      const selectCols = returning ? this.queryCompiler({}).formatter.columnize(returning) : "IDENTITY_VAL_LOCAL()";
+      const wrapped = `select ${selectCols} from FINAL TABLE(${baseInsert})`;
+      const singleObj = {
+        sql: wrapped,
+        bindings: singleValues,
+        sqlMethod: "insert",
+        response: void 0
+      };
+      await this.executeStatementQuery(connection, singleObj);
+      const resp = singleObj.response?.rows;
+      if (resp) insertedRows.push(...resp);
+    }
+    if (transactional && beganTx) {
+      try {
+        await connection.query("COMMIT");
+      } catch (commitErr) {
+        this.printError(
+          "Commit failed for sequential insert, attempting rollback: " + commitErr?.message
+        );
+        try {
+          await connection.query("ROLLBACK");
+        } catch {
+        }
+        throw commitErr;
+      }
+    }
+    obj.response = { rows: insertedRows, rowCount: insertedRows.length };
+    obj.sqlMethod = "insert";
+    obj.select = true;
+    return obj;
+  }
+  async executeDeleteReturning(connection, obj) {
+    const meta = obj._ibmiDeleteReturning;
+    const { deleteSql, selectColumns, whereClause, tableName } = meta;
+    this.printDebug("Executing DELETE with returning emulation");
+    try {
+      const selectSql = whereClause ? `select ${selectColumns} from ${tableName} ${whereClause}` : `select ${selectColumns} from ${tableName}`;
+      const selectObj = {
+        sql: selectSql,
+        bindings: obj.bindings,
+        sqlMethod: "select",
+        response: void 0
+      };
+      await this.executeSelectQuery(connection, selectObj);
+      const rowsToReturn = selectObj.response?.rows || [];
+      const deleteObj = {
+        sql: deleteSql,
+        bindings: obj.bindings,
+        sqlMethod: "del",
+        response: void 0
+      };
+      await this.executeStatementQuery(connection, deleteObj);
+      obj.response = { rows: rowsToReturn, rowCount: rowsToReturn.length };
+      obj.sqlMethod = "del";
+      obj.select = true;
+      return obj;
+    } catch (error) {
+      this.printError(`DELETE with returning failed: ${error.message}`);
+      throw this.wrapError(error, "delete_returning", obj);
     }
-    this.printDebug(queryObject);
-    return queryObject;
   }
   normalizeQueryObject(obj) {
     if (!obj || typeof obj === "string") {
@@ -433,14 +1076,18 @@ var DB2Client = class extends import_knex.knex.Client {
     return method === "select" || method === "first" || method === "pluck";
   }
   async executeSelectQuery(connection, obj) {
-    const rows = await connection.query(obj.sql, obj.bindings);
+    const rows = await connection.query(
+      obj.sql,
+      obj.bindings
+    );
     if (rows) {
       obj.response = { rows, rowCount: rows.length };
     }
   }
   async executeStatementQuery(connection, obj) {
+    let statement;
     try {
-      const statement = await connection.createStatement();
+      statement = await connection.createStatement();
       await statement.prepare(obj.sql);
       if (obj.bindings) {
         await statement.bind(obj.bindings);
@@ -449,60 +1096,130 @@ var DB2Client = class extends import_knex.knex.Client {
       this.printDebug(String(result));
       obj.response = this.formatStatementResponse(result);
     } catch (err) {
-      this.printError(JSON.stringify(err));
+      const sql = (obj.sql || "").toLowerCase();
+      const isDml = obj.sqlMethod === "update" /* UPDATE */ || sql.includes(" update ") || sql.startsWith("update") || obj.sqlMethod === "del" /* DELETE */ || sql.includes(" delete ") || sql.startsWith("delete");
+      const odbcErrors = err?.odbcErrors;
+      const isEmptyOdbcError = Array.isArray(odbcErrors) && odbcErrors.length === 0;
+      const hasNoDataState = Array.isArray(odbcErrors) ? odbcErrors.some(
+        (e) => String(e?.state || e?.SQLSTATE || "").toUpperCase() === "02000"
+      ) : false;
+      if (isDml && (isEmptyOdbcError || hasNoDataState || this.isNoDataError(err))) {
+        this.printWarn(
+          `ODBC signaled no-data for ${sql.includes("update") ? "UPDATE" : "DELETE"}; treating as 0 rows affected`
+        );
+        obj.response = { rows: [], rowCount: 0 };
+        return;
+      }
+      this.printError(this.safeStringify(err));
+      throw err;
+    } finally {
+      if (statement && typeof statement.close === "function") {
+        try {
+          await statement.close();
+        } catch (closeErr) {
+          this.printDebug(
+            `Error closing statement: ${this.safeStringify(closeErr, 2)}`
+          );
+        }
+      }
     }
   }
+  isNoDataError(error) {
+    if (!error) return false;
+    const msg = String(error?.message || error || "").toLowerCase();
+    return msg.includes("02000") || msg.includes("no data") || msg.includes("no rows") || msg.includes("0 rows");
+  }
+  /**
+   * Format statement response from ODBC driver
+   * Handles special case for IDENTITY_VAL_LOCAL() function
+   */
   formatStatementResponse(result) {
-    if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
+    const isIdentityQuery = result.statement?.includes("IDENTITY_VAL_LOCAL()");
+    if (isIdentityQuery && result.columns?.length > 0) {
       return {
         rows: result.map(
-          (row) => result.columns && result.columns?.length > 0 ? row[result.columns[0].name] : row
+          (row) => row[result.columns[0].name]
         ),
         rowCount: result.count
       };
-    } else {
-      return { rows: result, rowCount: result.count };
     }
+    const rowCount = typeof result?.count === "number" ? result.count : 0;
+    return {
+      rows: result,
+      rowCount
+    };
   }
   async _stream(connection, obj, stream, options) {
     if (!obj.sql) throw new Error("A query is required to stream results");
+    const optimizedFetchSize = options?.fetchSize || this.calculateOptimalFetchSize(obj.sql);
     return new Promise((resolve, reject) => {
-      stream.on("error", reject);
-      stream.on("end", resolve);
+      let isResolved = false;
+      const cleanup = () => {
+        if (!isResolved) {
+          isResolved = true;
+        }
+      };
+      stream.on("error", (err) => {
+        cleanup();
+        reject(err);
+      });
+      stream.on("end", () => {
+        cleanup();
+        resolve(void 0);
+      });
       connection.query(
         obj.sql,
         obj.bindings,
         {
           cursor: true,
-          fetchSize: options?.fetchSize || 1
+          fetchSize: optimizedFetchSize
         },
         (error, cursor) => {
           if (error) {
-            this.printError(JSON.stringify(error, null, 2));
+            this.printError(this.safeStringify(error, 2));
+            cleanup();
+            reject(error);
             return;
           }
           const readableStream = this._createCursorStream(cursor);
           readableStream.on("error", (err) => {
+            cleanup();
             reject(err);
-            stream.emit("error", err);
           });
           readableStream.pipe(stream);
         }
       );
     });
   }
+  calculateOptimalFetchSize(sql) {
+    const sqlLower = sql.toLowerCase();
+    const hasJoins = /\s+join\s+/i.test(sql);
+    const hasAggregates = /\s+(count|sum|avg|max|min)\s*\(/i.test(sql);
+    const hasOrderBy = /\s+order\s+by\s+/i.test(sql);
+    const hasGroupBy = /\s+group\s+by\s+/i.test(sql);
+    if (hasJoins || hasAggregates || hasOrderBy || hasGroupBy) {
+      return 500;
+    }
+    return 100;
+  }
   _createCursorStream(cursor) {
     const parentThis = this;
+    let isClosed = false;
     return new import_node_stream.Readable({
       objectMode: true,
       read() {
+        if (isClosed) return;
         cursor.fetch((error, result) => {
           if (error) {
-            parentThis.printError(JSON.stringify(error, null, 2));
+            parentThis.printError(parentThis.safeStringify(error, 2));
+            isClosed = true;
+            this.emit("error", error);
+            return;
           }
           if (!cursor.noData) {
             this.push(result);
           } else {
+            isClosed = true;
             cursor.close((closeError) => {
               if (closeError) {
                 parentThis.printError(JSON.stringify(closeError, null, 2));
@@ -514,6 +1231,21 @@ var DB2Client = class extends import_knex.knex.Client {
             });
           }
         });
+      },
+      destroy(err, callback) {
+        if (!isClosed) {
+          isClosed = true;
+          cursor.close((closeError) => {
+            if (closeError) {
+              parentThis.printDebug(
+                "Error closing cursor during destroy: " + parentThis.safeStringify(closeError)
+              );
+            }
+            callback(err);
+          });
+        } else {
+          callback(err);
+        }
       }
     });
   }
@@ -532,26 +1264,102 @@ var DB2Client = class extends import_knex.knex.Client {
   queryCompiler(builder, bindings) {
     return new ibmi_querycompiler_default(this, builder, bindings);
   }
+  // Create IBM i-specific migration runner that bypasses Knex's problematic locking system
+  createMigrationRunner(config) {
+    const knexInstance = this.context || this;
+    return createIBMiMigrationRunner(knexInstance, config);
+  }
   processResponse(obj, runner) {
     if (obj === null) return null;
-    const validationResult = this.validateResponse(obj);
-    if (validationResult !== null) return validationResult;
     const { response } = obj;
     if (obj.output) {
-      return obj.output(runner, response);
+      try {
+        const result = obj.output(runner, response);
+        return result;
+      } catch (error) {
+        const wrappedError = this.wrapError(error, "custom_output", obj);
+        this.printError(
+          `Custom output function failed: ${wrappedError.message}`
+        );
+        if (this.isConnectionError(error)) {
+          throw new Error(
+            "Connection closed during query processing - consider using migrations.disableTransactions: true for DDL operations"
+          );
+        }
+        throw wrappedError;
+      }
     }
+    const validationResult = this.validateResponse(obj);
+    if (validationResult !== null) return validationResult;
     return this.processSqlMethod(obj);
   }
   validateResponse(obj) {
     if (!obj.response) {
-      this.printDebug("response undefined" + obj);
-      return void 0;
+      this.printDebug("response undefined" + JSON.stringify(obj));
+      return null;
     }
     if (!obj.response.rows) {
-      return this.printError("rows undefined" + obj);
+      this.printError("rows undefined" + JSON.stringify(obj));
+      return null;
     }
     return null;
   }
+  wrapError(error, method, queryObject) {
+    const context = {
+      method,
+      sql: queryObject.sql ? queryObject.sql.substring(0, 100) + "..." : "unknown",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.isConnectionError(error)) {
+      return new Error(
+        `IBM i DB2 connection error during ${method}: ${error.message} | Context: ${JSON.stringify(context)}`
+      );
+    }
+    if (this.isTimeoutError(error)) {
+      return new Error(
+        `IBM i DB2 timeout during ${method}: ${error.message} | Context: ${JSON.stringify(context)}`
+      );
+    }
+    if (this.isSQLError(error)) {
+      return new Error(
+        `IBM i DB2 SQL error during ${method}: ${error.message} | Context: ${JSON.stringify(context)}`
+      );
+    }
+    return new Error(
+      `IBM i DB2 error during ${method}: ${error.message} | Context: ${JSON.stringify(context)}`
+    );
+  }
+  shouldRetryQuery(queryObject, method) {
+    return queryObject.sql?.toLowerCase().includes("systables") || queryObject.sql?.toLowerCase().includes("knex_migrations");
+  }
+  async retryQuery(connection, queryObject, method) {
+    this.printDebug(`Retrying ${method} query due to connection error...`);
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      if (this.isSelectMethod(method)) {
+        await this.executeSelectQuery(connection, queryObject);
+      } else {
+        await this.executeStatementQuery(connection, queryObject);
+      }
+      return queryObject;
+    } catch (retryError) {
+      this.printError(`Retry failed: ${retryError.message}`);
+      queryObject.response = { rows: [], rowCount: 0 };
+      return queryObject;
+    }
+  }
+  isConnectionError(error) {
+    const errorMessage = (error.message || error.toString || error).toLowerCase();
+    return errorMessage.includes("connection") && (errorMessage.includes("closed") || errorMessage.includes("invalid") || errorMessage.includes("terminated") || errorMessage.includes("not connected"));
+  }
+  isTimeoutError(error) {
+    const errorMessage = (error.message || error.toString || error).toLowerCase();
+    return errorMessage.includes("timeout") || errorMessage.includes("timed out");
+  }
+  isSQLError(error) {
+    const errorMessage = (error.message || error.toString || error).toLowerCase();
+    return errorMessage.includes("sql") || errorMessage.includes("syntax") || errorMessage.includes("table") || errorMessage.includes("column");
+  }
   processSqlMethod(obj) {
     const { rows, rowCount } = obj.response;
     switch (obj.sqlMethod) {
@@ -566,7 +1374,7 @@ var DB2Client = class extends import_knex.knex.Client {
       case "del" /* DELETE */:
       case "delete" /* DELETE_ALT */:
       case "update" /* UPDATE */:
-        return obj.select ? rows : rowCount;
+        return obj.select ? rows : rowCount ?? 0;
       case "counter" /* COUNTER */:
         return rowCount;
       default:
@@ -575,8 +1383,11 @@ var DB2Client = class extends import_knex.knex.Client {
   }
 };
 var DB2Dialect = DB2Client;
-var src_default = DB2Client;
+var index_default = DB2Client;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DB2Dialect
+  DB2Dialect,
+  IBMiMigrationRunner,
+  createIBMiMigrationRunner
 });
+//# sourceMappingURL=index.js.map