mysql2 3.3.5 → 3.4.1

package/typings/mysql/lib/protocol/sequences/Query.d.ts

@@ -1,148 +1,151 @@
+import { Sequence } from './Sequence.js';
+import { OkPacket, RowDataPacket, FieldPacket } from '../packets/index.js';
+import { Readable } from 'stream';
+
+export interface QueryOptions {
+  /**
+   * The SQL for the query
+   */
+  sql: string;
+
+  /**
+   * The values for the query
+   */
+  values?: any | any[] | { [param: string]: any };
+
+  /**
+   * This overrides the namedPlaceholders option set at the connection level.
+   */
+  namedPlaceholders?: boolean;
+
+  /**
+   * Every operation takes an optional inactivity timeout option. This allows you to specify appropriate timeouts for
+   * operations. It is important to note that these timeouts are not part of the MySQL protocol, and rather timeout
+   * operations through the client. This means that when a timeout is reached, the connection it occurred on will be
+   * destroyed and no further operations can be performed.
+   */
+  timeout?: number;
+
+  /**
+   * Either a boolean or string. If true, tables will be nested objects. If string (e.g. '_'), tables will be
+   * nested as tableName_fieldName
+   */
+  nestTables?: any;
+
+  /**
+   * Determines if column values should be converted to native JavaScript types. It is not recommended (and may go away / change in the future)
+   * to disable type casting, but you can currently do so on either the connection or query level. (Default: true)
+   *
+   * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
+   *
+   * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
+   *
+   * field.string()
+   * field.buffer()
+   * field.geometry()
+   *
+   * are aliases for
+   *
+   * parser.parseLengthCodedString()
+   * parser.parseLengthCodedBuffer()
+   * parser.parseGeometryValue()
+   *
+   * You can find which field function you need to use by looking at: RowDataPacket.prototype._typeCast
+   */
+  typeCast?: any;
+
+  /**
+   * This overrides the same option set at the connection level.
+   *
+   */
+  rowsAsArray?: boolean;
+
+  /**
+   * By specifying a function that returns a readable stream, an arbitrary stream can be sent when sending a local fs file.
+   */
+  infileStreamFactory?: (path: string) => Readable;
+}
+
+export interface StreamOptions {
+  /**
+   * Sets the max buffer size in objects of a stream
+   */
+  highWaterMark?: number;
 
-import Sequence = require('./Sequence');
-import {OkPacket, RowDataPacket, FieldPacket} from '../packets/index';
-import {Readable} from 'stream';
-
-declare namespace Query {
-
-    export interface QueryOptions {
-        /**
-         * The SQL for the query
-         */
-        sql: string;
-
-        /**
-         * The values for the query
-         */
-        values?: any | any[] | { [param: string]: any };
-
-        /**
-         * This overrides the namedPlaceholders option set at the connection level.
-         */
-        namedPlaceholders?: boolean;
-
-        /**
-         * Every operation takes an optional inactivity timeout option. This allows you to specify appropriate timeouts for
-         * operations. It is important to note that these timeouts are not part of the MySQL protocol, and rather timeout
-         * operations through the client. This means that when a timeout is reached, the connection it occurred on will be
-         * destroyed and no further operations can be performed.
-         */
-        timeout?: number;
-
-        /**
-         * Either a boolean or string. If true, tables will be nested objects. If string (e.g. '_'), tables will be
-         * nested as tableName_fieldName
-         */
-        nestTables?: any;
-
-        /**
-         * Determines if column values should be converted to native JavaScript types. It is not recommended (and may go away / change in the future)
-         * to disable type casting, but you can currently do so on either the connection or query level. (Default: true)
-         *
-         * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
-         *
-         * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
-         *
-         * field.string()
-         * field.buffer()
-         * field.geometry()
-         *
-         * are aliases for
-         *
-         * parser.parseLengthCodedString()
-         * parser.parseLengthCodedBuffer()
-         * parser.parseGeometryValue()
-         *
-         * You can find which field function you need to use by looking at: RowDataPacket.prototype._typeCast
-         */
-        typeCast?: any;
-
-        /**
-         * This overrides the same option set at the connection level.
-         *
-         */
-        rowsAsArray?: boolean
-
-        /**
-         * By specifying a function that returns a readable stream, an arbitrary stream can be sent when sending a local fs file.
-         */
-        infileStreamFactory?: (path: string) => Readable;
-    }
-
-    export interface StreamOptions {
-        /**
-         * Sets the max buffer size in objects of a stream
-         */
-        highWaterMark?: number;
-
-        /**
-         * The object mode of the stream (Default: true)
-         */
-        objectMode?: any;
-    }
-
-    export interface QueryError extends NodeJS.ErrnoException {
-        /**
-         * Either a MySQL server error (e.g. 'ER_ACCESS_DENIED_ERROR'),
-         * a node.js error (e.g. 'ECONNREFUSED') or an internal error
-         * (e.g. 'PROTOCOL_CONNECTION_LOST').
-         */
-        code: string;
-
-        /**
-         * The sql state marker
-         */
-        sqlStateMarker?: string;
-
-        /**
-         * The sql state
-         */
-        sqlState?: string;
-
-        /**
-         * The field count
-         */
-        fieldCount?: number;
-
-        /**
-         * Boolean, indicating if this error is terminal to the connection object.
-         */
-        fatal: boolean;
-    }
+  /**
+   * The object mode of the stream (Default: true)
+   */
+  objectMode?: any;
 }
 
-declare class Query extends Sequence {
+export interface QueryError extends NodeJS.ErrnoException {
+  /**
+   * Either a MySQL server error (e.g. 'ER_ACCESS_DENIED_ERROR'),
+   * a node.js error (e.g. 'ECONNREFUSED') or an internal error
+   * (e.g. 'PROTOCOL_CONNECTION_LOST').
+   */
+  code: string;
+
+  /**
+   * The sql state marker
+   */
+  sqlStateMarker?: string;
+
+  /**
+   * The sql state
+   */
+  sqlState?: string;
+
+  /**
+   * The field count
+   */
+  fieldCount?: number;
+
+  /**
+   * Boolean, indicating if this error is terminal to the connection object.
+   */
+  fatal: boolean;
+}
 
-    /**
-     * The SQL for a constructed query
-     */
-    sql: string;
-
-    /**
-     * Emits a query packet to start the query
-     */
-    start(): void;
-
-    /**
-     * Determines the packet class to use given the first byte of the packet.
-     *
-     * @param firstByte The first byte of the packet
-     * @param parser The packet parser
-     */
-    determinePacket(firstByte: number, parser: any): any;
-
-    /**
-     * Creates a Readable stream with the given options
-     *
-     * @param options The options for the stream.
-     */
-    stream(options?: Query.StreamOptions): Readable;
-
-    on(event: string, listener: Function): this;
-    on(event: 'error', listener: (err: Query.QueryError) => any): this;
-    on(event: 'fields', listener: (fields: FieldPacket, index: number) => any): this;
-    on(event: 'result', listener: (result: RowDataPacket | OkPacket, index: number) => any): this;
-    on(event: 'end', listener: () => any): this;
+declare class Query extends Sequence {
+  /**
+   * The SQL for a constructed query
+   */
+  sql: string;
+
+  /**
+   * Emits a query packet to start the query
+   */
+  start(): void;
+
+  /**
+   * Determines the packet class to use given the first byte of the packet.
+   *
+   * @param firstByte The first byte of the packet
+   * @param parser The packet parser
+   */
+  determinePacket(firstByte: number, parser: any): any;
+
+  /**
+   * Creates a Readable stream with the given options
+   *
+   * @param options The options for the stream.
+   */
+  stream(options?: StreamOptions): Readable;
+
+  on(event: string, listener: (args: any[]) => void): this;
+  on(event: 'error', listener: (err: QueryError) => any): this;
+  on(
+    event: 'fields',
+    listener: (fields: FieldPacket, index: number) => any
+  ): this;
+  on(
+    event: 'result',
+    listener: (result: RowDataPacket | OkPacket, index: number) => any
+  ): this;
+  on(event: 'end', listener: () => any): this;
 }
 
-export = Query;
+export type QueryableConstructor<T = object> = new (...args: any[]) => T;
+
+export { Query };

package/typings/mysql/lib/protocol/sequences/QueryableBase.ts

@@ -0,0 +1,104 @@
+import {
+  OkPacket,
+  FieldPacket,
+  RowDataPacket,
+  ResultSetHeader,
+} from '../packets/index.js';
+import {
+  Query,
+  QueryError,
+  QueryOptions,
+  QueryableConstructor,
+} from './Query.js';
+
+export function QueryableBase<T extends QueryableConstructor>(
+  Base: T = {} as T
+) {
+  return class extends Base {
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      sql: string,
+      callback?: (
+        err: QueryError | null,
+        result: T,
+        fields: FieldPacket[]
+      ) => any
+    ): Query;
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      sql: string,
+      values: any | any[] | { [param: string]: any },
+      callback?: (
+        err: QueryError | null,
+        result: T,
+        fields: FieldPacket[]
+      ) => any
+    ): Query;
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      options: QueryOptions,
+      callback?: (
+        err: QueryError | null,
+        result: T,
+        fields?: FieldPacket[]
+      ) => any
+    ): Query;
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      options: QueryOptions,
+      values: any | any[] | { [param: string]: any },
+      callback?: (
+        err: QueryError | null,
+        result: T,
+        fields: FieldPacket[]
+      ) => any
+    ): Query;
+
+    // Implementing all overload variations
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    query(
+      options: QueryOptions | string,
+      values?:
+        | any
+        | any[]
+        | { [param: string]: any }
+        | ((
+            err: QueryError | null,
+            result: any,
+            fields?: FieldPacket[]
+          ) => any),
+      callback?: (
+        err: QueryError | null,
+        result: any,
+        fields: FieldPacket[]
+      ) => any
+    ): Query {
+      return new Query();
+    }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  };
+}

