@depup/mysql2 3.19.0-depup.0

package/promise.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const SqlString = require('sql-escaper');
+const EventEmitter = require('events').EventEmitter;
+const parserCache = require('./lib/parsers/parser_cache.js');
+const PoolCluster = require('./lib/pool_cluster.js');
+const createConnection = require('./lib/create_connection.js');
+const createPool = require('./lib/create_pool.js');
+const createPoolCluster = require('./lib/create_pool_cluster.js');
+const PromiseConnection = require('./lib/promise/connection.js');
+const PromisePool = require('./lib/promise/pool.js');
+const makeDoneCb = require('./lib/promise/make_done_cb.js');
+const PromisePoolConnection = require('./lib/promise/pool_connection.js');
+const inheritEvents = require('./lib/promise/inherit_events.js');
+const PromisePoolNamespace = require('./lib/promise/pool_cluster');
+
+function createConnectionPromise(opts) {
+  const coreConnection = createConnection(opts);
+  const createConnectionErr = new Error();
+  const thePromise = opts.Promise || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+        'Use promise-enabled node version or pass userland Promise' +
+        " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+  return new thePromise((resolve, reject) => {
+    coreConnection.once('connect', () => {
+      resolve(new PromiseConnection(coreConnection, thePromise));
+    });
+    coreConnection.once('error', (err) => {
+      createConnectionErr.message = err.message;
+      createConnectionErr.code = err.code;
+      createConnectionErr.errno = err.errno;
+      createConnectionErr.sqlState = err.sqlState;
+      reject(createConnectionErr);
+    });
+  });
+}
+
+// note: the callback of "changeUser" is not called on success
+// hence there is no possibility to call "resolve"
+
+function createPromisePool(opts) {
+  const corePool = createPool(opts);
+  const thePromise = opts.Promise || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+        'Use promise-enabled node version or pass userland Promise' +
+        " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+
+  return new PromisePool(corePool, thePromise);
+}
+
+class PromisePoolCluster extends EventEmitter {
+  constructor(poolCluster, thePromise) {
+    super();
+    this.poolCluster = poolCluster;
+    this.Promise = thePromise || Promise;
+    inheritEvents(poolCluster, this, ['warn', 'remove', 'online', 'offline']);
+  }
+
+  getConnection(pattern, selector) {
+    const corePoolCluster = this.poolCluster;
+    return new this.Promise((resolve, reject) => {
+      corePoolCluster.getConnection(
+        pattern,
+        selector,
+        (err, coreConnection) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(new PromisePoolConnection(coreConnection, this.Promise));
+          }
+        }
+      );
+    });
+  }
+
+  query(sql, args) {
+    const corePoolCluster = this.poolCluster;
+    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);
+      corePoolCluster.query(sql, args, done);
+    });
+  }
+
+  execute(sql, args) {
+    const corePoolCluster = this.poolCluster;
+    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);
+      corePoolCluster.execute(sql, args, done);
+    });
+  }
+
+  of(pattern, selector) {
+    return new PromisePoolNamespace(
+      this.poolCluster.of(pattern, selector),
+      this.Promise
+    );
+  }
+
+  end() {
+    const corePoolCluster = this.poolCluster;
+    const localErr = new Error();
+    return new this.Promise((resolve, reject) => {
+      corePoolCluster.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.poolCluster._closed) {
+      await this.end();
+    }
+  }
+}
+
+/**
+ * proxy poolCluster synchronous functions
+ */
+(function (functionsToWrap) {
+  for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) {
+    const func = functionsToWrap[i];
+
+    if (
+      typeof PoolCluster.prototype[func] === 'function' &&
+      PromisePoolCluster.prototype[func] === undefined
+    ) {
+      PromisePoolCluster.prototype[func] = (function factory(funcName) {
+        return function () {
+          return PoolCluster.prototype[funcName].apply(
+            this.poolCluster,
+            arguments
+          );
+        };
+      })(func);
+    }
+  }
+})(['add', 'remove']);
+
+function createPromisePoolCluster(opts) {
+  const corePoolCluster = createPoolCluster(opts);
+  const thePromise = (opts && opts.Promise) || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+        'Use promise-enabled node version or pass userland Promise' +
+        " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+  return new PromisePoolCluster(corePoolCluster, thePromise);
+}
+
+exports.createConnection = createConnectionPromise;
+exports.createPool = createPromisePool;
+exports.createPoolCluster = createPromisePoolCluster;
+exports.escape = SqlString.escape;
+exports.escapeId = SqlString.escapeId;
+exports.format = SqlString.format;
+exports.raw = SqlString.raw;
+exports.PromisePool = PromisePool;
+exports.PromiseConnection = PromiseConnection;
+exports.PromisePoolConnection = PromisePoolConnection;
+
+exports.__defineGetter__('Types', () => require('./lib/constants/types.js'));
+
+exports.__defineGetter__('Charsets', () =>
+  require('./lib/constants/charsets.js')
+);
+
+exports.__defineGetter__('CharsetToEncoding', () =>
+  require('./lib/constants/charset_encodings.js')
+);
+
+exports.setMaxParserCache = function (max) {
+  parserCache.setMaxCache(max);
+};
+
+exports.clearParserCache = function () {
+  parserCache.clearCache();
+};

