orcaq 1.0.32 → 1.1.1

package/.output/server/node_modules/mysql2/lib/promise/connection.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const EventEmitter = require('events').EventEmitter;
+const PromisePreparedStatementInfo = require('./prepared_statement_info.js');
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./capture_local_err.js');
+const makeDoneCb = require('./make_done_cb.js');
+const inheritEvents = require('./inherit_events.js');
+const BaseConnection = require('../base/connection.js');
+
+class PromiseConnection extends EventEmitter {
+  constructor(connection, promiseImpl) {
+    super();
+    this.connection = connection;
+    this.Promise = promiseImpl || Promise;
+    inheritEvents(connection, this, [
+      'error',
+      'drain',
+      'connect',
+      'end',
+      'enqueue',
+    ]);
+  }
+
+  release() {
+    this.connection.release();
+  }
+
+  query(query, params) {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.query);
+    if (typeof params === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      if (params !== undefined) {
+        c.query(query, params, done);
+      } else {
+        c.query(query, done);
+      }
+    });
+  }
+
+  execute(query, params) {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.execute);
+    if (typeof params === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      if (params !== undefined) {
+        c.execute(query, params, done);
+      } else {
+        c.execute(query, done);
+      }
+    });
+  }
+
+  end() {
+    return new this.Promise((resolve) => {
+      this.connection.end(resolve);
+    });
+  }
+
+  async [Symbol.asyncDispose]() {
+    if (!this.connection._closing) {
+      await this.end();
+    }
+  }
+
+  beginTransaction() {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.beginTransaction
+    );
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      c.beginTransaction(done);
+    });
+  }
+
+  commit() {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.commit);
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      c.commit(done);
+    });
+  }
+
+  rollback() {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.rollback
+    );
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      c.rollback(done);
+    });
+  }
+
+  ping() {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.ping);
+    return new this.Promise((resolve, reject) => {
+      c.ping((err) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  reset() {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.reset);
+    return new this.Promise((resolve, reject) => {
+      c.reset((err) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  connect() {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.connect);
+    return new this.Promise((resolve, reject) => {
+      c.connect((err, param) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          resolve(param);
+        }
+      });
+    });
+  }
+
+  prepare(options) {
+    const c = this.connection;
+    const promiseImpl = this.Promise;
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.prepare);
+    return new this.Promise((resolve, reject) => {
+      c.prepare(options, (err, statement) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          const wrappedStatement = new PromisePreparedStatementInfo(
+            statement,
+            promiseImpl
+          );
+          resolve(wrappedStatement);
+        }
+      });
+    });
+  }
+
+  changeUser(options) {
+    const c = this.connection;
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.changeUser
+    );
+    return new this.Promise((resolve, reject) => {
+      c.changeUser(options, (err) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  get config() {
+    return this.connection.config;
+  }
+
+  get threadId() {
+    return this.connection.threadId;
+  }
+}
+// patching PromiseConnection
+// create facade functions for prototype functions on "Connection" that are not yet
+// implemented with PromiseConnection
+
+// proxy synchronous functions only
+(function (functionsToWrap) {
+  for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) {
+    const func = functionsToWrap[i];
+
+    if (
+      typeof BaseConnection.prototype[func] === 'function' &&
+      PromiseConnection.prototype[func] === undefined
+    ) {
+      PromiseConnection.prototype[func] = (function factory(funcName) {
+        return function () {
+          return BaseConnection.prototype[funcName].apply(
+            this.connection,
+            arguments
+          );
+        };
+      })(func);
+    }
+  }
+})([
+  // synchronous functions
+  'close',
+  'createBinlogStream',
+  'destroy',
+  'escape',
+  'escapeId',
+  'format',
+  'pause',
+  'pipe',
+  'resume',
+  'unprepare',
+]);
+
+module.exports = PromiseConnection;

package/.output/server/node_modules/mysql2/lib/promise/inherit_events.js

@@ -0,0 +1,27 @@
+'use strict';
+
+function inheritEvents(source, target, events) {
+  const listeners = {};
+  target
+    .on('newListener', (eventName) => {
+      if (events.indexOf(eventName) >= 0 && !target.listenerCount(eventName)) {
+        source.on(
+          eventName,
+          (listeners[eventName] = function () {
+            const args = [].slice.call(arguments);
+            args.unshift(eventName);
+
+            target.emit.apply(target, args);
+          })
+        );
+      }
+    })
+    .on('removeListener', (eventName) => {
+      if (events.indexOf(eventName) >= 0 && !target.listenerCount(eventName)) {
+        source.removeListener(eventName, listeners[eventName]);
+        delete listeners[eventName];
+      }
+    });
+}
+
+module.exports = inheritEvents;

package/.output/server/node_modules/mysql2/lib/promise/make_done_cb.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { applyCapturedStack } = require('./capture_local_err.js');
+
+function makeDoneCb(resolve, reject, stackHolder) {
+  return function (err, rows, fields) {
+    if (err) {
+      applyCapturedStack(err, stackHolder);
+      reject(err);
+    } else {
+      resolve([rows, fields]);
+    }
+  };
+}
+
+module.exports = makeDoneCb;

package/.output/server/node_modules/mysql2/lib/promise/pool.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const EventEmitter = require('events').EventEmitter;
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./capture_local_err.js');
+const makeDoneCb = require('./make_done_cb.js');
+const PromisePoolConnection = require('./pool_connection.js');
+const inheritEvents = require('./inherit_events.js');
+const BasePool = require('../base/pool.js');
+
+class PromisePool extends EventEmitter {
+  constructor(pool, thePromise) {
+    super();
+    this.pool = pool;
+    this.Promise = thePromise || Promise;
+    inheritEvents(pool, this, ['acquire', 'connection', 'enqueue', 'release']);
+  }
+
+  getConnection() {
+    const corePool = this.pool;
+    return new this.Promise((resolve, reject) => {
+      corePool.getConnection((err, coreConnection) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(new PromisePoolConnection(coreConnection, this.Promise));
+        }
+      });
+    });
+  }
+
+  releaseConnection(connection) {
+    if (connection instanceof PromisePoolConnection) connection.release();
+  }
+
+  query(sql, args) {
+    const corePool = this.pool;
+    const stackHolder = captureStackHolder(PromisePool.prototype.query);
+    if (typeof args === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      if (args !== undefined) {
+        corePool.query(sql, args, done);
+      } else {
+        corePool.query(sql, done);
+      }
+    });
+  }
+
+  execute(sql, args) {
+    const corePool = this.pool;
+    const stackHolder = captureStackHolder(PromisePool.prototype.execute);
+    if (typeof args === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      if (args) {
+        corePool.execute(sql, args, done);
+      } else {
+        corePool.execute(sql, done);
+      }
+    });
+  }
+
+  end() {
+    const corePool = this.pool;
+    const stackHolder = captureStackHolder(PromisePool.prototype.end);
+    return new this.Promise((resolve, reject) => {
+      corePool.end((err) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  async [Symbol.asyncDispose]() {
+    if (!this.pool._closed) {
+      await this.end();
+    }
+  }
+}
+
+(function (functionsToWrap) {
+  for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) {
+    const func = functionsToWrap[i];
+
+    if (
+      typeof BasePool.prototype[func] === 'function' &&
+      PromisePool.prototype[func] === undefined
+    ) {
+      PromisePool.prototype[func] = (function factory(funcName) {
+        return function () {
+          return BasePool.prototype[funcName].apply(this.pool, arguments);
+        };
+      })(func);
+    }
+  }
+})([
+  // synchronous functions
+  'escape',
+  'escapeId',
+  'format',
+]);
+
+module.exports = PromisePool;

package/.output/server/node_modules/mysql2/lib/promise/pool_cluster.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { captureStackHolder } = require('./capture_local_err.js');
+const PromisePoolConnection = require('./pool_connection');
+const makeDoneCb = require('./make_done_cb');
+
+class PromisePoolNamespace {
+  constructor(poolNamespace, thePromise) {
+    this.poolNamespace = poolNamespace;
+    this.Promise = thePromise || Promise;
+  }
+
+  getConnection() {
+    const corePoolNamespace = this.poolNamespace;
+    return new this.Promise((resolve, reject) => {
+      corePoolNamespace.getConnection((err, coreConnection) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(new PromisePoolConnection(coreConnection, this.Promise));
+        }
+      });
+    });
+  }
+
+  query(sql, values) {
+    const corePoolNamespace = this.poolNamespace;
+    const stackHolder = captureStackHolder(
+      PromisePoolNamespace.prototype.query
+    );
+    if (typeof values === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      corePoolNamespace.query(sql, values, done);
+    });
+  }
+
+  execute(sql, values) {
+    const corePoolNamespace = this.poolNamespace;
+    const stackHolder = captureStackHolder(
+      PromisePoolNamespace.prototype.execute
+    );
+    if (typeof values === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      corePoolNamespace.execute(sql, values, done);
+    });
+  }
+}
+
+module.exports = PromisePoolNamespace;

