@bdkinc/knex-ibmi 0.3.21 → 0.4.0

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,7 +181,7 @@ 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" : "");
@@ -160,69 +190,124 @@ var IBMiColumnCompiler = class extends import_columncompiler.default {
 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 {
+  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 {
-        sql: sql + returningSql + this._emptyInsertValue,
-        returning
-      };
+      return "";
     }
-    sql += this._buildInsertData(insertValues, returningSql);
-    sql += ")";
-    return {
-      sql,
-      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}`,
+      this._buildInsertData(insertValues, returningSql)
+    ].filter(Boolean).join(" ");
+    const sql = `select ${selectColumns} from FINAL TABLE(${insertSql})`;
+    return { sql, returning };
+  }
+  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 (typeof insertData === "string") {
-      sql += insertData;
-    } else {
-      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 columnsSql = `(${this.formatter.columnize(insertData.columns)})`;
+      const valuesSql = `(${this._buildInsertValues(insertData)})`;
+      return `${columnsSql} ${returningSql}values ${valuesSql}`;
+    }
+    if (Array.isArray(insertValues) && insertValues.length === 1 && insertValues[0]) {
+      return returningSql + this._emptyInsertValue;
     }
-    return sql;
+    return "";
   }
   _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,
@@ -234,36 +319,23 @@ 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 allColumns = /* @__PURE__ */ new Set();
+    for (const item of dataArray) {
+      if (item != null) {
+        Object.keys(item).forEach((key) => allColumns.add(key));
       }
-      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];
+    }
+    const columns = Array.from(allColumns).sort();
+    const values = [];
+    for (const item of dataArray) {
+      if (item == null) {
+        break;
       }
+      const row = columns.map((column) => item[column] ?? void 0);
       values.push(row);
     }
     return {
@@ -278,16 +350,32 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
     const order = this.order();
     const limit = this.limit();
     const { returning } = this.single;
-    let sql = "";
-    if (returning) {
-      sql += `select ${this.formatter.columnize(this.single.returning)} from FINAL TABLE(`;
-    }
-    sql += withSQL + `update ${this.single.only ? "only " : ""}${this.tableName} set ` + updates.join(", ") + (where ? ` ${where}` : "") + (order ? ` ${order}` : "") + (limit ? ` ${limit}` : "");
+    const baseUpdateSql = [
+      withSQL,
+      `update ${this.single.only ? "only " : ""}${this.tableName}`,
+      "set",
+      updates.join(", "),
+      where,
+      order,
+      limit
+    ].filter(Boolean).join(" ");
     if (returning) {
-      sql += `)`;
-    }
-    return { sql, returning };
-  }
+      this.client.logger.warn?.(
+        "IBMi DB2 does not support returning in update statements, only inserts"
+      );
+      const selectColumns = this.formatter.columnize(this.single.returning);
+      const sql = `select ${selectColumns} from FINAL TABLE(${baseUpdateSql})`;
+      return { sql, returning };
+    }
+    return { sql: baseUpdateSql, returning };
+  }
+  /**
+   * 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":
@@ -297,6 +385,8 @@ var IBMiQueryCompiler = class extends import_querycompiler.default {
         return value ? `${withTrigger ? " into #out" : ""}` : "";
       case "rowcount":
         return value ? "select @@rowcount" : "";
+      default:
+        return "";
     }
   }
   columnizeWithPrefix(prefix, target) {
@@ -314,8 +404,210 @@ 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) {
+    console.log("\u{1F3AF} DB2Client constructor called!");
     super(config);
     this.driverName = "odbc";
     if (this.dialect && !this.config.client) {
@@ -343,10 +635,24 @@ 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.includes("KNEX_MIGRATIONS") || value.includes("knex_migrations")) {
+      return value.toUpperCase();
+    }
     return value;
   }
   printDebug(message) {
@@ -379,6 +685,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),
@@ -388,11 +695,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.
@@ -408,46 +717,148 @@ 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) {
-    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;
-    if (method === "select" || method === "first" || method === "pluck") {
-      const rows = await connection.query(obj.sql, obj.bindings);
-      if (rows) {
-        obj.response = { rows, rowCount: rows.length };
+    const queryObject = this.normalizeQueryObject(obj);
+    const method = this.determineQueryMethod(queryObject);
+    queryObject.sqlMethod = method;
+    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)}`);
       }
-    } else {
-      try {
-        const statement = await connection.createStatement();
-        await statement.prepare(obj.sql);
-        if (obj.bindings) {
-          await statement.bind(obj.bindings);
-        }
-        const result = await statement.execute();
-        this.printDebug(result);
-        if (result.statement.includes("IDENTITY_VAL_LOCAL()")) {
-          obj.response = {
-            rows: result.map(
-              (row) => result.columns && result.columns?.length > 0 ? row[result.columns[0].name] : row
-            ),
-            rowCount: result.count
-          };
-        } else {
-          obj.response = { rows: result, rowCount: result.count };
+    }
+    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) {
+      if (this.isConnectionError(error)) {
+        this.printError(
+          `Connection error during ${method} query: ${error.message}`
+        );
+        if (queryObject.sql?.toLowerCase().includes("systables")) {
+          this.printDebug("Retrying hasTable 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;
+          }
         }
-      } catch (err) {
-        this.printError(JSON.stringify(err));
+        throw new Error(
+          `Connection closed during ${method} operation - IBM i DB2 DDL operations cause implicit commits`
+        );
       }
+      throw error;
+    }
+  }
+  normalizeQueryObject(obj) {
+    if (!obj || typeof obj === "string") {
+      return { sql: obj };
     }
-    this.printDebug(obj);
     return obj;
   }
