knex 3.1.0 → 3.2.1

package/lib/constants.js

@@ -1,61 +1,61 @@
-// The client names we'll allow in the `{name: lib}` pairing.
-const CLIENT_ALIASES = Object.freeze({
-  pg: 'postgres',
-  postgresql: 'postgres',
-  sqlite: 'sqlite3',
-});
-
-const SUPPORTED_CLIENTS = Object.freeze(
-  [
-    'mssql',
-    'mysql',
-    'mysql2',
-    'oracledb',
-    'postgres',
-    'pgnative',
-    'redshift',
-    'sqlite3',
-    'cockroachdb',
-    'better-sqlite3',
-  ].concat(Object.keys(CLIENT_ALIASES))
-);
-
-const DRIVER_NAMES = Object.freeze({
-  MsSQL: 'mssql',
-  MySQL: 'mysql',
-  MySQL2: 'mysql2',
-  Oracle: 'oracledb',
-  PostgreSQL: 'pg',
-  PgNative: 'pgnative',
-  Redshift: 'pg-redshift',
-  SQLite: 'sqlite3',
-  CockroachDB: 'cockroachdb',
-  BetterSQLite3: 'better-sqlite3',
-});
-
-const POOL_CONFIG_OPTIONS = Object.freeze([
-  'maxWaitingClients',
-  'testOnBorrow',
-  'fifo',
-  'priorityRange',
-  'autostart',
-  'evictionRunIntervalMillis',
-  'numTestsPerRun',
-  'softIdleTimeoutMillis',
-  'Promise',
-]);
-
-/**
- * Regex that only matches comma's in strings that aren't wrapped in parentheses. Can be used to
- * safely split strings like `id int, name string, body text, primary key (id, name)` into definition
- * rows
- */
-const COMMA_NO_PAREN_REGEX = /,[\s](?![^(]*\))/g;
-
-module.exports = {
-  CLIENT_ALIASES,
-  SUPPORTED_CLIENTS,
-  POOL_CONFIG_OPTIONS,
-  COMMA_NO_PAREN_REGEX,
-  DRIVER_NAMES,
-};
+// The client names we'll allow in the `{name: lib}` pairing.
+const CLIENT_ALIASES = Object.freeze({
+  pg: 'postgres',
+  postgresql: 'postgres',
+  sqlite: 'sqlite3',
+});
+
+const SUPPORTED_CLIENTS = Object.freeze(
+  [
+    'mssql',
+    'mysql',
+    'mysql2',
+    'oracledb',
+    'postgres',
+    'pgnative',
+    'redshift',
+    'sqlite3',
+    'cockroachdb',
+    'better-sqlite3',
+  ].concat(Object.keys(CLIENT_ALIASES))
+);
+
+const DRIVER_NAMES = Object.freeze({
+  MsSQL: 'mssql',
+  MySQL: 'mysql',
+  MySQL2: 'mysql2',
+  Oracle: 'oracledb',
+  PostgreSQL: 'pg',
+  PgNative: 'pgnative',
+  Redshift: 'pg-redshift',
+  SQLite: 'sqlite3',
+  CockroachDB: 'cockroachdb',
+  BetterSQLite3: 'better-sqlite3',
+});
+
+const POOL_CONFIG_OPTIONS = Object.freeze([
+  'maxWaitingClients',
+  'testOnBorrow',
+  'fifo',
+  'priorityRange',
+  'autostart',
+  'evictionRunIntervalMillis',
+  'numTestsPerRun',
+  'softIdleTimeoutMillis',
+  'Promise',
+]);
+
+/**
+ * Regex that only matches comma's in strings that aren't wrapped in parentheses. Can be used to
+ * safely split strings like `id int, name string, body text, primary key (id, name)` into definition
+ * rows
+ */
+const COMMA_NO_PAREN_REGEX = /,[\s](?![^(]*\))/g;
+
+module.exports = {
+  CLIENT_ALIASES,
+  SUPPORTED_CLIENTS,
+  POOL_CONFIG_OPTIONS,
+  COMMA_NO_PAREN_REGEX,
+  DRIVER_NAMES,
+};

package/lib/dialects/better-sqlite3/index.js

