@vlasky/zongji 0.5.9 → 0.6.0

package/lib/common.js

@@ -1,9 +1,9 @@
-const iconv = require('iconv-lite');
-const decodeJson = require('./json_decode');
-const dtDecode = require('./datetime_decode');
-const bigInt = require('big-integer');
+import iconv from 'iconv-lite';
+import decodeJson from './json_decode.js';
+import * as dtDecode from './datetime_decode.js';
+import bigInt from 'big-integer';
 
-const MysqlTypes = exports.MysqlTypes = {
+export const MysqlTypes = {
   DECIMAL: 0,
   TINY: 1,
   SHORT: 2,
@@ -42,9 +42,9 @@ const MysqlTypes = exports.MysqlTypes = {
 const TWO_TO_POWER_THIRTY_TWO = Math.pow(2, 32);
 const TWO_TO_POWER_SIXTY_THREE = '9223372036854775808'; // Math.pow(2, 63) or 1 << 63
 // This function will return a Number
-// if the reuslt < Math.MAX_SAFE_INTEGER or reuslt > Math.MIN_SAFE_INTEGER,
+// if the result < Math.MAX_SAFE_INTEGER or result > Math.MIN_SAFE_INTEGER,
 // otherwise, will return a string.
-const parseUInt64 = exports.parseUInt64 = function(parser) {
+export const parseUInt64 = function(parser) {
   const low = parser.parseUnsignedNumber(4);
   const high = parser.parseUnsignedNumber(4);
 
@@ -55,19 +55,19 @@ const parseUInt64 = exports.parseUInt64 = function(parser) {
   return (high * Math.pow(2,32)) + low;
 };
 
-exports.parseUInt48 = function(parser) {
+export function parseUInt48(parser) {
   const low = parser.parseUnsignedNumber(4);
   const high = parser.parseUnsignedNumber(2);
   return (high * Math.pow(2, 32)) + low;
 };
 
-const parseUInt24 = exports.parseUInt24 = function(parser) {
+export const parseUInt24 = function(parser) {
   const low = parser.parseUnsignedNumber(2);
   const high = parser.parseUnsignedNumber(1);
   return (high << 16) + low;
 };
 
-exports.parseBytesArray = function(parser, length) {
+export function parseBytesArray(parser, length) {
   const result = new Array(length);
   for (let i = 0; i < length; i++) {
     result[i] = parser.parseUnsignedNumber(1);
@@ -88,13 +88,13 @@ const parseSetEnumTypeDef = function(type, prefixLen) {
     });
 };
 
-const zeroPad = exports.zeroPad = function(num, size) {
+export const zeroPad = function(num, size) {
   // Max 32 digits
   const s = '00000000000000000000000000000000' + num;
   return s.substr(s.length-size);
 };
 
-const sliceBits = exports.sliceBits = function(input, start, end) {
+export const sliceBits = function(input, start, end) {
   // ex: start: 10, end: 15 = "111110000000000"
   const match = (((1 << end) - 1) ^ ((1 << start) - 1));
   return (input & match) >> start;
@@ -102,7 +102,7 @@ const sliceBits = exports.sliceBits = function(input, start, end) {
 
 // Use Typed Arrays to convert IEEE 754 numbers
 // Pass only high for 32-bit float, pass high and low for 64-bit double
-const parseIEEE754Float = exports.parseIEEE754Float = function(high, low) {
+export const parseIEEE754Float = function(high, low) {
   if (low !== undefined) {
     let value = new DataView(new ArrayBuffer(8));
     value.setUint32(0, high);
@@ -115,7 +115,7 @@ const parseIEEE754Float = exports.parseIEEE754Float = function(high, low) {
   }
 };
 
-const getUInt32Value = exports.getUInt32Value = function(input) {
+export function getUInt32Value(input) {
   // Last bit is not sign, it is part of value!
   if (input & (1 << 31)) return Math.pow(2, 31) + (input & ((1 << 31) -1));
   else return input;
@@ -312,6 +312,7 @@ const parseGeometryValue = function(buffer) {
 
 // Returns false, or an object describing the fraction of a second part of a
 // TIME, DATETIME, or TIMESTAMP.
+/** @returns {false | { value: number, precision: number, milliseconds: number }} */
 const readTemporalFraction = function(parser, fractionPrecision) {
   if (!fractionPrecision) return false;
   let fractionSize = Math.ceil(fractionPrecision / 2);
@@ -340,7 +341,7 @@ const readTemporalFraction = function(parser, fractionPrecision) {
 // The parser object contains the raw value, and functions useful for value
 // interpretation, but not the underlying column type or how the value ought to
 // be interpreted based on that column type.
-exports.readMysqlValue = function(
+export function readMysqlValue(
     parser,       // node-mysql parser instance, from mysql/lib/protocol/Parser
     column,       // tableMap.columns[columnNumber]
     columnSchema, // tableMap.columnSchemas[columnNumber]
@@ -471,7 +472,8 @@ exports.readMysqlValue = function(
         zongji.connection.config.dateStrings, // node-mysql dateStrings option
         sliceBits(raw, 9, 24),     // year
         sliceBits(raw, 5, 9),      // month
-        sliceBits(raw, 0, 5)       // day
+        sliceBits(raw, 0, 5),      // day
+        zongji.connection.config.timezone
       );
       break;
     case MysqlTypes.TIME:
@@ -526,7 +528,9 @@ exports.readMysqlValue = function(
         date % 100,                           // day
         Math.floor(time / 10000),             // hour
         Math.floor((time % 10000) / 100),     // minutes
-        time % 100                            // seconds
+        time % 100,                           // seconds
+        undefined,                            // fraction
+        zongji.connection.config.timezone
       );
       break;
     case MysqlTypes.DATETIME2: {
@@ -545,21 +549,30 @@ exports.readMysqlValue = function(
         sliceBits(rawLow, 12, 17),  // hour
         sliceBits(rawLow, 6, 12),   // minutes
         sliceBits(rawLow, 0, 6),    // seconds
-        fraction                    // fraction of a second object
+        fraction,                   // fraction of a second object
+        zongji.connection.config.timezone
       );
       break;
     }
     case MysqlTypes.TIMESTAMP:
       raw = parser.parseUnsignedNumber(4);
-      result = dtDecode.getTimeStamp(zongji.connection.config.dateStrings, raw);
+      result = dtDecode.getTimeStamp(
+        zongji.connection.config.dateStrings,
+        raw,
+        undefined,
+        zongji.connection.config.timezone
+      );
       break;
     case MysqlTypes.TIMESTAMP2:
       raw = readIntBE(parser._buffer, parser._offset, 4);
       parser._offset += 4;
       fraction = readTemporalFraction(parser, column.metadata.decimals);
-      result = dtDecode.getTimeStamp(zongji.connection.config.dateStrings,
-                                     raw,       // seconds from epoch
-                                     fraction); // fraction of a second object
+      result = dtDecode.getTimeStamp(
+        zongji.connection.config.dateStrings,
+        raw,       // seconds from epoch
+        fraction,  // fraction of a second object
+        zongji.connection.config.timezone
+      );
       break;
     case MysqlTypes.YEAR:
       raw = parser.parseUnsignedNumber(1);

package/lib/datetime_decode.js

@@ -3,7 +3,7 @@
 // dateStrings option.  The dateStrings option should be read from
 // zongji.connection.config, where zongji is the current instance of the ZongJi
 // object.  The dateStrings option is interpreted the same as in node-mysql.
-const common = require('./common'); // used only for common.zeroPad
+import { zeroPad } from './common.js';
 
 // dateStrings are used only if the dateStrings option is true, or is an array
 // containing the sql type name string, 'DATE', 'DATETIME', or 'TIMESTAMP'.
@@ -16,19 +16,19 @@ const useDateStringsForType = function(dateStrings, sqlTypeString) {
 
 // fraction is the fractional second object from readTemporalFraction().
 // returns '' or a '.' followed by fraction.precision digits, like '.123'
-const getFractionString = exports.getFractionString = function(fraction) {
+export const getFractionString = function(fraction) {
   return fraction ?
-         '.' + common.zeroPad(fraction.value, fraction.precision) :
+         '.' + zeroPad(fraction.value, fraction.precision) :
          '';
 };
 
 // 1950-00-00 and the like are perfectly valid Mysql dateStrings.  A 0 portion
 // of a date is essentially a null part of the date, so we should keep it.
 // year, month, and date must be integers >= 0.  January is month === 1.
-const getDateString = exports.getDateString = function(year, month, date) {
-  return common.zeroPad(year, 4) + '-' +
-         common.zeroPad(month, 2) + '-' +
-         common.zeroPad(date, 2);
+export const getDateString = function(year, month, date) {
+  return zeroPad(year, 4) + '-' +
+         zeroPad(month, 2) + '-' +
+         zeroPad(date, 2);
 };
 
 // Date object months are 1 less than Mysql months, and we need to filter 0.
@@ -44,16 +44,65 @@ const jsMonthFromMysqlMonth = function(month) {
 // option.  With the dateStrings option, it can output valid Mysql DATE strings
 // representing values that cannot be represented by a Date object, such as
 // values with a null part like '1950-00-04', or a zero date '0000-00-00'.
-exports.getDate = function(dateStrings, // node-mysql dateStrings option
+const createDateFromParts = function(year,
+                                     month,
+                                     date,
+                                     hour,
+                                     minute,
+                                     second,
+                                     millisecond,
+                                     timezone) {
+  const jsMonth = jsMonthFromMysqlMonth(month);
+  if (!timezone || timezone === 'local') {
+    return new Date(year,
+                    jsMonth,
+                    date,
+                    hour,
+                    minute,
+                    second,
+                    millisecond);
+  }
+
+  const utcTime = Date.UTC(year,
+                           jsMonth,
+                           date,
+                           hour,
+                           minute,
+                           second,
+                           millisecond);
+  if (timezone === 'Z') {
+    return new Date(utcTime);
+  }
+
+  const offsetMinutes = getTimezoneOffsetMinutes(timezone);
+  if (offsetMinutes === null) {
+    return new Date(year,
+                    jsMonth,
+                    date,
+                    hour,
+                    minute,
+                    second,
+                    millisecond);
+  }
+  return new Date(utcTime - offsetMinutes * 60000);
+};
+
+export function getDate(dateStrings, // node-mysql dateStrings option
                            year,
                            month,       // January === 1
-                           date
+                           date,
+                           timezone
                           )
 {
   if (!useDateStringsForType(dateStrings, 'DATE')) {
-    return new Date(year,
-                    jsMonthFromMysqlMonth(month),
-                    date);
+    return createDateFromParts(year,
+                               month,
+                               date,
+                               0,
+                               0,
+                               0,
+                               0,
+                               timezone);
   }
   return getDateString(year, month, date);
 };
@@ -62,40 +111,103 @@ exports.getDate = function(dateStrings, // node-mysql dateStrings option
 // option.  Fraction is an optional parameter that comes from
 // readTemporalFraction().  Mysql dateStrings are needed for microsecond
 // precision, or to represent '0000-00-00 00:00:00'.
-exports.getDateTime = function(dateStrings, // node-mysql dateStrings option
+export function getDateTime(dateStrings, // node-mysql dateStrings option
                                year,
                                month,       // January === 1
                                date,
                                hour,
                                minute,
                                second,
-                               fraction     // optional fractional second object
+                               fraction,    // optional fractional second object
+                               timezone
                               )
 {
   if (!useDateStringsForType(dateStrings, 'DATETIME')) {
-    return new Date(year,
-                    jsMonthFromMysqlMonth(month),
-                    date,
-                    hour,
-                    minute,
-                    second,
-                    fraction ? fraction.milliseconds : 0);
+    return createDateFromParts(year,
+                               month,
+                               date,
+                               hour,
+                               minute,
+                               second,
+                               fraction ? fraction.milliseconds : 0,
+                               timezone);
   }
   return getDateString(year, month, date) + ' ' +
-         common.zeroPad(hour, 2) + ':' +
-         common.zeroPad(minute, 2) + ':' +
-         common.zeroPad(second, 2) +
+         zeroPad(hour, 2) + ':' +
+         zeroPad(minute, 2) + ':' +
+         zeroPad(second, 2) +
          getFractionString(fraction);
-};
+}
 
 // Returns a new Date object or Mysql dateString, following the dateStrings
 // option.  Fraction is an optional parameter that comes from
 // readTemporalFraction().  With the dateStrings option from node-mysql,
 // this returns a mysql TIMESTAMP string, like '1975-03-01 23:03:20.38945' or
 // '1975-03-01 00:03:20'.  Mysql strings are needed for precision beyond ms.
-exports.getTimeStamp = function(dateStrings, // node-mysql dateStrings option
+const getTimezoneOffsetMinutes = function(timezone) {
+  if (!timezone || timezone === 'local' || timezone === 'Z') {
+    return null;
+  }
+  const match = timezone.match(/^([+-])(\d\d):(\d\d)$/);
+  if (!match) {
+    return null;
+  }
+  const sign = match[1] === '-' ? -1 : 1;
+  const hours = parseInt(match[2], 10);
+  const minutes = parseInt(match[3], 10);
+  return sign * (hours * 60 + minutes);
+};
+
+const getTimeComponents = function(dateObject, timezone) {
+  if (!timezone || timezone === 'local') {
+    return {
+      year: dateObject.getFullYear(),
+      month: dateObject.getMonth() + 1,
+      day: dateObject.getDate(),
+      hours: dateObject.getHours(),
+      minutes: dateObject.getMinutes(),
+      seconds: dateObject.getSeconds(),
+    };
+  }
+
+  if (timezone === 'Z') {
+    return {
+      year: dateObject.getUTCFullYear(),
+      month: dateObject.getUTCMonth() + 1,
+      day: dateObject.getUTCDate(),
+      hours: dateObject.getUTCHours(),
+      minutes: dateObject.getUTCMinutes(),
+      seconds: dateObject.getUTCSeconds(),
+    };
+  }
+
+  const offsetMinutes = getTimezoneOffsetMinutes(timezone);
+  if (offsetMinutes === null) {
+    return {
+      year: dateObject.getFullYear(),
+      month: dateObject.getMonth() + 1,
+      day: dateObject.getDate(),
+      hours: dateObject.getHours(),
+      minutes: dateObject.getMinutes(),
+      seconds: dateObject.getSeconds(),
+    };
+  }
+
+  const shifted = new Date(dateObject.getTime() + offsetMinutes * 60000);
+  return {
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth() + 1,
+    day: shifted.getUTCDate(),
+    hours: shifted.getUTCHours(),
+    minutes: shifted.getUTCMinutes(),
+    seconds: shifted.getUTCSeconds(),
+  };
+};
+
+export function getTimeStamp(dateStrings, // node-mysql dateStrings option
                                 secondsFromEpoch, // an integer
-                                fraction // optional fraction of second object
+                                fraction, // optional fraction of second object
+                                timezone // mysql2 timezone option
                                )
 {
   const milliseconds = fraction ? fraction.milliseconds : 0;
@@ -106,11 +218,12 @@ exports.getTimeStamp = function(dateStrings, // node-mysql dateStrings option
   if (secondsFromEpoch === 0 && (!fraction || fraction.value === 0)) {
     return '0000-00-00 00:00:00' + getFractionString(fraction);
   }
-  return getDateString(dateObject.getFullYear(),
-                       dateObject.getMonth() + 1,
-                       dateObject.getDate()) + ' ' +
-         common.zeroPad(dateObject.getHours(), 2) + ':' +
-         common.zeroPad(dateObject.getMinutes(), 2) + ':' +
-         common.zeroPad(dateObject.getSeconds(), 2) +
+  const parts = getTimeComponents(dateObject, timezone);
+  return getDateString(parts.year,
+                       parts.month,
+                       parts.day) + ' ' +
+         zeroPad(parts.hours, 2) + ':' +
+         zeroPad(parts.minutes, 2) + ':' +
+         zeroPad(parts.seconds, 2) +
          getFractionString(fraction);
-};
+}

package/lib/json_decode.js

@@ -1,5 +1,5 @@
-const common = require('./common');
-const Parser = require('@vlasky/mysql/lib/protocol/Parser');
+import * as common from './common.js';
+import { Parser } from './reader.js';
 
 const JSONB_TYPE_SMALL_OBJECT = 0;
 const JSONB_TYPE_LARGE_OBJECT = 1;
@@ -21,12 +21,12 @@ const JSONB_LITERALS = [ null, true, false ];
 // node-mysql prefixes binary string values
 const VAR_STRING_PREFIX = 'base64:type253:';
 
-module.exports = function(input) {
+export default function decodeJson(input) {
   // Value must be JSON string to match node-mysql results
   // Related to this node-mysql PR:
   // https://github.com/felixge/node-mysql/pull/1299
   return JSON.stringify(parseBinaryBuffer(input));
-};
+}
 
 /*
  * @func  parseBinaryBuffer
@@ -69,7 +69,7 @@ function parseBinaryBuffer(input, offset, parentValueOffset, readUInt, isLarge)
     }
     // All other types are retrieved from pointer
     case JSONB_TYPE_STRING: {
-      let strLen, strLenSize = 0, curStrLenByte;
+      let strLen = 0, strLenSize = 0, curStrLenByte;
       // If the high bit is 1, the string length continues to the next byte
       while (strLenSize === 0 || (curStrLenByte & 128) === 128) {
         strLenSize++;
@@ -135,7 +135,7 @@ function parseBinaryBuffer(input, offset, parentValueOffset, readUInt, isLarge)
     }
     case JSONB_TYPE_OPAQUE: {
       const customType = input.readUInt8(valueOffset + 1);
-      let dataLen, dataLenSize = 0, curDataLenByte;
+      let dataLen = 0, dataLenSize = 0, curDataLenByte;
       // If the high bit is 1, the string length continues to the next byte
       while (dataLenSize === 0 || (curDataLenByte & 128) === 128) {
         dataLenSize++;
@@ -216,9 +216,15 @@ function parseBinaryBuffer(input, offset, parentValueOffset, readUInt, isLarge)
             decimals: parser.parseUnsignedNumber(1),
           };
           break;
+        case common.MysqlTypes.VARCHAR:
+          result = 'base64:type15:' + parser._buffer.toString('base64');
+          break;
         case common.MysqlTypes.VAR_STRING:
           result = VAR_STRING_PREFIX + parser._buffer.toString('base64');
           break;
+        case common.MysqlTypes.STRING:
+          result = 'base64:type254:' + parser._buffer.toString('base64');
+          break;
         default:
           throw new Error('JSON Opaque Type Not Implemented: ' + customType);
       }

package/lib/packet/binlog.js

@@ -1,7 +1,7 @@
-const getEventClass = require('../code_map').getEventClass;
+import { getEventClass } from '../code_map.js';
 
 //TODO Don't depend on zongji instance here
-module.exports = function initBinlogPacketClass(zongji) {
+export default function initBinlogPacketClass(zongji) {
 
   class BinlogPacket {
 
@@ -37,7 +37,7 @@ module.exports = function initBinlogPacketClass(zongji) {
       try {
         this._event = new EventClass(parser, options, zongji);
       } catch (err) {
-        // Record error occurence but suppress until handled
+        // Record error occurrence but suppress until handled
         this._error = err;
       }
     }

package/lib/packet/combinlog.js

@@ -1,25 +1,27 @@
-function ComBinlog({ serverId, nonBlock, filename, position }) {
-  this.command = 0x12;
-  this.position = position || 4;
+class ComBinlog {
+  constructor({ serverId, nonBlock, filename, position }) {
+    this.command = 0x12;
+    this.position = position || 4;
 
-  // will send eof package if there is no more binlog event
-  // https://dev.mysql.com/doc/internals/en/com-binlog-dump.html#binlog-dump-non-block
-  this.flags = nonBlock ? 1 : 0;
+    // will send eof package if there is no more binlog event
+    // https://dev.mysql.com/doc/internals/en/com-binlog-dump.html#binlog-dump-non-block
+    this.flags = nonBlock ? 1 : 0;
 
-  this.serverId = serverId || 1;
-  this.filename = filename || '';
-}
+    this.serverId = serverId || 1;
+    this.filename = filename || '';
+  }
 
-ComBinlog.prototype.write = function(writer) {
-  writer.writeUnsignedNumber(1, this.command);
-  writer.writeUnsignedNumber(4, this.position);
-  writer.writeUnsignedNumber(2, this.flags);
-  writer.writeUnsignedNumber(4, this.serverId);
-  writer.writeNullTerminatedString(this.filename);
-};
+  write(writer) {
+    writer.writeUnsignedNumber(1, this.command);
+    writer.writeUnsignedNumber(4, this.position);
+    writer.writeUnsignedNumber(2, this.flags);
+    writer.writeUnsignedNumber(4, this.serverId);
+    writer.writeNullTerminatedString(this.filename);
+  }
 
-ComBinlog.prototype.parse = function() {
-  throw new Error('should never be callede here');
-};
+  parse() {
+    throw new Error('should never be called here');
+  }
+}
 
-module.exports = ComBinlog;
+export default ComBinlog;

package/lib/packet/index.js

@@ -1,66 +1,66 @@
-// from npm package mysql
-function EofPacket(options) {
-  options = options || {};
+import ComBinlog from './combinlog.js';
+import initBinlogPacketClass from './binlog.js';
 
-  this.fieldCount   = undefined;
-  this.warningCount = options.warningCount;
-  this.serverStatus = options.serverStatus;
-  this.protocol41   = options.protocol41;
-}
+// from npm package mysql
+class EofPacket {
+  constructor(options = {}) {
+    this.fieldCount = undefined;
+    this.warningCount = options.warningCount;
+    this.serverStatus = options.serverStatus;
+    this.protocol41 = options.protocol41;
+  }
 
-EofPacket.prototype.parse = function(parser) {
-  this.fieldCount   = parser.parseUnsignedNumber(1);
-  if (this.protocol41) {
-    this.warningCount = parser.parseUnsignedNumber(2);
-    this.serverStatus = parser.parseUnsignedNumber(2);
+  parse(parser) {
+    this.fieldCount = parser.parseUnsignedNumber(1);
+    if (this.protocol41) {
+      this.warningCount = parser.parseUnsignedNumber(2);
+      this.serverStatus = parser.parseUnsignedNumber(2);
+    }
   }
-};
 
-EofPacket.prototype.write = function(writer) {
-  writer.writeUnsignedNumber(1, 0xfe);
-  if (this.protocol41) {
-    writer.writeUnsignedNumber(2, this.warningCount);
-    writer.writeUnsignedNumber(2, this.serverStatus);
+  write(writer) {
+    writer.writeUnsignedNumber(1, 0xfe);
+    if (this.protocol41) {
+      writer.writeUnsignedNumber(2, this.warningCount);
+      writer.writeUnsignedNumber(2, this.serverStatus);
+    }
   }
-};
+}
 
 // from npm package mysql
-function ErrorPacket(options) {
-  options = options || {};
+class ErrorPacket {
+  constructor(options = {}) {
+    this.fieldCount = options.fieldCount;
+    this.errno = options.errno;
+    this.sqlStateMarker = options.sqlStateMarker;
+    this.sqlState = options.sqlState;
+    this.message = options.message;
+  }
 
-  this.fieldCount     = options.fieldCount;
-  this.errno          = options.errno;
-  this.sqlStateMarker = options.sqlStateMarker;
-  this.sqlState       = options.sqlState;
-  this.message        = options.message;
-}
+  parse(parser) {
+    this.fieldCount = parser.parseUnsignedNumber(1);
+    this.errno = parser.parseUnsignedNumber(2);
 
-ErrorPacket.prototype.parse = function(parser) {
-  this.fieldCount = parser.parseUnsignedNumber(1);
-  this.errno      = parser.parseUnsignedNumber(2);
+    // sqlStateMarker ('#' = 0x23) indicates error packet format
+    if (parser.peak() === 0x23) {
+      this.sqlStateMarker = parser.parseString(1);
+      this.sqlState = parser.parseString(5);
+    }
 
-  // sqlStateMarker ('#' = 0x23) indicates error packet format
-  if (parser.peak() === 0x23) {
-    this.sqlStateMarker = parser.parseString(1);
-    this.sqlState       = parser.parseString(5);
+    this.message = parser.parsePacketTerminatedString();
   }
 
-  this.message = parser.parsePacketTerminatedString();
-};
+  write(writer) {
+    writer.writeUnsignedNumber(1, 0xff);
+    writer.writeUnsignedNumber(2, this.errno);
 
-ErrorPacket.prototype.write = function(writer) {
-  writer.writeUnsignedNumber(1, 0xff);
-  writer.writeUnsignedNumber(2, this.errno);
+    if (this.sqlStateMarker) {
+      writer.writeString(this.sqlStateMarker);
+      writer.writeString(this.sqlState);
+    }
 
-  if (this.sqlStateMarker) {
-    writer.writeString(this.sqlStateMarker);
-    writer.writeString(this.sqlState);
+    writer.writeString(this.message);
   }
+}
 
-  writer.writeString(this.message);
-};
-
-exports.EofPacket = EofPacket;
-exports.ErrorPacket = ErrorPacket;
-exports.ComBinlog = require('./combinlog');
-exports.initBinlogPacketClass = require('./binlog');
+export { EofPacket, ErrorPacket, ComBinlog, initBinlogPacketClass };