mysql2 3.22.6 → 3.22.7-canary.5034e57

package/lib/base/connection.js

@@ -87,6 +87,8 @@ class BaseConnection extends EventEmitter {
       },
     });
     this.serverCapabilityFlags = 0;
+    this._isMariaDB = false;
+    this._mariadbExtendedMetadata = false;
     this.authorized = false;
     this.sequenceId = 0;
     this.compressedSequenceId = 0;

package/lib/commands/client_handshake.js

@@ -13,6 +13,7 @@
 const Command = require('./command.js');
 const Packets = require('../packets/index.js');
 const ClientConstants = require('../constants/client.js');
+const MariaDBClientConstants = require('../constants/mariadb_client.js');
 const CharsetToEncoding = require('../constants/charset_encodings.js');
 const auth41 = require('../auth_41.js');
 const { getAuthPlugin } = require('./auth_switch.js');
@@ -35,6 +36,7 @@ class ClientHandshake extends Command {
     super();
     this.handshake = null;
     this.clientFlags = clientFlags;
+    this.mariadbExtendedClientFlags = 0;
     this.authenticationFactor = 0;
   }
 
@@ -45,7 +47,8 @@ class ClientHandshake extends Command {
   sendSSLRequest(connection) {
     const sslRequest = new Packets.SSLRequest(
       this.clientFlags,
-      connection.config.charsetNumber
+      connection.config.charsetNumber,
+      this.mariadbExtendedClientFlags
     );
     connection.writePacket(sslRequest.toPacket());
   }
@@ -130,6 +133,7 @@ class ClientHandshake extends Command {
 
     const handshakeResponse = new Packets.HandshakeResponse({
       flags: this.clientFlags,
+      mariadbExtendedClientFlags: this.mariadbExtendedClientFlags,
       user: this.user,
       database: this.database,
       password: this.password,
@@ -265,6 +269,26 @@ class ClientHandshake extends Command {
     connection.serverCapabilityFlags = this.handshake.capabilityFlags;
     connection.serverEncoding = CharsetToEncoding[this.handshake.characterSet];
     connection.connectionId = this.handshake.connectionId;
+    // MariaDB needs a few protocol deviations, e.g. it rejects the JSON
+    // parameter type in COM_STMT_EXECUTE
+    connection._isMariaDB = /mariadb/i.test(this.handshake.serverVersion);
+    // If a MariaDB server offers extended column metadata, request it so
+    // MariaDB-specific column types (UUID, INET4, INET6, VECTOR and the JSON
+    // alias) can be identified. The server only reads the extended client
+    // capability bytes when the client leaves CLIENT_MYSQL (LONG_PASSWORD)
+    // unset, mirroring the server side of the negotiation.
+    if (
+      this.handshake.mariadbExtendedCapabilityFlags &
+      MariaDBClientConstants.MARIADB_CLIENT_EXTENDED_METADATA
+    ) {
+      this.clientFlags &= ~ClientConstants.LONG_PASSWORD;
+      this.mariadbExtendedClientFlags |=
+        MariaDBClientConstants.MARIADB_CLIENT_EXTENDED_METADATA;
+    }
+    connection._mariadbExtendedMetadata = Boolean(
+      this.mariadbExtendedClientFlags &
+      MariaDBClientConstants.MARIADB_CLIENT_EXTENDED_METADATA
+    );
     const serverSSLSupport =
       this.handshake.capabilityFlags & ClientConstants.SSL;
     // multi factor authentication is enabled with the

package/lib/commands/execute.js

@@ -51,7 +51,8 @@ class Execute extends Command {
       connection.config.charsetNumber,
       connection.config.timezone,
       this._executeOptions.attributes,
-      clientFlags
+      clientFlags,
+      connection._isMariaDB
     );
     //For reasons why this try-catch is here, please see
     // https://github.com/sidorares/node-mysql2/pull/689
@@ -77,7 +78,8 @@ class Execute extends Command {
     //  this.statement.columns[this._receivedFieldsCount] : new Packets.ColumnDefinition(packet);
     const field = new Packets.ColumnDefinition(
       packet,
-      connection.clientEncoding
+      connection.clientEncoding,
+      connection._mariadbExtendedMetadata
     );
     this._receivedFieldsCount++;
     this._fields[this._resultIndex].push(field);

package/lib/commands/prepare.js

@@ -87,7 +87,11 @@ class Prepare extends Command {
       }
       return this.prepareDone(connection);
     }
-    const def = new Packets.ColumnDefinition(packet, connection.clientEncoding);
+    const def = new Packets.ColumnDefinition(
+      packet,
+      connection.clientEncoding,
+      connection._mariadbExtendedMetadata
+    );
     this.parameterDefinitions.push(def);
     if (this.parameterDefinitions.length === this.parameterCount) {
       return Prepare.prototype.parametersEOF;
@@ -99,7 +103,11 @@ class Prepare extends Command {
     if (packet.isEOF()) {
       return this.prepareDone(connection);
     }
-    const def = new Packets.ColumnDefinition(packet, connection.clientEncoding);
+    const def = new Packets.ColumnDefinition(
+      packet,
+      connection.clientEncoding,
+      connection._mariadbExtendedMetadata
+    );
     this.fields.push(def);
     if (this.fields.length === this.fieldCount) {
       return Prepare.prototype.fieldsEOF;

package/lib/commands/query.js

@@ -199,7 +199,8 @@ class Query extends Command {
     if (this._fields[this._resultIndex].length !== this._fieldCount) {
       const field = new Packets.ColumnDefinition(
         packet,
-        connection.clientEncoding
+        connection.clientEncoding,
+        connection._mariadbExtendedMetadata
       );
       this._fields[this._resultIndex].push(field);
       if (connection.config.debug) {

package/lib/constants/charset_encodings.js

@@ -3,7 +3,7 @@
 // see tools/generate-charset-mapping.js
 // basicalliy result of "SHOW COLLATION" query
 
-module.exports = [
+const encodings = [
   'utf8',
   'big5',
   'latin2',
@@ -315,3 +315,27 @@ module.exports = [
   'utf8',
   'utf8',
 ];
+
+// MariaDB NO PAD collations mirror their PAD SPACE counterparts:
+// collation id = PAD SPACE collation id + 1024
+const padSpaceLength = encodings.length;
+for (let id = 1025; id < 1024 + padSpaceLength; id++) {
+  encodings[id] = encodings[id - 1024];
+}
+
+// MariaDB UCA-14.0.0 (uca1400) collations use fixed 256-id blocks
+// per character set, each covering the PAD SPACE and NO PAD variants
+const uca1400Blocks = [
+  [2048, 'cesu8'], // utf8mb3
+  [2304, 'utf8'], // utf8mb4
+  [2560, 'ucs2'], // ucs2
+  [2816, 'utf16'], // utf16
+  [3072, 'utf32'], // utf32
+];
+for (const [start, encoding] of uca1400Blocks) {
+  for (let id = start; id < start + 256; id++) {
+    encodings[id] = encoding;
+  }
+}
+
+module.exports = encodings;

package/lib/constants/mariadb_client.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// MariaDB-specific extended capability flags.
+//
+// MariaDB servers (10.2+) do not set the CLIENT_MYSQL (LONG_PASSWORD)
+// capability and instead use 4 reserved bytes of the initial handshake packet
+// to advertise these flags. Clients answer with their own extended
+// capabilities in the last 4 reserved bytes of the handshake response
+// (the server only reads them when the client leaves CLIENT_MYSQL unset).
+//
+// The flags below are the lower 32 bits shifted down, i.e.
+// MARIADB_CLIENT_PROGRESS is documented as 1 << 32.
+// https://mariadb.com/docs/server/reference/clientserver-protocol/1-connecting/connection
+exports.MARIADB_CLIENT_PROGRESS = 0x00000001;
+exports.MARIADB_CLIENT_COM_MULTI = 0x00000002; /* deprecated */
+exports.MARIADB_CLIENT_STMT_BULK_OPERATIONS = 0x00000004;
+exports.MARIADB_CLIENT_EXTENDED_METADATA = 0x00000008;
+exports.MARIADB_CLIENT_CACHE_METADATA = 0x00000010;
+exports.MARIADB_CLIENT_BULK_UNIT_RESULTS = 0x00000020;

package/lib/packets/column_definition.js

@@ -19,7 +19,7 @@ const fields = ['catalog', 'schema', 'table', 'orgTable', 'name', 'orgName'];
 // see https://github.com/sidorares/node-mysql2/pull/137
 //
 class ColumnDefinition {
-  constructor(packet, clientEncoding) {
+  constructor(packet, clientEncoding, mariadbExtendedMetadata) {
     this._buf = packet.buffer;
     this._clientEncoding = clientEncoding;
     this._catalogLength = packet.readLengthCodedNumber();
@@ -41,6 +41,14 @@ class ColumnDefinition {
     this._orgNameLength = packet.readLengthCodedNumber();
     this._orgNameStart = packet.offset;
     packet.offset += this._orgNameLength;
+    // MariaDB-specific column types (UUID, INET4, INET6, VECTOR and the JSON
+    // alias) are sent as standard string/blob types on the wire; the real
+    // type is only visible here, in the extended metadata block negotiated
+    // via the MARIADB_CLIENT_EXTENDED_METADATA capability (parsed out of
+    // line and with prototype defaults to keep this hot constructor small)
+    if (mariadbExtendedMetadata) {
+      this._parseMariadbExtendedMetadata(packet);
+    }
     packet.skip(1); //  length of the following fields (always 0x0c)
     this.characterSet = packet.readInt16();
     this.encoding = CharsetToEncoding[this.characterSet];
@@ -57,6 +65,27 @@ class ColumnDefinition {
     this.decimals = packet.readInt8();
   }
 
+  _parseMariadbExtendedMetadata(packet) {
+    // length-encoded block of { int<1> id, string<lenenc> value } pairs
+    const extendedMetadataLength = packet.readLengthCodedNumber() || 0;
+    const extendedMetadataEnd = Math.min(
+      packet.offset + extendedMetadataLength,
+      packet.end
+    );
+    while (packet.offset < extendedMetadataEnd) {
+      const id = packet.readInt8();
+      const value = packet.readLengthCodedString('ascii');
+      if (id === 0) {
+        this.extendedTypeName = value; // e.g. 'uuid', 'inet4', 'inet6', 'point'
+      } else if (id === 1) {
+        this.extendedFormat = value; // e.g. 'json'
+      }
+    }
+    // a malformed entry could read past the block; resynchronise so the
+    // fixed column definition fields that follow parse from the right offset
+    packet.offset = extendedMetadataEnd;
+  }
+
   inspect() {
     return {
       catalog: this.catalog,
@@ -288,4 +317,9 @@ addString('table');
 addString('orgTable');
 addString('orgName');
 
+// MariaDB extended metadata defaults; instances only carry own values when
+// the server actually tagged the column
+ColumnDefinition.prototype.extendedTypeName = undefined;
+ColumnDefinition.prototype.extendedFormat = undefined;
+
 module.exports = ColumnDefinition;

package/lib/packets/encode_parameter.js

@@ -11,7 +11,7 @@ function isJSON(value) {
   );
 }
 
-function toParameter(value, encoding, timezone) {
+function toParameter(value, encoding, timezone, jsonAsString) {
   let type = Types.VAR_STRING;
   let length;
   let writer = function (value) {
@@ -46,8 +46,18 @@ function toParameter(value, encoding, timezone) {
           };
         } else if (isJSON(value)) {
           value = JSON.stringify(value);
-          type = Types.JSON;
+          // MariaDB rejects the JSON parameter type with "Incorrect
+          // arguments to mysqld_stmt_execute"; it expects JSON values
+          // as plain strings
+          if (!jsonAsString) {
+            type = Types.JSON;
+          }
         } else if (Buffer.isBuffer(value)) {
+          // send buffers as BLOB so servers treat the value as binary data
+          // rather than a string in the connection charset (MariaDB converts
+          // string parameters when storing into binary columns such as
+          // VECTOR, corrupting the value)
+          type = Types.BLOB;
           length = Packet.lengthCodedNumberLength(value.length) + value.length;
           writer = Packet.prototype.writeLengthCodedBuffer;
         }

package/lib/packets/execute.js

@@ -15,7 +15,8 @@ class Execute {
     charsetNumber,
     timezone,
     attributes,
-    clientFlags
+    clientFlags,
+    jsonAsString
   ) {
     this.id = id;
     this.parameters = parameters;
@@ -23,6 +24,7 @@ class Execute {
     this.timezone = timezone;
     this.attributes = attributes;
     this.clientFlags = clientFlags || 0;
+    this.jsonAsString = jsonAsString || false;
   }
 
   static fromPacket(packet, encoding) {
@@ -34,6 +36,7 @@ class Execute {
     while (i < packet.end - 1) {
       if (
         (packet.buffer[i + 1] === Types.VAR_STRING ||
+          packet.buffer[i + 1] === Types.BLOB ||
           packet.buffer[i + 1] === Types.NULL ||
           packet.buffer[i + 1] === Types.DOUBLE ||
           packet.buffer[i + 1] === Types.TINY ||
@@ -54,6 +57,7 @@ class Execute {
     for (let i = packet.offset + 1; i < packet.end - 1; i++) {
       if (
         (packet.buffer[i] === Types.VAR_STRING ||
+          packet.buffer[i] === Types.BLOB ||
           packet.buffer[i] === Types.NULL ||
           packet.buffer[i] === Types.DOUBLE ||
           packet.buffer[i] === Types.TINY ||
@@ -72,6 +76,8 @@ class Execute {
     for (let i = 0; i < types.length; i++) {
       if (types[i] === Types.VAR_STRING) {
         values.push(packet.readLengthCodedString(encoding));
+      } else if (types[i] === Types.BLOB) {
+        values.push(packet.readLengthCodedBuffer());
       } else if (types[i] === Types.DOUBLE) {
         values.push(packet.readDouble());
       } else if (types[i] === Types.TINY) {
@@ -119,7 +125,7 @@ class Execute {
       const bindParams =
         numParams > 0
           ? this.parameters.map((v) =>
-              toParameter(v, this.encoding, this.timezone)
+              toParameter(v, this.encoding, this.timezone, this.jsonAsString)
             )
           : [];
       const attrParams = attrNames.map((name) =>

package/lib/packets/handshake.js

@@ -16,6 +16,7 @@ class Handshake {
     this.characterSet = args.characterSet;
     this.statusFlags = args.statusFlags;
     this.authPluginName = args.authPluginName;
+    this.mariadbExtendedCapabilityFlags = args.mariadbExtendedCapabilityFlags;
   }
 
   setScrambleData(cb) {
@@ -79,9 +80,20 @@ class Handshake {
         args.authPluginDataLength = 0;
         packet.skip(1);
       }
-      packet.skip(10);
+      packet.skip(6);
+      if (args.capabilityFlags & ClientConstants.LONG_PASSWORD) {
+        // CLIENT_MYSQL (LONG_PASSWORD) set: a MySQL server, the remaining
+        // 4 reserved bytes are filler
+        packet.skip(4);
+        args.mariadbExtendedCapabilityFlags = 0;
+      } else {
+        // MariaDB servers (10.2+) leave CLIENT_MYSQL unset and use these
+        // 4 bytes to advertise MariaDB-specific capabilities
+        args.mariadbExtendedCapabilityFlags = packet.readInt32();
+      }
     } else {
       args.capabilityFlags = capabilityFlagsBuffer.readUInt16LE(0);
+      args.mariadbExtendedCapabilityFlags = 0;
     }
 
     const isSecureConnection =

package/lib/packets/handshake_response.js

@@ -16,6 +16,7 @@ class HandshakeResponse {
     this.authPluginData2 = handshake.authPluginData2;
     this.compress = handshake.compress;
     this.clientFlags = handshake.flags;
+    this.mariadbExtendedClientFlags = handshake.mariadbExtendedClientFlags || 0;
 
     // Accept pre-calculated authToken and authPluginName from caller
     // This allows the caller to optimize by using the server's preferred auth method
@@ -69,7 +70,10 @@ class HandshakeResponse {
     packet.writeInt32(this.clientFlags);
     packet.writeInt32(0); // max packet size. todo: move to config
     packet.writeInt8(this.charsetNumber);
-    packet.skip(23);
+    // the last 4 of the 23 reserved bytes carry the MariaDB extended client
+    // capabilities (zero when not negotiated, i.e. plain filler)
+    packet.skip(19);
+    packet.writeInt32(this.mariadbExtendedClientFlags);
     const encoding = this.encoding;
     packet.writeNullTerminatedString(this.user, encoding);
     let k;

package/lib/packets/ssl_request.js

@@ -4,9 +4,10 @@ const ClientConstants = require('../constants/client');
 const Packet = require('../packets/packet');
 
 class SSLRequest {
-  constructor(flags, charset) {
+  constructor(flags, charset, mariadbExtendedClientFlags) {
     this.clientFlags = flags | ClientConstants.SSL;
     this.charset = charset;
+    this.mariadbExtendedClientFlags = mariadbExtendedClientFlags || 0;
   }
 
   toPacket() {
@@ -18,6 +19,10 @@ class SSLRequest {
     packet.writeInt32(this.clientFlags);
     packet.writeInt32(0); // max packet size. todo: move to config
     packet.writeInt8(this.charset);
+    // the last 4 of the 23 reserved bytes carry the MariaDB extended client
+    // capabilities (zero when not negotiated, i.e. plain filler)
+    packet.skip(19);
+    packet.writeInt32(this.mariadbExtendedClientFlags);
     return packet;
   }
 }

package/lib/parsers/binary_parser.js

@@ -21,6 +21,13 @@ function readCodeFor(field, config, options, fieldNum) {
   const timezone = options.timezone || config.timezone;
   const dateStrings = options.dateStrings || config.dateStrings;
   const unsigned = field.flags & FieldFlags.UNSIGNED;
+  // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+  // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+  if (field.extendedFormat === 'json') {
+    return config.jsonStrings
+      ? `packet.readLengthCodedString(fields[${fieldNum}].encoding)`
+      : `JSON.parse(packet.readLengthCodedString(fields[${fieldNum}].encoding));`;
+  }
   switch (field.columnType) {
     case Types.TINY:
       return unsigned ? 'packet.readInt8();' : 'packet.readSInt8();';
@@ -92,6 +99,8 @@ function compile(fields, options, config) {
   function wrap(field, packet) {
     return {
       type: typeNames[field.columnType],
+      extendedTypeName: field.extendedTypeName,
+      extendedFormat: field.extendedFormat,
       length: field.columnLength,
       db: field.schema,
       table: field.table,

package/lib/parsers/parser_cache.js

@@ -20,6 +20,7 @@ function keyFromFields(type, fields, options, config) {
     options.timezone || config.timezone,
     Boolean(options.decimalNumbers),
     options.dateStrings,
+    Boolean(config.jsonStrings),
   ];
 
   for (let i = 0; i < fields.length; ++i) {
@@ -33,6 +34,8 @@ function keyFromFields(type, fields, options, config) {
       field.table,
       field.flags,
       field.characterSet,
+      field.extendedTypeName,
+      field.extendedFormat,
     ]);
   }
 

package/lib/parsers/static_binary_parser.js

@@ -22,6 +22,14 @@ function getBinaryParser(fields, _options, config) {
     const dateStrings = options.dateStrings || config.dateStrings;
     const unsigned = field.flags & FieldFlags.UNSIGNED;
 
+    // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+    // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+    if (field.extendedFormat === 'json') {
+      return config.jsonStrings
+        ? packet.readLengthCodedString(field.encoding)
+        : JSON.parse(packet.readLengthCodedString(field.encoding));
+    }
+
     switch (field.columnType) {
       case Types.TINY:
         return unsigned ? packet.readInt8() : packet.readSInt8();
@@ -120,6 +128,8 @@ function getBinaryParser(fields, _options, config) {
               ? typeCast(
                   {
                     type: typeNames[field.columnType],
+                    extendedTypeName: field.extendedTypeName,
+                    extendedFormat: field.extendedFormat,
                     length: field.columnLength,
                     db: field.schema,
                     table: field.table,

package/lib/parsers/static_text_parser.js

@@ -9,7 +9,15 @@ for (const t in Types) {
   typeNames[Types[t]] = t;
 }
 
-function readField({ packet, type, charset, encoding, config, options }) {
+function readField({
+  packet,
+  field,
+  type,
+  charset,
+  encoding,
+  config,
+  options,
+}) {
   const supportBigNumbers = Boolean(
     options.supportBigNumbers || config.supportBigNumbers
   );
@@ -19,6 +27,14 @@ function readField({ packet, type, charset, encoding, config, options }) {
   const timezone = options.timezone || config.timezone;
   const dateStrings = options.dateStrings || config.dateStrings;
 
+  // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+  // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+  if (field.extendedFormat === 'json') {
+    return config.jsonStrings
+      ? packet.readLengthCodedString(encoding)
+      : JSON.parse(packet.readLengthCodedString(encoding));
+  }
+
   switch (type) {
     case Types.TINY:
     case Types.SHORT:
@@ -76,6 +92,8 @@ function readField({ packet, type, charset, encoding, config, options }) {
 function createTypecastField(field, packet) {
   return {
     type: typeNames[field.columnType],
+    extendedTypeName: field.extendedTypeName,
+    extendedFormat: field.extendedFormat,
     length: field.columnLength,
     db: field.schema,
     table: field.table,
@@ -110,6 +128,7 @@ function getTextParser(_fields, _options, config) {
         const next = () =>
           readField({
             packet,
+            field,
             type: field.columnType,
             encoding: field.encoding,
             charset: field.characterSet,

package/lib/parsers/text_parser.js

@@ -11,7 +11,9 @@ for (const t in Types) {
   typeNames[Types[t]] = t;
 }
 
-function readCodeFor(type, charset, encodingExpr, config, options) {
+function readCodeFor(field, encodingExpr, config, options) {
+  const type = field.columnType;
+  const charset = field.characterSet;
   const supportBigNumbers = Boolean(
     options.supportBigNumbers || config.supportBigNumbers
   );
@@ -21,6 +23,14 @@ function readCodeFor(type, charset, encodingExpr, config, options) {
   const timezone = options.timezone || config.timezone;
   const dateStrings = options.dateStrings || config.dateStrings;
 
+  // MariaDB sends JSON values as LONGTEXT; the JSON type is only visible in
+  // the extended metadata (MARIADB_CLIENT_EXTENDED_METADATA capability)
+  if (field.extendedFormat === 'json') {
+    return config.jsonStrings
+      ? `packet.readLengthCodedString(${encodingExpr})`
+      : `JSON.parse(packet.readLengthCodedString(${encodingExpr}))`;
+  }
+
   switch (type) {
     case Types.TINY:
     case Types.SHORT:
@@ -88,6 +98,8 @@ function compile(fields, options, config) {
   function wrap(field, _this) {
     return {
       type: typeNames[field.columnType],
+      extendedTypeName: field.extendedTypeName,
+      extendedFormat: field.extendedFormat,
       length: field.columnLength,
       db: field.schema,
       table: field.table,
@@ -174,13 +186,7 @@ function compile(fields, options, config) {
       parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
     } else {
       const encodingExpr = `fields[${i}].encoding`;
-      const readCode = readCodeFor(
-        fields[i].columnType,
-        fields[i].characterSet,
-        encodingExpr,
-        config,
-        options
-      );
+      const readCode = readCodeFor(fields[i], encodingExpr, config, options);
       if (typeof options.typeCast === 'function') {
         parserFn(
           `${lvalue} = options.typeCast(this.wrap${i}, function() { return ${readCode} });`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.22.6",
+  "version": "3.22.7-canary.5034e57",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "typings": "typings/mysql/index",

package/typings/mysql/lib/parsers/typeCast.d.ts

@@ -40,6 +40,17 @@ export type Type = {
 };
 
 export type Field = Type & {
+  /**
+   * MariaDB extended data type name (e.g. `uuid`, `inet4`, `inet6`, `point`),
+   * available when the server supports the MARIADB_CLIENT_EXTENDED_METADATA
+   * capability (MariaDB 10.5+)
+   */
+  extendedTypeName?: string;
+  /**
+   * MariaDB extended format name (e.g. `json`), available when the server
+   * supports the MARIADB_CLIENT_EXTENDED_METADATA capability (MariaDB 10.5+)
+   */
+  extendedFormat?: string;
   length: number;
   db: string;
   table: string;

package/typings/mysql/lib/protocol/packets/FieldPacket.d.ts

@@ -22,6 +22,17 @@ declare interface FieldPacket {
   typeName?: string;
   encoding?: string;
   columnLength?: number;
+  /**
+   * MariaDB extended data type name (e.g. `uuid`, `inet4`, `inet6`, `point`),
+   * available when the server supports the MARIADB_CLIENT_EXTENDED_METADATA
+   * capability (MariaDB 10.5+)
+   */
+  extendedTypeName?: string;
+  /**
+   * MariaDB extended format name (e.g. `json`), available when the server
+   * supports the MARIADB_CLIENT_EXTENDED_METADATA capability (MariaDB 10.5+)
+   */
+  extendedFormat?: string;
 }
 
 export { FieldPacket };