@@ -1,77 +1,101 @@
-// better-sqlite3 Client
-// -------
-const Client_SQLite3 = require('../sqlite3');
-
-class Client_BetterSQLite3 extends Client_SQLite3 {
-  _driver() {
-    return require('better-sqlite3');
-  }
-
-  // Get a raw connection from the database, returning a promise with the connection object.
-  async acquireRawConnection() {
-    const options = this.connectionSettings.options || {};
-
-    return new this.driver(this.connectionSettings.filename, {
-      nativeBinding: options.nativeBinding,
-      readonly: !!options.readonly,
-    });
-  }
-
-  // Used to explicitly close a connection, called internally by the pool when
-  // a connection times out or the pool is shutdown.
-  async destroyRawConnection(connection) {
-    return connection.close();
-  }
-
-  // Runs the query on the specified connection, providing the bindings and any
-  // other necessary prep work.
-  async _query(connection, obj) {
-    if (!obj.sql) throw new Error('The query is empty');
-
-    if (!connection) {
-      throw new Error('No connection provided');
-    }
-
-    const statement = connection.prepare(obj.sql);
-    const bindings = this._formatBindings(obj.bindings);
-
-    if (statement.reader) {
-      const response = await statement.all(bindings);
-      obj.response = response;
-      return obj;
-    }
-
-    const response = await statement.run(bindings);
-    obj.response = response;
-    obj.context = {
-      lastID: response.lastInsertRowid,
-      changes: response.changes,
-    };
-
-    return obj;
-  }
-
-  _formatBindings(bindings) {
-    if (!bindings) {
-      return [];
-    }
-    return bindings.map((binding) => {
-      if (binding instanceof Date) {
-        return binding.valueOf();
-      }
-
-      if (typeof binding === 'boolean') {
-        return Number(binding);
-      }
-
-      return binding;
-    });
-  }
-}
-
-Object.assign(Client_BetterSQLite3.prototype, {
-  // The "dialect", for reference .
-  driverName: 'better-sqlite3',
-});
-
-module.exports = Client_BetterSQLite3;
+// better-sqlite3 Client
+// -------
+const Client_SQLite3 = require('../sqlite3');
+
+class Client_BetterSQLite3 extends Client_SQLite3 {
+  _driver() {
+    return require('better-sqlite3');
+  }
+
+  // Get a raw connection from the database, returning a promise with the connection object.
+  async acquireRawConnection() {
+    const options = this.connectionSettings.options || {};
+
+    const db = new this.driver(this.connectionSettings.filename, {
+      nativeBinding: options.nativeBinding,
+      readonly: !!options.readonly,
+    });
+
+    const safeIntegers = this._optSafeIntegers(options);
+    if (safeIntegers !== undefined) {
+      db.defaultSafeIntegers(safeIntegers);
+    }
+
+    return db;
+  }
+
+  // Used to explicitly close a connection, called internally by the pool when
+  // a connection times out or the pool is shutdown.
+  async destroyRawConnection(connection) {
+    return connection.close();
+  }
+
+  // Runs the query on the specified connection, providing the bindings and any
+  // other necessary prep work.
+  async _query(connection, obj) {
+    if (!obj.sql) throw new Error('The query is empty');
+
+    if (!connection) {
+      throw new Error('No connection provided');
+    }
+
+    const statement = connection.prepare(obj.sql);
+
+    const safeIntegers = this._optSafeIntegers(obj.options);
+    if (safeIntegers !== undefined) {
+      statement.safeIntegers(safeIntegers);
+    }
+
+    const bindings = this._formatBindings(obj.bindings);
+
+    if (statement.reader) {
+      const response = await statement.all(bindings);
+      obj.response = response;
+      return obj;
+    }
+
+    const response = await statement.run(bindings);
+    obj.response = response;
+    obj.context = {
+      lastID: response.lastInsertRowid,
+      changes: response.changes,
+    };
+
+    return obj;
+  }
+
+  _formatBindings(bindings) {
+    if (!bindings) {
+      return [];
+    }
+    return bindings.map((binding) => {
+      if (binding instanceof Date) {
+        return binding.valueOf();
+      }
+
+      if (typeof binding === 'boolean') {
+        return Number(binding);
+      }
+
+      return binding;
+    });
+  }
+
+  _optSafeIntegers(options) {
+    if (
+      options &&
+      typeof options === 'object' &&
+      typeof options.safeIntegers === 'boolean'
+    ) {
+      return options.safeIntegers;
+    }
+    return undefined;
+  }
+}
+
+Object.assign(Client_BetterSQLite3.prototype, {
+  // The "dialect", for reference .
+  driverName: 'better-sqlite3',
+});
+
+module.exports = Client_BetterSQLite3;