package/.output/server/node_modules/mysql2/lib/promise/pool_connection.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const PromiseConnection = require('./connection.js');
+
+class PromisePoolConnection extends PromiseConnection {
+  constructor(connection, promiseImpl) {
+    super(connection, promiseImpl);
+  }
+
+  destroy() {
+    return this.connection.destroy();
+  }
+
+  async [Symbol.asyncDispose]() {
+    this.release();
+  }
+}
+
+module.exports = PromisePoolConnection;

package/.output/server/node_modules/mysql2/lib/promise/prepared_statement_info.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { captureStackHolder } = require('./capture_local_err.js');
+const makeDoneCb = require('./make_done_cb.js');
+
+class PromisePreparedStatementInfo {
+  constructor(statement, promiseImpl) {
+    this.statement = statement;
+    this.Promise = promiseImpl;
+  }
+
+  execute(parameters) {
+    const s = this.statement;
+    const stackHolder = captureStackHolder(
+      PromisePreparedStatementInfo.prototype.execute
+    );
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      if (parameters) {
+        s.execute(parameters, done);
+      } else {
+        s.execute(done);
+      }
+    });
+  }
+
+  close() {
+    return new this.Promise((resolve) => {
+      this.statement.close();
+      resolve();
+    });
+  }
+}
+
+module.exports = PromisePreparedStatementInfo;