+  determineQueryMethod(obj) {
+    return (obj.hasOwnProperty("method") && obj.method !== "raw" ? obj.method : obj.sql.split(" ")[0]).toLowerCase();
+  }
+  isSelectMethod(method) {
+    return method === "select" || method === "first" || method === "pluck";
+  }
+  async executeSelectQuery(connection, obj) {
+    const rows = await connection.query(
+      obj.sql,
+      obj.bindings
+    );
+    if (rows) {
+      obj.response = { rows, rowCount: rows.length };
+    }
+  }
+  async executeStatementQuery(connection, obj) {
+    let statement;
+    try {
+      statement = await connection.createStatement();
+      await statement.prepare(obj.sql);
+      if (obj.bindings) {
+        await statement.bind(obj.bindings);
+      }
+      const result = await statement.execute();
+      this.printDebug(String(result));
+      obj.response = this.formatStatementResponse(result);
+    } catch (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) {
+    const isIdentityQuery = result.statement?.includes("IDENTITY_VAL_LOCAL()");
+    if (isIdentityQuery && result.columns?.length > 0) {
+      return {
+        rows: result.map(
+          (row) => row[result.columns[0].name]
+        ),
+        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");
     return new Promise((resolve, reject) => {
@@ -462,30 +873,12 @@ var DB2Client = class extends import_knex.knex.Client {
         },
         (error, cursor) => {
           if (error) {
-            this.printError(JSON.stringify(error, null, 2));
+            this.printError(this.safeStringify(error, 2));
+            stream.emit("error", error);
+            reject(error);
+            return;
           }
-          const readableStream = new import_node_stream.Readable({
-            objectMode: true,
-            read() {
-              cursor.fetch((error2, result) => {
-                if (error2) {
-                  console.log(JSON.stringify(error2, null, 2));
-                }
-                if (!cursor.noData) {
-                  this.push(result);
-                } else {
-                  cursor.close((error3) => {
-                    if (error3) {
-                      console.log(JSON.stringify(error3, null, 2));
-                    }
-                    if (result) {
-                      this.push(result);
-                    }
-                  });
-                }
-              });
-            }
-          });
+          const readableStream = this._createCursorStream(cursor);
           readableStream.on("error", (err) => {
             reject(err);
             stream.emit("error", err);
@@ -495,6 +888,32 @@ var DB2Client = class extends import_knex.knex.Client {
       );
     });
   }
+  _createCursorStream(cursor) {
+    const parentThis = this;
+    return new import_node_stream.Readable({
+      objectMode: true,
+      read() {
+        cursor.fetch((error, result) => {
+          if (error) {
+            parentThis.printError(parentThis.safeStringify(error, 2));
+          }
+          if (!cursor.noData) {
+            this.push(result);
+          } else {
+            cursor.close((closeError) => {
+              if (closeError) {
+                parentThis.printError(JSON.stringify(closeError, null, 2));
+              }
+              if (result) {
+                this.push(result);
+              }
+              this.push(null);
+            });
+          }
+        });
+      }
+    });
+  }
   transaction(container, config, outerTx) {
     return new ibmi_transaction_default(this, container, config, outerTx);
   }
@@ -510,32 +929,65 @@ 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 resp = obj.response;
-    const method = obj.sqlMethod;
-    if (!resp) {
-      this.printDebug("response undefined" + obj);
+    const { response } = obj;
+    if (obj.output) {
+      try {
+        const result = obj.output(runner, response);
+        return result;
+      } catch (error) {
+        this.printError(
+          `Custom output function failed: ${error.message || error}`
+        );
+        if (this.isConnectionError(error)) {
+          throw new Error(
+            "Connection closed during query processing - consider using migrations.disableTransactions: true for DDL operations"
+          );
+        }
+        throw error;
+      }
     }
-    const { rows, rowCount } = resp;
-    if (obj.output) return obj.output.call(runner, resp);
-    switch (method) {
-      case "select":
+    const validationResult = this.validateResponse(obj);
+    if (validationResult !== null) return validationResult;
+    return this.processSqlMethod(obj);
+  }
+  validateResponse(obj) {
+    if (!obj.response) {
+      this.printDebug("response undefined" + JSON.stringify(obj));
+      return null;
+    }
+    if (!obj.response.rows) {
+      this.printError("rows undefined" + JSON.stringify(obj));
+      return null;
+    }
+    return null;
+  }
+  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"));
+  }
+  processSqlMethod(obj) {
+    const { rows, rowCount } = obj.response;
+    switch (obj.sqlMethod) {
+      case "select" /* SELECT */:
         return rows;
-      case "pluck":
+      case "pluck" /* PLUCK */:
         return rows.map(obj.pluck);
-      case "first":
+      case "first" /* FIRST */:
         return rows[0];
-      case "insert":
+      case "insert" /* INSERT */:
         return rows;
-      case "del":
-      case "delete":
-      case "update":
-        if (obj.select) {
-          return rows;
-        }
-        return rowCount;
-      case "counter":
+      case "del" /* DELETE */:
+      case "delete" /* DELETE_ALT */:
+      case "update" /* UPDATE */:
+        return obj.select ? rows : rowCount ?? 0;
+      case "counter" /* COUNTER */:
         return rowCount;
       default:
         return rows;
@@ -543,8 +995,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