@depup/mysql2 3.19.0-depup.0

package/lib/promise/pool.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const EventEmitter = require('events').EventEmitter;
+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 localErr = new Error();
+    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, localErr);
+      if (args !== undefined) {
+        corePool.query(sql, args, done);
+      } else {
+        corePool.query(sql, done);
+      }
+    });
+  }
+
+  execute(sql, args) {
+    const corePool = this.pool;
+    const localErr = new Error();
+    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, localErr);
+      if (args) {
+        corePool.execute(sql, args, done);
+      } else {
+        corePool.execute(sql, done);
+      }
+    });
+  }
+
+  end() {
+    const corePool = this.pool;
+    const localErr = new Error();
+    return new this.Promise((resolve, reject) => {
+      corePool.end((err) => {
+        if (err) {
+          localErr.message = err.message;
+          localErr.code = err.code;
+          localErr.errno = err.errno;
+          localErr.sqlState = err.sqlState;
+          localErr.sqlMessage = err.sqlMessage;
+          reject(localErr);
+        } 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/lib/promise/pool_cluster.js

@@ -0,0 +1,54 @@
+'use strict';
+
+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 localErr = new Error();
+    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, localErr);
+      corePoolNamespace.query(sql, values, done);
+    });
+  }
+
+  execute(sql, values) {
+    const corePoolNamespace = this.poolNamespace;
+    const localErr = new Error();
+    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, localErr);
+      corePoolNamespace.execute(sql, values, done);
+    });
+  }
+}
+
+module.exports = PromisePoolNamespace;

package/lib/promise/pool_connection.js

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

package/lib/promise/prepared_statement_info.js

@@ -0,0 +1,32 @@
+'use strict';
+
+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 localErr = new Error();
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, localErr);
+      if (parameters) {
+        s.execute(parameters, done);
+      } else {
+        s.execute(done);
+      }
+    });
+  }
+
+  close() {
+    return new this.Promise((resolve) => {
+      this.statement.close();
+      resolve();
+    });
+  }
+}
+
+module.exports = PromisePreparedStatementInfo;

package/lib/results_stream.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const Readable = require('stream').Readable;
+
+// copy-paste from https://github.com/mysqljs/mysql/blob/master/lib/protocol/sequences/Query.js
+module.exports = function (command, connectionStream) {
+  command.stream = function (options) {
+    let stream;
+
+    options = options || {};
+    options.objectMode = true;
+    ((stream = new Readable(options)),
+      (stream._read = function () {
+        connectionStream.resume();
+      }));
+
+    this.on('result', (row, i) => {
+      if (!stream.push(row)) {
+        connectionStream.pause();
+      }
+      stream.emit('result', row, i); // replicate old emitter
+    });
+
+    this.on('error', (err) => {
+      stream.emit('error', err); // Pass on any errors
+    });
+
+    this.on('end', () => {
+      stream.push(null); // pushing null, indicating EOF
+    });
+
+    this.on('fields', (fields, i) => {
+      stream.emit('fields', fields, i); // replicate old emitter
+    });
+
+    return stream;
+  };
+};