package/.output/server/node_modules/mysql2/lib/server.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const net = require('net');
+const EventEmitter = require('events').EventEmitter;
+
+const Connection = require('./connection');
+const ConnectionConfig = require('./connection_config');
+
+// TODO: inherit Server from net.Server
+class Server extends EventEmitter {
+  constructor() {
+    super();
+    this.connections = [];
+    this._server = net.createServer(this._handleConnection.bind(this));
+  }
+
+  _handleConnection(socket) {
+    const connectionConfig = new ConnectionConfig({
+      stream: socket,
+      isServer: true,
+    });
+    const connection = new Connection({ config: connectionConfig });
+    this.emit('connection', connection);
+  }
+
+  listen(port) {
+    this._port = port;
+    this._server.listen.apply(this._server, arguments);
+    return this;
+  }
+
+  close(cb) {
+    this._server.close(cb);
+  }
+}
+
+module.exports = Server;

package/.output/server/node_modules/mysql2/lib/tracing.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const process = require('process');
+
+// Safe load: use getBuiltinModule if available, fallback to require, catch if unavailable
+const dc = (() => {
+  try {
+    return 'getBuiltinModule' in process
+      ? process.getBuiltinModule('node:diagnostics_channel')
+      : require('node:diagnostics_channel');
+  } catch {
+    return undefined;
+  }
+})();
+
+const hasTracingChannel = typeof dc?.tracingChannel === 'function';
+
+const queryChannel = hasTracingChannel
+  ? dc.tracingChannel('mysql2:query')
+  : undefined;
+
+const executeChannel = hasTracingChannel
+  ? dc.tracingChannel('mysql2:execute')
+  : undefined;
+
+const connectChannel = hasTracingChannel
+  ? dc.tracingChannel('mysql2:connect')
+  : undefined;
+
+const poolConnectChannel = hasTracingChannel
+  ? dc.tracingChannel('mysql2:pool:connect')
+  : undefined;
+
+function getServerContext(config) {
+  if (config.socketPath) {
+    return { serverAddress: config.socketPath, serverPort: undefined };
+  }
+  return {
+    serverAddress: config.host || 'localhost',
+    serverPort: config.port || 3306,
+  };
+}
+
+// Node 20+: TracingChannel has an aggregated hasSubscribers getter.
+// Node 18.x: that getter is missing (undefined), fall back to start sub-channel.
+function shouldTrace(channel) {
+  if (channel === undefined || channel === null) {
+    return false;
+  }
+  return channel.hasSubscribers ?? channel.start?.hasSubscribers ?? false;
+}
+
+// Generic traceCallback wrapper — calls fn synchronously, wraps the callback
+// at args[position] to emit asyncStart/asyncEnd/error. No promises involved.
+function traceCallback(channel, fn, position, context, thisArg, ...args) {
+  if (shouldTrace(channel)) {
+    return channel.traceCallback(fn, position, context(), thisArg, ...args);
+  }
+  return fn.apply(thisArg, args);
+}
+
+// tracePromise for operations that are inherently async (connection handshake)
+function tracePromise(channel, fn, contextFactory) {
+  if (shouldTrace(channel)) {
+    return channel.tracePromise(fn, contextFactory());
+  }
+  return fn();
+}
+
+module.exports = {
+  dc,
+  hasTracingChannel,
+  shouldTrace,
+  queryChannel,
+  executeChannel,
+  connectChannel,
+  poolConnectChannel,
+  getServerContext,
+  traceCallback,
+  tracePromise,
+};