package/lib/dialects/cockroachdb/crdb-columncompiler.js

@@ -1,14 +1,14 @@
-const ColumnCompiler_PG = require('../postgres/schema/pg-columncompiler.js');
-
-class ColumnCompiler_CRDB extends ColumnCompiler_PG {
-  uuid(options = { primaryKey: false }) {
-    return (
-      'uuid' +
-      (this.tableCompiler._canBeAddPrimaryKey(options)
-        ? ' primary key default gen_random_uuid()'
-        : '')
-    );
-  }
-}
-
-module.exports = ColumnCompiler_CRDB;
+const ColumnCompiler_PG = require('../postgres/schema/pg-columncompiler.js');
+
+class ColumnCompiler_CRDB extends ColumnCompiler_PG {
+  uuid(options = { primaryKey: false }) {
+    return (
+      'uuid' +
+      (this.tableCompiler._canBeAddPrimaryKey(options)
+        ? ' primary key default gen_random_uuid()'
+        : '')
+    );
+  }
+}
+
+module.exports = ColumnCompiler_CRDB;

package/lib/dialects/cockroachdb/crdb-querybuilder.js

@@ -1,11 +1,11 @@
-const QueryBuilder = require('../../query/querybuilder');
-const isEmpty = require('lodash/isEmpty');
-
-module.exports = class QueryBuilder_CockroachDB extends QueryBuilder {
-  upsert(values, returning, options) {
-    this._method = 'upsert';
-    if (!isEmpty(returning)) this.returning(returning, options);
-    this._single.upsert = values;
-    return this;
-  }
-};
+const QueryBuilder = require('../../query/querybuilder');
+const isEmpty = require('lodash/isEmpty');
+
+module.exports = class QueryBuilder_CockroachDB extends QueryBuilder {
+  upsert(values, returning, options) {
+    this._method = 'upsert';
+    if (!isEmpty(returning)) this.returning(returning, options);
+    this._single.upsert = values;
+    return this;
+  }
+};

package/lib/dialects/cockroachdb/crdb-querycompiler.js