package/typings/mysql/LICENSE.txt

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2016, Felix Frederick Becker
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/typings/mysql/index.d.ts

@@ -0,0 +1,84 @@
+import { Pool as BasePool, PoolOptions } from './lib/Pool.js';
+import {
+  Connection as BaseConnection,
+  ConnectionOptions,
+  SslOptions,
+} from './lib/Connection.js';
+import {
+  Query as BaseQuery,
+  QueryOptions,
+  QueryError,
+} from './lib/protocol/sequences/Query.js';
+import {
+  PoolCluster as BasePoolCluster,
+  PoolClusterOptions,
+  PoolNamespace,
+} from './lib/PoolCluster.js';
+import { PoolConnection as BasePoolConnection } from './lib/PoolConnection.js';
+import {
+  Prepare as BasePrepare,
+  PrepareStatementInfo,
+} from './lib/protocol/sequences/Prepare.js';
+import { Server } from './lib/Server.js';
+import {
+  escape as SqlStringEscape,
+  escapeId as SqlStringEscapeId,
+  format as SqlStringFormat,
+  raw as SqlStringRaw,
+} from 'sql-escaper';
+export type { Raw, SqlValue, Timezone } from 'sql-escaper';
+
+export {
+  ConnectionOptions,
+  SslOptions,
+  PoolOptions,
+  PoolClusterOptions,
+  PoolNamespace,
+  QueryOptions,
+  QueryError,
+  PrepareStatementInfo,
+};
+
+export * from './lib/protocol/packets/index.js';
+export * from './lib/Auth.js';
+export * from './lib/constants/index.js';
+export * from './lib/parsers/index.js';
+export * from './lib/Connection.js';
+
+// Expose class interfaces
+export interface Connection extends BaseConnection {}
+export interface Pool extends BasePool {}
+export interface PoolConnection extends BasePoolConnection {}
+export interface PoolCluster extends BasePoolCluster {}
+export interface Query extends BaseQuery {}
+export interface Prepare extends BasePrepare {}
+
+export function createConnection(connectionUri: string): BaseConnection;
+export function createConnection(config: ConnectionOptions): BaseConnection;
+
+export function createPool(connectionUri: string): BasePool;
+export function createPool(config: PoolOptions): BasePool;
+
+export function createPoolCluster(config?: PoolClusterOptions): PoolCluster;
+
+export const escape: typeof SqlStringEscape;
+export const escapeId: typeof SqlStringEscapeId;
+export const format: typeof SqlStringFormat;
+export const raw: typeof SqlStringRaw;
+
+export interface ConnectionConfig extends ConnectionOptions {
+  mergeFlags(defaultFlags: string[], userFlags: string[] | string): number;
+  getDefaultFlags(options?: ConnectionOptions): string[];
+  getCharsetNumber(charset: string): number;
+  getSSLProfile(name: string): { ca: string[] };
+  parseUrl(url: string): {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    [key: string]: any;
+  };
+}
+
+export function createServer(handler: (conn: BaseConnection) => any): Server;

package/typings/mysql/info.txt

@@ -0,0 +1 @@
+temporary workaround, see https://github.com/sidorares/node-mysql2/issues/1210

package/typings/mysql/lib/Auth.d.ts

@@ -0,0 +1,30 @@
+import { RsaPublicKey, RsaPrivateKey, KeyLike } from 'crypto';
+import { Connection } from './Connection.js';
+
+export type AuthPlugin = (pluginMetadata: {
+  connection: Connection;
+  command: string;
+}) => (
+  pluginData: Buffer
+) => Promise<string> | string | Buffer | Promise<Buffer> | null;
+
+type AuthPluginDefinition<T> = (pluginOptions?: T) => AuthPlugin;
+
+export const authPlugins: {
+  caching_sha2_password: AuthPluginDefinition<{
+    overrideIsSecure?: boolean;
+    serverPublicKey?: RsaPublicKey | RsaPrivateKey | KeyLike;
+    onServerPublicKey?: (data: Buffer) => void;
+  }>;
+  mysql_clear_password: AuthPluginDefinition<{
+    password?: string;
+  }>;
+  mysql_native_password: AuthPluginDefinition<{
+    password?: string;
+    passwordSha1?: string;
+  }>;
+  sha256_password: AuthPluginDefinition<{
+    serverPublicKey?: RsaPublicKey | RsaPrivateKey | KeyLike;
+    onServerPublicKey?: (data: Buffer) => void;
+  }>;
+};