fix(types): extend QueryValues to callback-based methods

test/global/test-load-infile.test.mts

@@ -22,6 +22,7 @@ await describe('Load Infile', async () => {
     .query<RowDataPacket[]>('SELECT @@GLOBAL.local_infile as backup');
   const originalLocalInfile = savedLocalInfile[0].backup;
 
+  // @ts-expect-error: strict.ifError is an assertion function incompatible with query callback type
   connection.query('SET GLOBAL local_infile = true', strict.ifError);
   connection.query(
     [

test/integration/connection/test-bind-undefined.test.mts

@@ -0,0 +1,48 @@
+import type { RowDataPacket } from '../../../index.js';
+import { describe, it, strict } from 'poku';
+import { createConnection } from '../../common.test.mjs';
+
+await describe('Bind Undefined', async () => {
+  const connection = createConnection().promise();
+
+  await it('execute: should throw TypeError for undefined parameter', async () => {
+    await strict.rejects(
+      // @ts-expect-error: testing that undefined bind parameter throws TypeError
+      connection.execute('SELECT ? AS result', [undefined]),
+      {
+        name: 'TypeError',
+        message:
+          'Bind parameters must not contain undefined. To pass SQL NULL specify JS null',
+      }
+    );
+  });
+
+  await it('execute: should accept undefined as values (no bind parameters)', async () => {
+    const [results] = await connection.execute<RowDataPacket[]>(
+      'SELECT 1 AS result',
+      undefined
+    );
+
+    strict.strictEqual(results[0].result, 1);
+  });
+
+  await it('query: should accept undefined bind parameter as NULL', async () => {
+    const [results] = await connection.query<RowDataPacket[]>(
+      'SELECT ? AS result',
+      [undefined]
+    );
+
+    strict.strictEqual(results[0].result, null);
+  });
+
+  await it('query: should accept undefined as values (no bind parameters)', async () => {
+    const [results] = await connection.query<RowDataPacket[]>(
+      'SELECT 1 AS result',
+      undefined
+    );
+
+    strict.strictEqual(results[0].result, 1);
+  });
+
+  await connection.end();
+});

typings/mysql/lib/protocol/sequences/ExecutableBase.d.ts

@@ -3,6 +3,7 @@ import {
   Query,
   QueryError,
   QueryOptions,
+  ExecuteValues,
   QueryableConstructor,
 } from './Query.js';
 
@@ -18,20 +19,20 @@ export declare function ExecutableBase<T extends QueryableConstructor>(
     ): Query;
     execute<T extends QueryResult>(
       sql: string,
-      values: any,
+      values: ExecuteValues,
       callback?:
         | ((err: QueryError | null, result: T, fields: FieldPacket[]) => any)
         | undefined
     ): Query;
     execute<T extends QueryResult>(
       options: QueryOptions,
       callback?:
-        | ((err: QueryError | null, result: T, fields?: FieldPacket[]) => any)
+        | ((err: QueryError | null, result: T, fields: FieldPacket[]) => any)
         | undefined
     ): Query;
     execute<T extends QueryResult>(
       options: QueryOptions,
-      values: any,
+      values: ExecuteValues,
       callback?:
         | ((err: QueryError | null, result: T, fields: FieldPacket[]) => any)
         | undefined

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

@@ -4,7 +4,7 @@ import { Readable } from 'stream';
 import { Timezone } from 'sql-escaper';
 import { TypeCast } from '../../parsers/typeCast.js';
 
-export type QueryValues =
+export type ExecuteValues =
   | string
   | number
   | bigint
@@ -14,6 +14,18 @@ export type QueryValues =
   | Blob
   | Buffer
   | ({} | null)[]
+  | { [key: string]: ExecuteValues };
+
+export type QueryValues =
+  | string
+  | number
+  | bigint
+  | boolean
+  | Date
+  | null
+  | Blob
+  | Buffer
+  | ({} | null | undefined)[]
   | { [key: string]: QueryValues };
 
 export interface QueryOptions {

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

@@ -3,6 +3,7 @@ import {
   Query,
   QueryError,
   QueryOptions,
+  QueryValues,
   QueryableConstructor,
 } from './Query.js';
 
@@ -18,20 +19,20 @@ export declare function QueryableBase<T extends QueryableConstructor>(
     ): Query;
     query<T extends QueryResult>(
       sql: string,
-      values: any,
+      values: QueryValues,
       callback?:
         | ((err: QueryError | null, result: T, fields: FieldPacket[]) => any)
         | undefined
     ): Query;
     query<T extends QueryResult>(
       options: QueryOptions,
       callback?:
-        | ((err: QueryError | null, result: T, fields?: FieldPacket[]) => any)
+        | ((err: QueryError | null, result: T, fields: FieldPacket[]) => any)
         | undefined
     ): Query;
     query<T extends QueryResult>(
       options: QueryOptions,
-      values: any,
+      values: QueryValues,
       callback?:
         | ((err: QueryError | null, result: T, fields: FieldPacket[]) => any)
         | undefined

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

@@ -1,17 +1,17 @@
 import { FieldPacket, QueryResult } from '../../packets/index.js';
-import { QueryOptions, QueryableConstructor, QueryValues } from '../Query.js';
+import { QueryOptions, QueryableConstructor, ExecuteValues } from '../Query.js';
 
 export declare function ExecutableBase<T extends QueryableConstructor>(
   Base?: T
 ): {
   new (...args: any[]): {
     execute<T extends QueryResult>(
       sql: string,
-      values?: QueryValues
+      values?: ExecuteValues
     ): Promise<[T, FieldPacket[]]>;
     execute<T extends QueryResult>(
       options: QueryOptions,
-      values?: QueryValues
+      values?: ExecuteValues
     ): Promise<[T, FieldPacket[]]>;
   };
 } & T;

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

@@ -1,18 +1,18 @@
 import { FieldPacket, QueryResult } from '../../packets/index.js';
-import { QueryOptions, QueryableConstructor } from '../Query.js';
+import { QueryOptions, QueryValues, QueryableConstructor } from '../Query.js';
 
 export declare function QueryableBase<T extends QueryableConstructor>(
   Base?: T
 ): {
   new (...args: any[]): {
     query<T extends QueryResult>(
       sql: string,
-      values?: any
+      values?: QueryValues
     ): Promise<[T, FieldPacket[]]>;
 
     query<T extends QueryResult>(
       options: QueryOptions,
-      values?: any
+      values?: QueryValues
     ): Promise<[T, FieldPacket[]]>;
   };
 } & T;