orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/knex/lib/dialects/better-sqlite3/index.js

@@ -0,0 +1,77 @@
+// 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;

package/.output/server/node_modules/knex/lib/dialects/cockroachdb/crdb-columncompiler.js

@@ -0,0 +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;

package/.output/server/node_modules/knex/lib/dialects/cockroachdb/crdb-querybuilder.js

@@ -0,0 +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;
+  }
+};

package/.output/server/node_modules/knex/lib/dialects/cockroachdb/crdb-querycompiler.js

@@ -0,0 +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;

package/.output/server/node_modules/knex/lib/dialects/cockroachdb/crdb-tablecompiler.js

@@ -0,0 +1,37 @@
+/* eslint max-len: 0 */
+
+const TableCompiler = require('../postgres/schema/pg-tablecompiler');
+
+class TableCompiler_CRDB extends TableCompiler {
+  constructor(client, tableBuilder) {
+    super(client, tableBuilder);
+  }
+
+  addColumns(columns, prefix, colCompilers) {
+    if (prefix === this.alterColumnsPrefix) {
+      // alter columns
+      for (const col of colCompilers) {
+        this.client.logger.warn(
+          'Experimental alter column in use, see issue: https://github.com/cockroachdb/cockroach/issues/49329'
+        );
+        this.pushQuery({
+          sql: 'SET enable_experimental_alter_column_type_general = true',
+          bindings: [],
+        });
+        super._addColumn(col);
+      }
+    } else {
+      // base class implementation for normal add
+      super.addColumns(columns, prefix);
+    }
+  }
+
+  dropUnique(columns, indexName) {
+    indexName = indexName
+      ? this.formatter.wrap(indexName)
+      : this._indexCommand('unique', this.tableNameRaw, columns);
+    this.pushQuery(`drop index ${this.tableName()}@${indexName} cascade `);
+  }
+}
+
+module.exports = TableCompiler_CRDB;

package/.output/server/node_modules/knex/lib/dialects/cockroachdb/crdb-viewcompiler.js

@@ -0,0 +1,15 @@
+const ViewCompiler_PG = require('../postgres/schema/pg-viewcompiler.js');
+
+class ViewCompiler_CRDB extends ViewCompiler_PG {
+  renameColumn(from, to) {
+    throw new Error('rename column of views is not supported by this dialect.');
+  }
+
+  defaultTo(column, defaultValue) {
+    throw new Error(
+      'change default values of views is not supported by this dialect.'
+    );
+  }
+}
+
+module.exports = ViewCompiler_CRDB;

package/.output/server/node_modules/knex/lib/dialects/cockroachdb/index.js

@@ -0,0 +1,86 @@
+// CockroachDB Client
+// -------
+const Client_PostgreSQL = require('../postgres');
+const Transaction = require('../postgres/execution/pg-transaction');
+const QueryCompiler = require('./crdb-querycompiler');
+const ColumnCompiler = require('./crdb-columncompiler');
+const TableCompiler = require('./crdb-tablecompiler');
+const ViewCompiler = require('./crdb-viewcompiler');
+const QueryBuilder = require('./crdb-querybuilder');
+
+// Always initialize with the "QueryBuilder" and "QueryCompiler"
+// objects, which extend the base 'lib/query/builder' and
+// 'lib/query/compiler', respectively.
+class Client_CockroachDB extends Client_PostgreSQL {
+  transaction() {
+    return new Transaction(this, ...arguments);
+  }
+
+  queryCompiler(builder, formatter) {
+    return new QueryCompiler(this, builder, formatter);
+  }
+
+  columnCompiler() {
+    return new ColumnCompiler(this, ...arguments);
+  }
+
+  tableCompiler() {
+    return new TableCompiler(this, ...arguments);
+  }
+
+  viewCompiler() {
+    return new ViewCompiler(this, ...arguments);
+  }
+
+  queryBuilder() {
+    return new QueryBuilder(this);
+  }
+
+  _parseVersion(versionString) {
+    return versionString.split(' ')[2];
+  }
+
+  async cancelQuery(connectionToKill) {
+    try {
+      return await this._wrappedCancelQueryCall(null, connectionToKill);
+    } catch (err) {
+      this.logger.warn(`Connection Error: ${err}`);
+      throw err;
+    }
+  }
+
+  _wrappedCancelQueryCall(emptyConnection, connectionToKill) {
+    // FixMe https://github.com/cockroachdb/cockroach/issues/41335
+    if (
+      connectionToKill.activeQuery.processID === 0 &&
+      connectionToKill.activeQuery.secretKey === 0
+    ) {
+      return;
+    }
+
+    return connectionToKill.cancel(
+      connectionToKill,
+      connectionToKill.activeQuery
+    );
+  }
+
+  toArrayPathFromJsonPath(jsonPath, builder, bindingsHolder) {
+    return jsonPath
+      .replace(/^(\$\.)/, '') // remove the first dollar
+      .replace(/\[([0-9]+)]/, '.$1')
+      .split('.')
+      .map(
+        function (v) {
+          return this.parameter(v, builder, bindingsHolder);
+        }.bind(this)
+      )
+      .join(', ');
+  }
+}
+
+Object.assign(Client_CockroachDB.prototype, {
+  // The "dialect", for reference elsewhere.
+  driverName: 'cockroachdb',
+});
+
+module.exports = Client_CockroachDB;

package/.output/server/node_modules/knex/lib/dialects/index.js

@@ -0,0 +1,34 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getDialectByNameOrAlias = void 0;
+const { resolveClientNameWithAliases } = require('../util/helpers');
+const dbNameToDialectLoader = Object.freeze({
+  'better-sqlite3': () => require('./better-sqlite3'),
+  cockroachdb: () => require('./cockroachdb'),
+  mssql: () => require('./mssql'),
+  mysql: () => require('./mysql'),
+  mysql2: () => require('./mysql2'),
+  oracle: () => require('./oracle'),
+  oracledb: () => require('./oracledb'),
+  pgnative: () => require('./pgnative'),
+  postgres: () => require('./postgres'),
+  redshift: () => require('./redshift'),
+  sqlite3: () => require('./sqlite3'),
+});
+/**
+ * Gets the Dialect object with the given client name or throw an
+ * error if not found.
+ *
+ * NOTE: This is a replacement for prior practice of doing dynamic
+ * string construction for imports of Dialect objects.
+ */
+function getDialectByNameOrAlias(clientName) {
+  const resolvedClientName = resolveClientNameWithAliases(clientName);
+  const dialectLoader = dbNameToDialectLoader[resolvedClientName];
+  if (!dialectLoader) {
+    throw new Error(`Invalid clientName given: ${clientName}`);
+  }
+  return dialectLoader();
+}
+exports.getDialectByNameOrAlias = getDialectByNameOrAlias;
+//# sourceMappingURL=index.js.map