knex 3.2.9 → 3.3.0

package/lib/dialects/mysql/query/mysql-querycompiler.js

@@ -17,16 +17,10 @@ const isPlainObjectOrArray = (value) =>
 class QueryCompiler_MySQL extends QueryCompiler {
   constructor(client, builder, formatter) {
     super(client, builder, formatter);
-
-    const { returning } = this.single;
-    if (returning) {
-      this.client.logger.warn(
-        '.returning() is not supported by mysql and will not have any effect.'
-      );
-    }
-
+    this._returningCheck();
     this._emptyInsertValue = '() values ()';
   }
+
   // Compiles a `delete` query, allowing comments and LIMIT.
   del() {
     const sql = super.del();
@@ -288,6 +282,15 @@ class QueryCompiler_MySQL extends QueryCompiler {
   onJsonPathEquals(clause) {
     return this._onJsonPathEquals('json_extract', clause);
   }
+
+  _returningCheck() {
+    const { returning } = this.single;
+    if (returning) {
+      this.client.logger.warn(
+        '.returning() is not supported by mysql and will not have any effect.'
+      );
+    }
+  }
 }
 
 // MySQL supports LIMIT on single-table DELETE statements.

package/lib/dialects/mysql2/index.js

@@ -34,6 +34,13 @@ class Client_MySQL2 extends Client_MySQL {
     }
   }
 
+  // Support both mysql2.createPool() and mysql2/promise.createPool().
+  // The promise variant wraps a callback pool and exposes it as .pool.
+  wrapNativePool(nativePool) {
+    const callbackPool = nativePool.pool || nativePool;
+    return super.wrapNativePool(callbackPool);
+  }
+
   validateConnection(connection) {
     return (
       connection &&

package/lib/dialects/oracledb/index.js

@@ -4,6 +4,7 @@ const each = require('lodash/each');
 const flatten = require('lodash/flatten');
 const isEmpty = require('lodash/isEmpty');
 const map = require('lodash/map');
+const uniqueId = require('lodash/uniqueId');
 
 const Formatter = require('../../formatter');
 const QueryCompiler = require('./query/oracledb-querycompiler');
@@ -165,8 +166,51 @@ class Client_Oracledb extends Client_Oracle {
 
   // Used to explicitly close a connection, called internally by the pool
   // when a connection times out or the pool is shutdown.
+  /**
+   * @param {import('oracledb').Connection} connection
+   */
   destroyRawConnection(connection) {
-    return connection.release();
+    return connection.release({ drop: true });
+  }
+
+  // Wraps a native oracledb pool with the interface knex expects from this.pool.
+  /**
+   * @param {import('oracledb').Pool} nativePool
+   */
+  wrapNativePool(nativePool) {
+    const client = this;
+    return {
+      acquire() {
+        return {
+          promise: nativePool.getConnection().then((connection) => {
+            connection.__knexUid = uniqueId('__knexUid');
+            monkeyPatchConnection(connection, client);
+            return connection;
+          }),
+        };
+      },
+      /**
+       * @param {import('oracledb').Connection} connection
+       */
+      release(connection) {
+        // connection.close() returns the connection to the native pool
+        // (or closes it if standalone). Works for both healthy and disposed connections.
+        if (typeof connection.close === 'function') {
+          const opts = connection.__knex__disposed ? { drop: true } : {};
+          connection.close(opts, (err) => {
+            if (err) {
+              console.error(`Error closing oracle connection`, err);
+            }
+          });
+          return true;
+        }
+        return false;
+      },
+      destroy() {
+        // No-op: knex does not own the native pool
+        return Promise.resolve();
+      },
+    };
   }
 
   // Handle oracle version resolution on acquiring connection from pool instead of connection creation.

package/lib/dialects/postgres/index.js

@@ -2,6 +2,7 @@
 // -------
 const extend = require('lodash/extend');
 const map = require('lodash/map');
+const uniqueId = require('lodash/uniqueId');
 const { promisify } = require('util');
 const Client = require('../../client');
 
@@ -120,6 +121,41 @@ class Client_PG extends Client {
     return end();
   }
 
+  // Wraps a native pg.Pool with the interface knex expects from this.pool.
+  wrapNativePool(nativePool) {
+    const client = this;
+    return {
+      acquire() {
+        return {
+          promise: nativePool.connect().then(async (connection) => {
+            connection.__knexUid = uniqueId('__knexUid');
+            if (!client.version) {
+              try {
+                client.version = await client.checkVersion(connection);
+              } catch (_e) {
+                // version check is best-effort
+              }
+            }
+            return connection;
+          }),
+        };
+      },
+      release(connection) {
+        if (typeof connection.release === 'function') {
+          // pg: release(true) destroys the connection instead of returning to pool
+          const shouldDestroy = !!connection.__knex__disposed;
+          connection.release(shouldDestroy);
+          return true;
+        }
+        return false;
+      },
+      destroy() {
+        // No-op: knex does not own the native pool
+        return Promise.resolve();
+      },
+    };
+  }
+
   // In PostgreSQL, we need to do a version check to do some feature
   // checking on the database.
   checkVersion(connection) {

package/lib/dialects/postgres/query/pg-querycompiler.js

@@ -49,14 +49,15 @@ class QueryCompiler_PG extends QueryCompiler {
   update() {
     const withSQL = this.with();
     const updateData = this._prepUpdate(this.single.update);
-    const wheres = this.where();
     const { returning, updateFrom } = this.single;
+    const updateFromSQL = this._updateFrom(updateFrom);
+    const wheres = this.where();
     return {
       sql:
         withSQL +
         `update ${this.single.only ? 'only ' : ''}${this.tableName} ` +
         `set ${updateData.join(', ')}` +
-        this._updateFrom(updateFrom) +
+        updateFromSQL +
         (wheres ? ` ${wheres}` : '') +
         this._returning(returning),
       returning,
@@ -84,11 +85,11 @@ class QueryCompiler_PG extends QueryCompiler {
     // Make sure tableName is processed by the formatter first.
     const { tableName } = this;
     const withSQL = this.with();
-    let wheres = this.where() || '';
     let using = this.using() || '';
     const joins = this.grouped.join;
 
     const tableJoins = [];
+    const joinWhereStatements = [];
     if (Array.isArray(joins)) {
       for (const join of joins) {
         tableJoins.push(
@@ -101,19 +102,13 @@ class QueryCompiler_PG extends QueryCompiler {
           )
         );
 
-        const joinWheres = [];
         for (const clause of join.clauses) {
-          joinWheres.push(
-            this.whereBasic({
-              column: clause.column,
-              operator: '=',
-              value: clause.value,
-              asColumn: true,
-            })
-          );
-        }
-        if (joinWheres.length > 0) {
-          wheres += (wheres ? ' and ' : 'where ') + joinWheres.join(' and ');
+          joinWhereStatements.push({
+            column: clause.column,
+            operator: '=',
+            value: clause.value,
+            asColumn: true,
+          });
         }
       }
       if (tableJoins.length > 0) {
@@ -121,6 +116,16 @@ class QueryCompiler_PG extends QueryCompiler {
       }
     }
 
+    // Delete joins are rewritten into USING plus WHERE, so defer join predicates
+    // until after this.where() to keep bindings aligned with SQL placeholder order.
+    let wheres = this.where() || '';
+    const joinWhereClauses = joinWhereStatements.map((joinWhere) =>
+      this.whereBasic(joinWhere)
+    );
+    if (joinWhereClauses.length > 0) {
+      wheres += (wheres ? ' and ' : 'where ') + joinWhereClauses.join(' and ');
+    }
+
     // With 'using' syntax, no tablename between DELETE and FROM.
     const sql =
       withSQL +
@@ -197,29 +202,19 @@ class QueryCompiler_PG extends QueryCompiler {
     }
   }
 
-  // Join array of table names and apply default schema.
-  _tableNames(tables) {
-    const schemaName = this.single.schema;
-    const sql = [];
-
-    for (let i = 0; i < tables.length; i++) {
-      let tableName = tables[i];
-
-      if (tableName) {
-        if (schemaName) {
-          tableName = `${schemaName}.${tableName}`;
-        }
-        sql.push(this.formatter.wrap(tableName));
-      }
-    }
-
-    return sql.join(', ');
-  }
-
   _lockingClause(lockMode) {
     const tables = this.single.lockTables || [];
 
-    return lockMode + (tables.length ? ' of ' + this._tableNames(tables) : '');
+    return (
+      lockMode +
+      (tables.length
+        ? ' of ' +
+          tables
+            .filter(Boolean)
+            .map((table) => this.formatter.wrap(table))
+            .join(', ')
+        : '')
+    );
   }
 
   _groupOrder(item, type) {

package/lib/dialects/sqlite3/query/sqlite-querycompiler.js

@@ -140,6 +140,8 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
     else if (onConflict && merge) {
       sql +=
         ' where true' + this._merge(merge.updates, onConflict, insertValues);
+      const wheres = this.where();
+      if (wheres) sql += ` ${wheres}`;
     }
 
     const { returning } = this.single;

package/lib/execution/runner.js

@@ -65,11 +65,17 @@ class Runner {
     const stream = new Transform({
       objectMode: true,
       transform: (chunk, _, callback) => {
-        callback(null, this.client.postProcessResponse(chunk, queryContext));
+        try {
+          callback(null, this.client.postProcessResponse(chunk, queryContext));
+        } catch (err) {
+          callback(err);
+        }
       },
     });
     stream.on('close', () => {
-      this.client.releaseConnection(this.connection);
+      if (this.connection) {
+        this.client.releaseConnection(this.connection);
+      }
     });
 
     // If the stream is manually destroyed, the close event is not

package/lib/formatter/wrappingFormatter.js

@@ -67,7 +67,11 @@ const operators = transform(
 
 // Accepts a string or array of columns to wrap as appropriate. Column can be raw
 function columnize(target, builder, client, bindingHolder) {
-  const columns = Array.isArray(target) ? target : [target];
+  if (!Array.isArray(target)) {
+    return wrap(target, undefined, builder, client, bindingHolder);
+  }
+
+  const columns = target;
   let str = '',
     i = -1;
   while (++i < columns.length) {
@@ -137,9 +141,27 @@ function operator(value, builder, client, bindingsHolder) {
   return operator;
 }
 
+// Find a case-insensitive " as " without allocating a lowercased string.
+// ASCII uppercase letters differ from lowercase by bit 0x20, so `| 32`
+// folds A/S to a/s before comparing to 97 ("a") and 115 ("s").
+function getAliasSeparatorIndex(value) {
+  let i = -1;
+  while ((i = value.indexOf(' ', i + 1)) !== -1) {
+    if (
+      i + 3 < value.length &&
+      (value.charCodeAt(i + 1) | 32) === 97 &&
+      (value.charCodeAt(i + 2) | 32) === 115 &&
+      value.charCodeAt(i + 3) === 32
+    ) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 // Coerce to string to prevent strange errors when it's not a string.
 function wrapString(value, builder, client) {
-  const asIndex = value.toLowerCase().indexOf(' as ');
+  const asIndex = getAliasSeparatorIndex(value);
   if (asIndex !== -1) {
     const first = value.slice(0, asIndex);
     const second = value.slice(asIndex + 4);
@@ -148,18 +170,34 @@ function wrapString(value, builder, client) {
       wrapAsIdentifier(second, builder, client)
     );
   }
-  const wrapped = [];
-  let i = -1;
-  const segments = value.split('.');
-  while (++i < segments.length) {
-    value = segments[i];
-    if (i === 0 && segments.length > 1) {
-      wrapped.push(wrapString((value || '').trim(), builder, client));
-    } else {
-      wrapped.push(wrapAsIdentifier(value, builder, client));
-    }
+
+  let segmentStart = 0;
+  let dotIndex = value.indexOf('.');
+
+  if (dotIndex === -1) {
+    return wrapAsIdentifier(value, builder, client);
   }
-  return wrapped.join('.');
+
+  let wrapped = '';
+  let i = 0;
+
+  while (dotIndex !== -1) {
+    const segment = value.slice(segmentStart, dotIndex);
+    if (i > 0) wrapped += '.';
+    wrapped +=
+      i === 0
+        ? wrapString((segment || '').trim(), builder, client)
+        : wrapAsIdentifier(segment, builder, client);
+    segmentStart = dotIndex + 1;
+    dotIndex = value.indexOf('.', segmentStart);
+    i++;
+  }
+
+  return `${wrapped}.${wrapAsIdentifier(
+    value.slice(segmentStart),
+    builder,
+    client
+  )}`;
 }
 
 // Key-value notation for alias
@@ -246,6 +284,7 @@ module.exports = {
   direction,
   operator,
   outputQuery,
+  getAliasSeparatorIndex,
   rawOrFn,
   unwrapRaw,
   wrap,

package/lib/knex-builder/FunctionHelper.js

@@ -32,6 +32,7 @@ class FunctionHelper {
         return this.client.raw('(random_uuid())');
       case 'mysql':
       case 'mysql2':
+      case 'mariadb':
         return this.client.raw('(UUID())');
       default:
         throw new Error(

package/lib/knex-builder/Knex.js

@@ -4,6 +4,7 @@ const QueryInterface = require('../query/method-constants');
 
 const makeKnex = require('./make-knex');
 const { KnexTimeoutError } = require('../util/timeout');
+const { KnexPool } = require('../pool');
 const { resolveConfig } = require('./internal/config-resolver');
 const SchemaBuilder = require('../schema/builder');
 const ViewBuilder = require('../schema/viewbuilder');
@@ -24,6 +25,7 @@ function knex(config) {
 knex.Client = Client;
 
 knex.KnexTimeoutError = KnexTimeoutError;
+knex.KnexPool = KnexPool;
 
 knex.QueryBuilder = {
   extend: function (methodName, fn) {

package/lib/knex-builder/internal/config-resolver.js

@@ -37,6 +37,13 @@ function resolveConfig(config) {
     Dialect = getDialectByNameOrAlias(clientName);
   }
 
+  // connectionPool and connection are mutually exclusive
+  if (parsedConfig.connectionPool && parsedConfig.connection) {
+    throw new Error(
+      `knex: 'connectionPool' and 'connection' are mutually exclusive. Use one or the other.`
+    );
+  }
+
   // If config connection parameter is passed as string, try to parse it
   if (typeof parsedConfig.connection === 'string') {
     resolvedConfig = Object.assign({}, parsedConfig, {

package/lib/migrations/migrate/Migrator.js

@@ -245,6 +245,136 @@ class Migrator {
       });
   }
 
+  // Migrate up to a specific migration (inclusive).
+  // Runs all pending migrations up to and including the specified one.
+  async to(config) {
+    this._disableProcessing();
+    this.config = getMergedConfig(config, this.config, this.knex.client.logger);
+
+    const name = this.config.name;
+    if (!name) {
+      throw new Error(
+        'A migration name must be specified when using migrate.to()'
+      );
+    }
+
+    const allAndCompleted = await migrationListResolver.listAllAndCompleted(
+      this.config,
+      this.knex
+    );
+
+    if (!this.config.disableMigrationsListValidation) {
+      validateMigrationList(this.config.migrationSource, allAndCompleted);
+    }
+
+    const [all, completed] = allAndCompleted;
+
+    const targetIndex = all.findIndex(
+      (migration) =>
+        this.config.migrationSource.getMigrationName(migration) === name
+    );
+
+    if (targetIndex === -1) {
+      throw new Error(`Migration "${name}" not found.`);
+    }
+
+    const completedNames = completed.map((m) => m.name);
+
+    const migrationsToRun = all
+      .slice(0, targetIndex + 1)
+      .filter((migration) => {
+        return !completedNames.includes(
+          this.config.migrationSource.getMigrationName(migration)
+        );
+      });
+
+    const transactionForAll =
+      !this.config.disableTransactions &&
+      !(
+        await Promise.all(
+          migrationsToRun.map(async (migration) => {
+            const migrationContents =
+              await this.config.migrationSource.getMigration(migration);
+            return !this._useTransaction(migrationContents);
+          })
+        )
+      ).some((isTransactionUsed) => isTransactionUsed);
+
+    if (transactionForAll) {
+      return this.knex.transaction((trx) => {
+        return this._runBatch(migrationsToRun, 'up', trx);
+      });
+    } else {
+      return this._runBatch(migrationsToRun, 'up');
+    }
+  }
+
+  // Migrate up to just before a specific migration (exclusive).
+  // Runs all pending migrations before the specified one.
+  async before(config) {
+    this._disableProcessing();
+    this.config = getMergedConfig(config, this.config, this.knex.client.logger);
+
+    const name = this.config.name;
+    if (!name) {
+      throw new Error(
+        'A migration name must be specified when using migrate.before()'
+      );
+    }
+
+    const allAndCompleted = await migrationListResolver.listAllAndCompleted(
+      this.config,
+      this.knex
+    );
+
+    if (!this.config.disableMigrationsListValidation) {
+      validateMigrationList(this.config.migrationSource, allAndCompleted);
+    }
+
+    const [all, completed] = allAndCompleted;
+
+    const targetIndex = all.findIndex(
+      (migration) =>
+        this.config.migrationSource.getMigrationName(migration) === name
+    );
+
+    if (targetIndex === -1) {
+      throw new Error(`Migration "${name}" not found.`);
+    }
+
+    if (targetIndex === 0) {
+      return [0, []];
+    }
+
+    const completedNames = completed.map((m) => m.name);
+
+    const migrationsToRun = all.slice(0, targetIndex).filter((migration) => {
+      return !completedNames.includes(
+        this.config.migrationSource.getMigrationName(migration)
+      );
+    });
+
+    const transactionForAll =
+      !this.config.disableTransactions &&
+      !(
+        await Promise.all(
+          migrationsToRun.map(async (migration) => {
+            const migrationContents =
+              await this.config.migrationSource.getMigration(migration);
+            return !this._useTransaction(migrationContents);
+          })
+        )
+      ).some((isTransactionUsed) => isTransactionUsed);
+
+    if (transactionForAll) {
+      return this.knex.transaction((trx) => {
+        return this._runBatch(migrationsToRun, 'up', trx);
+      });
+    } else {
+      return this._runBatch(migrationsToRun, 'up');
+    }
+  }
+
   status(config) {
     this._disableProcessing();
     this.config = getMergedConfig(config, this.config, this.knex.client.logger);

package/lib/pool.js

@@ -0,0 +1,24 @@
+const { Pool } = require('tarn');
+
+class KnexPool extends Pool {
+  constructor(config) {
+    super(config);
+  }
+}
+
+// Check if an object is a tarn Pool (or KnexPool) vs a native driver pool.
+// Uses instanceof plus a duck-type fallback checking tarn-specific methods.
+function isTarnPool(obj) {
+  if (obj instanceof Pool) return true;
+  // Duck-type: tarn pools expose these numeric methods that native pools don't
+  return (
+    typeof obj.acquire === 'function' &&
+    typeof obj.release === 'function' &&
+    typeof obj.destroy === 'function' &&
+    typeof obj.numFree === 'function' &&
+    typeof obj.numUsed === 'function' &&
+    typeof obj.numPendingAcquires === 'function'
+  );
+}
+
+module.exports = { KnexPool, isTarnPool };

package/lib/query/querycompiler.js

@@ -1243,7 +1243,7 @@ class QueryCompiler {
     sql += ')';
 
     if (stmt.alias) {
-      sql += ' as ' + stmt.alias;
+      sql += ' as ' + self.formatter.wrap(stmt.alias);
     }
 
     return sql;

package/lib/schema/tablecompiler.js

@@ -328,6 +328,7 @@ class TableCompiler {
       output: () => {
         return this.client
           .queryBuilder()
+          .withSchema(this.schemaNameRaw)
           .from(this.tableNameRaw)
           .columnInfo(column)
           .then((columnInfo) => {