@bdkinc/knex-ibmi 0.3.21 → 0.4.0

package/dist/index.mjs

@@ -0,0 +1,971 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+import process from "process";
+import knex from "knex";
+import odbc from "odbc";
+
+// src/schema/ibmi-compiler.ts
+import SchemaCompiler from "knex/lib/schema/compiler.js";
+var IBMiSchemaCompiler = class extends SchemaCompiler {
+  hasTable(tableName) {
+    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: (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;
+      }
+    });
+  }
+  toSQL() {
+    const sequence = this.builder._sequence;
+    for (let i = 0, l = sequence.length; i < l; i++) {
+      const query = sequence[i];
+      this[query.method].apply(this, query.args);
+    }
+    return this.sequence;
+  }
+};
+var ibmi_compiler_default = IBMiSchemaCompiler;
+
+// src/schema/ibmi-tablecompiler.ts
+import TableCompiler from "knex/lib/schema/tablecompiler.js";
+var IBMiTableCompiler = class extends TableCompiler {
+  createQuery(columns, ifNot, like) {
+    let createStatement = ifNot ? `if object_id('${this.tableName()}', 'U') is null ` : "";
+    if (like) {
+      createStatement += `select * into ${this.tableName()} from ${this.tableNameLike()} WHERE 0=1`;
+    } else {
+      createStatement += "create table " + this.tableName() + (this._formatting ? " (\n    " : " (") + columns.sql.join(this._formatting ? ",\n    " : ", ") + this._addChecks() + ")";
+    }
+    this.pushQuery(createStatement);
+    if (this.single.comment) {
+      this.comment(this.single.comment);
+    }
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
+  }
+  dropUnique(columns, indexName) {
+    indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
+    this.pushQuery(`drop index ${indexName}`);
+  }
+  unique(columns, indexName) {
+    let deferrable = "";
+    let predicate;
+    let finalIndexName;
+    if (typeof indexName === "object" && indexName !== null) {
+      deferrable = indexName.deferrable || "";
+      predicate = indexName.predicate;
+      finalIndexName = indexName.indexName;
+    } else {
+      finalIndexName = indexName;
+    }
+    if (deferrable && deferrable !== "not deferrable") {
+      this.client.logger.warn?.(
+        `IBMi: unique index \`${finalIndexName}\` will not be deferrable ${deferrable}.`
+      );
+    }
+    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 ${wrappedIndexName} on ${this.tableName()} (${columns})${predicateQuery}`
+    );
+  }
+  // All of the columns to "add" for the query
+  addColumns(columns, prefix) {
+    prefix = prefix || this.addColumnsPrefix;
+    if (columns.sql.length > 0) {
+      const columnSql = columns.sql.map((column) => {
+        return prefix + column;
+      });
+      this.pushQuery({
+        sql: (this.lowerCase ? "alter table " : "ALTER TABLE ") + this.tableName() + " " + columnSql.join(" "),
+        bindings: columns.bindings
+      });
+    }
+  }
+  async commit(connection) {
+    return await connection.commit();
+  }
+};
+var ibmi_tablecompiler_default = IBMiTableCompiler;
+
+// src/schema/ibmi-columncompiler.ts
+import ColumnCompiler from "knex/lib/schema/columncompiler.js";
+var IBMiColumnCompiler = class extends ColumnCompiler {
+  increments(options = { primaryKey: true }) {
+    return "int not null generated always as identity (start with 1, increment by 1)" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
+  }
+};
+var ibmi_columncompiler_default = IBMiColumnCompiler;
+
+// src/execution/ibmi-transaction.ts
+import Transaction from "knex/lib/execution/transaction.js";
+var IBMiTransaction = class extends Transaction {
+  begin(connection) {
+    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) {
+    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) {
+    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
+import QueryCompiler from "knex/lib/query/querycompiler.js";
+import { rawOrFn as rawOrFn_ } from "knex/lib/formatter/wrappingFormatter.js";
+var IBMiQueryCompiler = class extends QueryCompiler {
+  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 || [];
+    const { returning } = this.single;
+    if (this.isEmptyInsertValues(insertValues)) {
+      if (this.isEmptyObject(insertValues)) {
+        return this.buildEmptyInsertResult(returning);
+      }
+      return "";
+    }
+    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) {
+    const insertData = this._prepInsert(insertValues);
+    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 "";
+  }
+  _prepInsert(data) {
+    if (typeof data === "object" && data?.migration_time) {
+      const parsed = new Date(data.migration_time);
+      if (!isNaN(parsed.getTime())) {
+        data.migration_time = this.formatTimestampLocal(parsed);
+      }
+    }
+    const isRaw = rawOrFn_(
+      data,
+      void 0,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    );
+    if (isRaw) {
+      return isRaw;
+    }
+    const dataArray = Array.isArray(data) ? data : data ? [data] : [];
+    if (dataArray.length === 0) {
+      return { columns: [], values: [] };
+    }
+    const allColumns = /* @__PURE__ */ new Set();
+    for (const item of dataArray) {
+      if (item != null) {
+        Object.keys(item).forEach((key) => allColumns.add(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 {
+      columns,
+      values
+    };
+  }
+  update() {
+    const withSQL = this.with();
+    const updates = this._prepUpdate(this.single.update);
+    const where = this.where();
+    const order = this.order();
+    const limit = this.limit();
+    const { returning } = this.single;
+    const baseUpdateSql = [
+      withSQL,
+      `update ${this.single.only ? "only " : ""}${this.tableName}`,
+      "set",
+      updates.join(", "),
+      where,
+      order,
+      limit
+    ].filter(Boolean).join(" ");
+    if (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":
+      case "insert":
+        return value ? `${withTrigger ? " into #out" : ""}` : "";
+      case "del":
+        return value ? `${withTrigger ? " into #out" : ""}` : "";
+      case "rowcount":
+        return value ? "select @@rowcount" : "";
+      default:
+        return "";
+    }
+  }
+  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]);
+    }
+    return str;
+  }
+};
+var ibmi_querycompiler_default = IBMiQueryCompiler;
+
+// src/index.ts
+import { Readable } from "stream";
+
+// src/migrations/ibmi-migration-runner.ts
+import fs from "fs";
+import path from "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 (!fs.existsSync(directory)) {
+      throw new Error(`Migration directory does not exist: ${directory}`);
+    }
+    const validExtensions = ["js", "ts", "mjs", "cjs"];
+    const extensionToCheck = extension || "js";
+    return fs.readdirSync(directory).filter((file) => {
+      if (extension && extension !== "js") {
+        return file.endsWith(`.${extension}`);
+      }
+      return validExtensions.some((ext) => file.endsWith(`.${ext}`));
+    }).sort();
+  }
+  getMigrationPath(filename) {
+    return path.resolve(this.config.directory, filename);
+  }
+};
+function createIBMiMigrationRunner(knex2, config) {
+  return new IBMiMigrationRunner(knex2, config);
+}
+
+// src/index.ts
+var DB2Client = class extends knex.Client {
+  constructor(config) {
+    console.log("\u{1F3AF} DB2Client constructor called!");
+    super(config);
+    this.driverName = "odbc";
+    if (this.dialect && !this.config.client) {
+      this.printWarn(
+        `Using 'this.dialect' to identify the client is deprecated and support for it will be removed in the future. Please use configuration option 'client' instead.`
+      );
+    }
+    const dbClient = this.config.client || this.dialect;
+    if (!dbClient) {
+      throw new Error(
+        `knex: Required configuration option 'client' is missing.`
+      );
+    }
+    if (config.version) {
+      this.version = config.version;
+    }
+    if (this.driverName && config.connection) {
+      this.initializeDriver();
+      if (!config.pool || config.pool && config.pool.max !== 0) {
+        this.initializePool(config);
+      }
+    }
+    this.valueForUndefined = this.raw("DEFAULT");
+    if (config.useNullAsDefault) {
+      this.valueForUndefined = null;
+    }
+  }
+  // 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 odbc;
+  }
+  wrapIdentifierImpl(value) {
+    if (value.includes("KNEX_MIGRATIONS") || value.includes("knex_migrations")) {
+      return value.toUpperCase();
+    }
+    return value;
+  }
+  printDebug(message) {
+    if (process.env.DEBUG === "true") {
+      if (this.logger.debug) {
+        this.logger.debug("knex-ibmi: " + message);
+      }
+    }
+  }
+  printError(message) {
+    if (this.logger.error) {
+      this.logger.error("knex-ibmi: " + message);
+    }
+  }
+  printWarn(message) {
+    if (process.env.DEBUG === "true") {
+      if (this.logger.warn) {
+        this.logger.warn("knex-ibmi: " + message);
+      }
+    }
+  }
+  // Get a raw connection, called by the pool manager whenever a new
+  // connection needs to be added to the pool.
+  async acquireRawConnection() {
+    this.printDebug("acquiring raw connection");
+    const connectionConfig = this.config.connection;
+    if (!connectionConfig) {
+      return this.printError("There is no connection config defined");
+    }
+    this.printDebug(
+      "connection config: " + this._getConnectionString(connectionConfig)
+    );
+    let connection;
+    if (this.config?.pool) {
+      const poolConfig = {
+        connectionString: this._getConnectionString(connectionConfig),
+        connectionTimeout: this.config?.acquireConnectionTimeout || 6e4,
+        initialSize: this.config?.pool?.min || 2,
+        maxSize: this.config?.pool?.max || 10,
+        reuseConnection: true
+      };
+      const pool = await this.driver.pool(poolConfig);
+      connection = await pool.connect();
+    } else {
+      connection = 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.
+  async destroyRawConnection(connection) {
+    this.printDebug("destroy connection");
+    return await connection.close();
+  }
+  _getConnectionString(connectionConfig) {
+    const connectionStringParams = connectionConfig.connectionStringParams || {};
+    const connectionStringExtension = Object.keys(
+      connectionStringParams
+    ).reduce((result, key) => {
+      const value = connectionStringParams[key];
+      return `${result}${key}=${value};`;
+    }, "");
+    return `DRIVER=${connectionConfig.driver};SYSTEM=${connectionConfig.host};HOSTNAME=${connectionConfig.host};PORT=${connectionConfig.port};DATABASE=${connectionConfig.database};UID=${connectionConfig.user};PWD=${connectionConfig.password};` + connectionStringExtension;
+  }
+  // Runs the query on the specified connection, providing the bindings
+  async _query(connection, obj) {
+    const queryObject = this.normalizeQueryObject(obj);
+    const method = this.determineQueryMethod(queryObject);
+    queryObject.sqlMethod = method;
+    if (process.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 (process.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;
+          }
+        }
+        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 };
+    }
+    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) => {
+      stream.on("error", reject);
+      stream.on("end", resolve);
+      connection.query(
+        obj.sql,
+        obj.bindings,
+        {
+          cursor: true,
+          fetchSize: options?.fetchSize || 1
+        },
+        (error, cursor) => {
+          if (error) {
+            this.printError(this.safeStringify(error, 2));
+            stream.emit("error", error);
+            reject(error);
+            return;
+          }
+          const readableStream = this._createCursorStream(cursor);
+          readableStream.on("error", (err) => {
+            reject(err);
+            stream.emit("error", err);
+          });
+          readableStream.pipe(stream);
+        }
+      );
+    });
+  }
+  _createCursorStream(cursor) {
+    const parentThis = this;
+    return new 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);
+  }
+  schemaCompiler(tableBuilder) {
+    return new ibmi_compiler_default(this, tableBuilder);
+  }
+  tableCompiler(tableBuilder) {
+    return new ibmi_tablecompiler_default(this, tableBuilder);
+  }
+  columnCompiler(tableCompiler, columnCompiler) {
+    return new ibmi_columncompiler_default(this, tableCompiler, columnCompiler);
+  }
+  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 { 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 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" /* PLUCK */:
+        return rows.map(obj.pluck);
+      case "first" /* FIRST */:
+        return rows[0];
+      case "insert" /* INSERT */:
+        return rows;
+      case "del" /* DELETE */:
+      case "delete" /* DELETE_ALT */:
+      case "update" /* UPDATE */:
+        return obj.select ? rows : rowCount ?? 0;
+      case "counter" /* COUNTER */:
+        return rowCount;
+      default:
+        return rows;
+    }
+  }
+};
+var DB2Dialect = DB2Client;
+var index_default = DB2Client;
+export {
+  DB2Dialect,
+  IBMiMigrationRunner,
+  createIBMiMigrationRunner,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map