package/typings/mysql/lib/protocol/sequences/Sequence.d.ts

@@ -1,5 +1,5 @@
+import { EventEmitter } from 'events';
 
-import {EventEmitter} from 'events';
+declare class Sequence extends EventEmitter {}
 
-declare class Sequence extends EventEmitter { }
-export = Sequence;
+export { Sequence };

package/typings/mysql/lib/protocol/sequences/promise/ExecutableBase.ts

@@ -0,0 +1,69 @@
+import {
+  OkPacket,
+  FieldPacket,
+  RowDataPacket,
+  ResultSetHeader,
+} from '../../packets/index.js';
+import { Query, QueryOptions, QueryableConstructor } from '../Query.js';
+
+export function ExecutableBase<T extends QueryableConstructor>(
+  Base: T = {} as T
+) {
+  return class extends Base {
+    execute<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(sql: string): Promise<[T, FieldPacket[]]>;
+    execute<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      sql: string,
+      values: any | any[] | { [param: string]: any }
+    ): Promise<[T, FieldPacket[]]>;
+    execute<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(options: QueryOptions): Promise<[T, FieldPacket[]]>;
+    execute<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      options: QueryOptions,
+      values: any | any[] | { [param: string]: any }
+    ): Promise<[T, FieldPacket[]]>;
+
+    // Implementing all overload variations
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    execute<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      sql: string | QueryOptions,
+      values?: any | any[] | { [param: string]: any }
+    ): Promise<[T, FieldPacket[]]> {
+      return new Promise(() => new Query());
+    }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  };
+}

package/typings/mysql/lib/protocol/sequences/promise/QueryableBase.ts

@@ -0,0 +1,69 @@
+import {
+  OkPacket,
+  FieldPacket,
+  RowDataPacket,
+  ResultSetHeader,
+} from '../../packets/index.js';
+import { Query, QueryOptions, QueryableConstructor } from '../Query.js';
+
+export function QueryableBase<T extends QueryableConstructor>(
+  Base: T = {} as T
+) {
+  return class extends Base {
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(sql: string): Promise<[T, FieldPacket[]]>;
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      sql: string,
+      values: any | any[] | { [param: string]: any }
+    ): Promise<[T, FieldPacket[]]>;
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(options: QueryOptions): Promise<[T, FieldPacket[]]>;
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      options: QueryOptions,
+      values: any | any[] | { [param: string]: any }
+    ): Promise<[T, FieldPacket[]]>;
+
+    // Implementing all overload variations
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    query<
+      T extends
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+    >(
+      sql: string | QueryOptions,
+      values?: any | any[] | { [param: string]: any }
+    ): Promise<[T, FieldPacket[]]> {
+      return new Promise(() => new Query());
+    }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  };
+}