@@ -1,122 +1,122 @@
-const QueryCompiler_PG = require('../postgres/query/pg-querycompiler');
-const {
-  columnize: columnize_,
-  wrap: wrap_,
-  operator: operator_,
-} = require('../../formatter/wrappingFormatter');
-
-class QueryCompiler_CRDB extends QueryCompiler_PG {
-  truncate() {
-    return `truncate ${this.tableName}`;
-  }
-
-  upsert() {
-    let sql = this._upsert();
-    if (sql === '') return sql;
-    const { returning } = this.single;
-    if (returning) sql += this._returning(returning);
-    return {
-      sql: sql,
-      returning,
-    };
-  }
-
-  _upsert() {
-    const upsertValues = this.single.upsert || [];
-    const sql = this.with() + `upsert into ${this.tableName} `;
-    const body = this._insertBody(upsertValues);
-    return body === '' ? '' : sql + body;
-  }
-
-  _groupOrder(item, type) {
-    // CockroachDB don't support PostgreSQL order nulls first/last syntax, we take the generic one.
-    return this._basicGroupOrder(item, type);
-  }
-
-  whereJsonPath(statement) {
-    let castValue = '';
-    if (!isNaN(statement.value) && parseInt(statement.value)) {
-      castValue = '::int';
-    } else if (!isNaN(statement.value) && parseFloat(statement.value)) {
-      castValue = '::float';
-    } else {
-      castValue = " #>> '{}'";
-    }
-    return `json_extract_path(${this._columnClause(
-      statement
-    )}, ${this.client.toArrayPathFromJsonPath(
-      statement.jsonPath,
-      this.builder,
-      this.bindingsHolder
-    )})${castValue} ${operator_(
-      statement.operator,
-      this.builder,
-      this.client,
-      this.bindingsHolder
-    )} ${this._jsonValueClause(statement)}`;
-  }
-
-  // Json common functions
-  _jsonExtract(nameFunction, params) {
-    let extractions;
-    if (Array.isArray(params.column)) {
-      extractions = params.column;
-    } else {
-      extractions = [params];
-    }
-    return extractions
-      .map((extraction) => {
-        const jsonCol = `json_extract_path(${columnize_(
-          extraction.column || extraction[0],
-          this.builder,
-          this.client,
-          this.bindingsHolder
-        )}, ${this.client.toArrayPathFromJsonPath(
-          extraction.path || extraction[1],
-          this.builder,
-          this.bindingsHolder
-        )})`;
-        const alias = extraction.alias || extraction[2];
-        return alias
-          ? this.client.alias(jsonCol, this.formatter.wrap(alias))
-          : jsonCol;
-      })
-      .join(', ');
-  }
-
-  _onJsonPathEquals(nameJoinFunction, clause) {
-    return (
-      'json_extract_path(' +
-      wrap_(
-        clause.columnFirst,
-        undefined,
-        this.builder,
-        this.client,
-        this.bindingsHolder
-      ) +
-      ', ' +
-      this.client.toArrayPathFromJsonPath(
-        clause.jsonPathFirst,
-        this.builder,
-        this.bindingsHolder
-      ) +
-      ') = json_extract_path(' +
-      wrap_(
-        clause.columnSecond,
-        undefined,
-        this.builder,
-        this.client,
-        this.bindingsHolder
-      ) +
-      ', ' +
-      this.client.toArrayPathFromJsonPath(
-        clause.jsonPathSecond,
-        this.builder,
-        this.bindingsHolder
-      ) +
-      ')'
-    );
-  }
-}
-
-module.exports = QueryCompiler_CRDB;
+const QueryCompiler_PG = require('../postgres/query/pg-querycompiler');
+const {
+  columnize: columnize_,
+  wrap: wrap_,
+  operator: operator_,
+} = require('../../formatter/wrappingFormatter');
+
+class QueryCompiler_CRDB extends QueryCompiler_PG {
+  truncate() {
+    return `truncate ${this.tableName}`;
+  }
+
+  upsert() {
+    let sql = this._upsert();
+    if (sql === '') return sql;
+    const { returning } = this.single;
+    if (returning) sql += this._returning(returning);
+    return {
+      sql: sql,
+      returning,
+    };
+  }
+
+  _upsert() {
+    const upsertValues = this.single.upsert || [];
+    const sql = this.with() + `upsert into ${this.tableName} `;
+    const body = this._insertBody(upsertValues);
+    return body === '' ? '' : sql + body;
+  }
+
+  _groupOrder(item, type) {
+    // CockroachDB don't support PostgreSQL order nulls first/last syntax, we take the generic one.
+    return this._basicGroupOrder(item, type);
+  }
+
+  whereJsonPath(statement) {
+    let castValue = '';
+    if (!isNaN(statement.value) && parseInt(statement.value)) {
+      castValue = '::int';
+    } else if (!isNaN(statement.value) && parseFloat(statement.value)) {
+      castValue = '::float';
+    } else {
+      castValue = " #>> '{}'";
+    }
+    return `json_extract_path(${this._columnClause(
+      statement
+    )}, ${this.client.toArrayPathFromJsonPath(
+      statement.jsonPath,
+      this.builder,
+      this.bindingsHolder
+    )})${castValue} ${operator_(
+      statement.operator,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )} ${this._jsonValueClause(statement)}`;
+  }
+
+  // Json common functions
+  _jsonExtract(nameFunction, params) {
+    let extractions;
+    if (Array.isArray(params.column)) {
+      extractions = params.column;
+    } else {
+      extractions = [params];
+    }
+    return extractions
+      .map((extraction) => {
+        const jsonCol = `json_extract_path(${columnize_(
+          extraction.column || extraction[0],
+          this.builder,
+          this.client,
+          this.bindingsHolder
+        )}, ${this.client.toArrayPathFromJsonPath(
+          extraction.path || extraction[1],
+          this.builder,
+          this.bindingsHolder
+        )})`;
+        const alias = extraction.alias || extraction[2];
+        return alias
+          ? this.client.alias(jsonCol, this.formatter.wrap(alias))
+          : jsonCol;
+      })
+      .join(', ');
+  }
+
+  _onJsonPathEquals(nameJoinFunction, clause) {
+    return (
+      'json_extract_path(' +
+      wrap_(
+        clause.columnFirst,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.toArrayPathFromJsonPath(
+        clause.jsonPathFirst,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ') = json_extract_path(' +
+      wrap_(
+        clause.columnSecond,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.toArrayPathFromJsonPath(
+        clause.jsonPathSecond,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ')'
+    );
+  }
+}
+
+module.exports = QueryCompiler_CRDB;