package/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/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@depup/mysql2",
+  "version": "3.19.0-depup.0",
+  "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
+  "main": "index.js",
+  "typings": "typings/mysql/index",
+  "type": "commonjs",
+  "scripts": {
+    "lint": "eslint . && prettier --check .",
+    "lint:fix": "eslint . --fix && prettier --write .",
+    "test": "npm run test:parallel && npm run test:global",
+    "test:parallel": "poku -c=\"poku.config.mjs\" test",
+    "test:global": "cross-env SUITE=global poku -c=\"poku.config.mjs\" test/global",
+    "test:bun": "npm run test:bun:parallel && npm run test:bun:global",
+    "test:bun:parallel": "bun poku -c=\"poku.config.mjs\" test",
+    "test:bun:global": "cross-env SUITE=global bun poku -c=\"poku.config.mjs\" test/global",
+    "test:deno": "npm run test:deno:parallel && npm run test:deno:global",
+    "test:deno:parallel": "deno run --allow-read --allow-env --allow-run npm:poku@canary -c=\"poku.config.mjs\" test",
+    "test:deno:global": "cross-env SUITE=global deno run --allow-read --allow-env --allow-run npm:poku@canary -c=\"poku.config.mjs\" test/global",
+    "test:docker:up": "docker compose -f test/docker-compose.yml up --abort-on-container-exit --remove-orphans",
+    "test:docker:down": "docker compose -f test/docker-compose.yml down",
+    "test:docker:node": "npm run test:docker:up -- node && npm run test:docker:down",
+    "test:docker:bun": "npm run test:docker:up -- bun && npm run test:docker:down",
+    "test:docker:deno": "npm run test:docker:up -- deno && npm run test:docker:down",
+    "test:docker:coverage": "npm run test:docker:up -- coverage && npm run test:docker:down",
+    "test:coverage": "c8 npm test",
+    "typecheck": "cd \"test/tsc-build\" && tsc -p \"tsconfig.json\" && cd .. && tsc -p \"tsconfig.json\" --noEmit",
+    "benchmark": "node ./benchmarks/benchmark.js",
+    "wait-port": "wait-on"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sidorares/node-mysql2.git"
+  },
+  "homepage": "https://sidorares.github.io/node-mysql2/docs",
+  "keywords": [
+    "mysql",
+    "client",
+    "server"
+  ],
+  "files": [
+    "lib",
+    "typings/mysql",
+    "index.js",
+    "index.d.ts",
+    "promise.js",
+    "promise.d.ts"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./promise": "./promise.js",
+    "./promise.js": "./promise.js"
+  },
+  "engines": {
+    "node": ">= 8.0"
+  },
+  "author": "Andrey Sidorov <andrey.sidorov@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "aws-ssl-profiles": "^1.1.2",
+    "denque": "^2.1.0",
+    "generate-function": "^2.3.1",
+    "iconv-lite": "^0.7.2",
+    "long": "^5.3.2",
+    "lru.min": "^1.1.4",
+    "named-placeholders": "^1.1.6",
+    "sql-escaper": "^1.3.3"
+  },
+  "peerDependencies": {
+    "@types/node": ">= 8"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
+    "@eslint/markdown": "^7.5.1",
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "assert-diff": "^3.0.4",
+    "benchmark": "^2.1.4",
+    "c8": "^11.0.0",
+    "cross-env": "^10.1.0",
+    "error-stack-parser": "^2.1.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-async-await": "^0.0.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "poku": "^3.0.3-canary.8f374795",
+    "portfinder": "^1.0.38",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/promise.d.ts

@@ -0,0 +1,139 @@
+import { EventEmitter } from 'events';
+
+import {
+  RowDataPacket,
+  OkPacket,
+  ResultSetHeader,
+  FieldPacket,
+  QueryOptions,
+  ConnectionOptions,
+  PoolOptions,
+  PoolClusterOptions,
+  Pool as CorePool,
+  ConnectionState,
+} from './index.js';
+import { ExecutableBase as ExecutableBaseClass } from './typings/mysql/lib/protocol/sequences/promise/ExecutableBase.js';
+import { QueryableBase as QueryableBaseClass } from './typings/mysql/lib/protocol/sequences/promise/QueryableBase.js';
+
+export * from './index.js';
+
+// Expose class interfaces
+declare class QueryableAndExecutableBase extends QueryableBaseClass(
+  ExecutableBaseClass(EventEmitter)
+) {}
+
+export interface PreparedStatementInfo {
+  close(): Promise<void>;
+  execute(
+    parameters: any | any[] | { [param: string]: any }
+  ): Promise<
+    [
+      (
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+      ),
+      FieldPacket[],
+    ]
+  >;
+}
+
+export interface Connection extends QueryableAndExecutableBase {
+  config: ConnectionOptions;
+
+  threadId: number;
+
+  readonly state: ConnectionState;
+
+  connect(): Promise<void>;
+
+  ping(): Promise<void>;
+
+  beginTransaction(): Promise<void>;
+
+  commit(): Promise<void>;
+
+  rollback(): Promise<void>;
+
+  changeUser(options: ConnectionOptions): Promise<void>;
+
+  prepare(options: string | QueryOptions): Promise<PreparedStatementInfo>;
+
+  unprepare(sql: string | QueryOptions): void;
+
+  end(options?: any): Promise<void>;
+
+  [Symbol.asyncDispose](): Promise<void>;
+
+  destroy(): void;
+
+  pause(): void;
+
+  resume(): void;
+
+  escape(value: any): string;
+
+  escapeId(value: string): string;
+  escapeId(values: string[]): string;
+
+  format(sql: string, values?: any | any[] | { [param: string]: any }): string;
+}
+
+export interface PoolConnection extends Connection {
+  release(): void;
+  connection: Connection;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+
+export interface Pool extends Connection {
+  getConnection(): Promise<PoolConnection>;
+
+  releaseConnection(connection: PoolConnection): void;
+
+  on(event: 'connection', listener: (connection: PoolConnection) => any): this;
+  on(event: 'acquire', listener: (connection: PoolConnection) => any): this;
+  on(event: 'release', listener: (connection: PoolConnection) => any): this;
+  on(event: 'enqueue', listener: () => any): this;
+
+  end(): Promise<void>;
+
+  pool: CorePool;
+}
+
+export interface PoolNamespace extends QueryableAndExecutableBase {
+  getConnection(): Promise<PoolConnection>;
+}
+
+export interface PoolCluster extends EventEmitter {
+  config: PoolClusterOptions;
+
+  add(config: PoolOptions): void;
+  add(group: string, connectionUri: string): void;
+  add(group: string, config: PoolOptions): void;
+
+  end(): Promise<void>;
+
+  [Symbol.asyncDispose](): Promise<void>;
+
+  getConnection(): Promise<PoolConnection>;
+  getConnection(group: string): Promise<PoolConnection>;
+  getConnection(group: string, selector: string): Promise<PoolConnection>;
+
+  of(pattern: string, selector?: string): PoolNamespace;
+
+  on(event: string, listener: (...args: any[]) => void): this;
+  on(event: 'remove', listener: (nodeId: number) => void): this;
+  on(event: 'warn', listener: (err: Error) => void): this;
+}
+
+export function createConnection(connectionUri: string): Promise<Connection>;
+export function createConnection(
+  config: ConnectionOptions
+): Promise<Connection>;
+
+export function createPool(connectionUri: string): Pool;
+export function createPool(config: PoolOptions): Pool;
+
+export function createPoolCluster(config?: PoolClusterOptions): PoolCluster;