tedious 2.2.3 → 2.2.4

package/lib/data-types/timen.js

@@ -0,0 +1,95 @@
+'use strict';
+
+module.exports = {
+  id: 0x29,
+  type: 'TIMEN',
+  name: 'TimeN',
+  aliases: ['Time'],
+  hasScale: true,
+  dataLengthLength: 1,
+
+  dataLengthFromScale: function dataLengthFromScale(scale) {
+    switch (scale) {
+      case 0:
+      case 1:
+      case 2:
+        return 3;
+      case 3:
+      case 4:
+        return 4;
+      case 5:
+      case 6:
+      case 7:
+        return 5;
+    }
+  },
+
+  declaration: function declaration(parameter) {
+    return 'time(' + this.resolveScale(parameter) + ')';
+  },
+
+  resolveScale: function resolveScale(parameter) {
+    if (parameter.scale != null) {
+      return parameter.scale;
+    } else if (parameter.value === null) {
+      return 0;
+    } else {
+      return 7;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeUInt8(parameter.scale);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter, options) {
+    if (parameter.value != null) {
+      var time = new Date(+parameter.value);
+
+      var timestamp = void 0;
+      if (options.useUTC) {
+        timestamp = ((time.getUTCHours() * 60 + time.getUTCMinutes()) * 60 + time.getUTCSeconds()) * 1000 + time.getUTCMilliseconds();
+      } else {
+        timestamp = ((time.getHours() * 60 + time.getMinutes()) * 60 + time.getSeconds()) * 1000 + time.getMilliseconds();
+      }
+
+      timestamp = timestamp * Math.pow(10, parameter.scale - 3);
+      timestamp += (parameter.value.nanosecondDelta != null ? parameter.value.nanosecondDelta : 0) * Math.pow(10, parameter.scale);
+      timestamp = Math.round(timestamp);
+
+      switch (parameter.scale) {
+        case 0:
+        case 1:
+        case 2:
+          buffer.writeUInt8(3);
+          buffer.writeUInt24LE(timestamp);
+        case 3:
+        case 4:
+          buffer.writeUInt8(4);
+          buffer.writeUInt32LE(timestamp);
+        case 5:
+        case 6:
+        case 7:
+          buffer.writeUInt8(5);
+          buffer.writeUInt40LE(timestamp);
+      }
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (value instanceof Date) {
+      return value;
+    }
+    value = Date.parse(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid time.');
+    }
+    return value;
+  }
+};

package/lib/data-types/tinyint.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var IntN = require('./intn');
+
+module.exports = {
+  id: 0x30,
+  type: 'INT1',
+  name: 'TinyInt',
+
+  declaration: function declaration() {
+    return 'tinyint';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(IntN.id);
+    buffer.writeUInt8(1);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(1);
+      buffer.writeUInt8(parseInt(parameter.value));
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    value = parseInt(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    if (value < 0 || value > 255) {
+      return new TypeError('Value must be between 0 and 255.');
+    }
+    return value;
+  }
+};

package/lib/data-types/tvp.js

@@ -0,0 +1,83 @@
+'use strict';
+
+module.exports = {
+  id: 0xF3,
+  type: 'TVPTYPE',
+  name: 'TVP',
+
+  declaration: function declaration(parameter) {
+    return parameter.value.name + ' readonly';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    var ref = void 0,
+        ref1 = void 0,
+        ref2 = void 0,
+        ref3 = void 0;
+    buffer.writeUInt8(this.id);
+    buffer.writeBVarchar('');
+    buffer.writeBVarchar((ref = (ref1 = parameter.value) != null ? ref1.schema : undefined) != null ? ref : '');
+    buffer.writeBVarchar((ref2 = (ref3 = parameter.value) != null ? ref3.name : undefined) != null ? ref2 : '');
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter, options) {
+    if (parameter.value == null) {
+      buffer.writeUInt16LE(0xFFFF);
+      buffer.writeUInt8(0x00);
+      buffer.writeUInt8(0x00);
+      return;
+    }
+
+    buffer.writeUInt16LE(parameter.value.columns.length);
+
+    var ref = parameter.value.columns;
+    for (var i = 0, len = ref.length; i < len; i++) {
+      var column = ref[i];
+      buffer.writeUInt32LE(0x00000000);
+      buffer.writeUInt16LE(0x0000);
+      column.type.writeTypeInfo(buffer, column);
+      buffer.writeBVarchar('');
+    }
+
+    buffer.writeUInt8(0x00);
+
+    var ref1 = parameter.value.rows;
+    for (var j = 0, len1 = ref1.length; j < len1; j++) {
+      var row = ref1[j];
+
+      buffer.writeUInt8(0x01);
+
+      for (var k = 0, len2 = row.length; k < len2; k++) {
+        var value = row[k];
+        var param = {
+          value: value,
+          length: parameter.value.columns[k].length,
+          scale: parameter.value.columns[k].scale,
+          precision: parameter.value.columns[k].precision
+        };
+        parameter.value.columns[k].type.writeParameterData(buffer, param, options);
+      }
+    }
+
+    buffer.writeUInt8(0x00);
+  },
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+
+    if (typeof value !== 'object') {
+      return new TypeError('Invalid table.');
+    }
+
+    if (!Array.isArray(value.columns)) {
+      return new TypeError('Invalid table.');
+    }
+
+    if (!Array.isArray(value.rows)) {
+      return new TypeError('Invalid table.');
+    }
+
+    return value;
+  }
+};

package/lib/data-types/udt.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0xF0,
+  type: 'UDTTYPE',
+  name: 'UDT',
+  hasUDTInfo: true
+};

package/lib/data-types/uniqueidentifiern.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var guidParser = require('../guid-parser');
+
+module.exports = {
+  id: 0x24,
+  type: 'GUIDN',
+  name: 'UniqueIdentifierN',
+  aliases: ['UniqueIdentifier'],
+  dataLengthLength: 1,
+
+  declaration: function declaration() {
+    return 'uniqueidentifier';
+  },
+
+  resolveLength: function resolveLength() {
+    return 16;
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(this.id);
+    buffer.writeUInt8(0x10);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(0x10);
+      buffer.writeBuffer(new Buffer(guidParser.guidToArray(parameter.value)));
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (typeof value !== 'string') {
+      if (typeof value.toString !== 'function') {
+        return TypeError('Invalid string.');
+      }
+      value = value.toString();
+    }
+    return value;
+  }
+};

package/lib/data-types/varbinary.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var NULL = (1 << 16) - 1;
+var MAX = (1 << 16) - 1;
+
+module.exports = {
+  id: 0xA5,
+  type: 'BIGVARBIN',
+  name: 'VarBinary',
+  dataLengthLength: 2,
+  maximumLength: 8000,
+
+  declaration: function declaration(parameter) {
+    var length = void 0;
+    if (parameter.length) {
+      length = parameter.length;
+    } else if (parameter.value != null) {
+      length = parameter.value.length || 1;
+    } else if (parameter.value === null && !parameter.output) {
+      length = 1;
+    } else {
+      length = this.maximumLength;
+    }
+
+    if (length <= this.maximumLength) {
+      return 'varbinary(' + length + ')';
+    } else {
+      return 'varbinary(max)';
+    }
+  },
+
+  resolveLength: function resolveLength(parameter) {
+    if (parameter.length != null) {
+      return parameter.length;
+    } else if (parameter.value != null) {
+      return parameter.value.length;
+    } else {
+      return this.maximumLength;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    if (parameter.length <= this.maximumLength) {
+      buffer.writeUInt16LE(this.maximumLength);
+    } else {
+      buffer.writeUInt16LE(MAX);
+    }
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      if (parameter.length <= this.maximumLength) {
+        buffer.writeUsVarbyte(parameter.value);
+      } else {
+        buffer.writePLPBody(parameter.value);
+      }
+    } else {
+      if (parameter.length <= this.maximumLength) {
+        buffer.writeUInt16LE(NULL);
+      } else {
+        buffer.writeUInt32LE(0xFFFFFFFF);
+        buffer.writeUInt32LE(0xFFFFFFFF);
+      }
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!Buffer.isBuffer(value)) {
+      return new TypeError('Invalid buffer.');
+    }
+    return value;
+  }
+};

package/lib/data-types/varchar.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var NULL = (1 << 16) - 1;
+var MAX = (1 << 16) - 1;
+
+module.exports = {
+  id: 0xA7,
+  type: 'BIGVARCHR',
+  name: 'VarChar',
+  hasCollation: true,
+  dataLengthLength: 2,
+  maximumLength: 8000,
+
+  declaration: function declaration(parameter) {
+    var length = void 0;
+    if (parameter.length) {
+      length = parameter.length;
+    } else if (parameter.value != null) {
+      length = parameter.value.toString().length || 1;
+    } else if (parameter.value === null && !parameter.output) {
+      length = 1;
+    } else {
+      length = this.maximumLength;
+    }
+
+    if (length <= this.maximumLength) {
+      return 'varchar(' + length + ')';
+    } else {
+      return 'varchar(max)';
+    }
+  },
+
+  resolveLength: function resolveLength(parameter) {
+    if (parameter.length != null) {
+      return parameter.length;
+    } else if (parameter.value != null) {
+      if (Buffer.isBuffer(parameter.value)) {
+        return parameter.value.length || 1;
+      } else {
+        return parameter.value.toString().length || 1;
+      }
+    } else {
+      return this.maximumLength;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    if (parameter.length <= this.maximumLength) {
+      buffer.writeUInt16LE(this.maximumLength);
+    } else {
+      buffer.writeUInt16LE(MAX);
+    }
+    buffer.writeBuffer(new Buffer([0x00, 0x00, 0x00, 0x00, 0x00]));
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      if (parameter.length <= this.maximumLength) {
+        buffer.writeUsVarbyte(parameter.value, 'ascii');
+      } else {
+        buffer.writePLPBody(parameter.value, 'ascii');
+      }
+    } else {
+      if (parameter.length <= this.maximumLength) {
+        buffer.writeUInt16LE(NULL);
+      } else {
+        buffer.writeUInt32LE(0xFFFFFFFF);
+        buffer.writeUInt32LE(0xFFFFFFFF);
+      }
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (typeof value !== 'string') {
+      if (typeof value.toString !== 'function') {
+        return TypeError('Invalid string.');
+      }
+      value = value.toString();
+    }
+    return value;
+  }
+};

package/lib/data-types/xml.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0xF1,
+  type: 'XML',
+  name: 'Xml',
+  hasSchemaPresent: true
+};

package/lib/instance-lookup.js

@@ -68,7 +68,7 @@ var InstanceLookup = function () {
 
       var onTimeout = function onTimeout() {
         sender.cancel();
-        return makeAttempt();
+        makeAttempt();
       };
 
       var makeAttempt = function makeAttempt() {
@@ -80,26 +80,27 @@ var InstanceLookup = function () {
           sender.execute(function (err, message) {
             clearTimeout(timer);
             if (err) {
-              return callback('Failed to lookup instance on ' + server + ' - ' + err.message);
+              callback('Failed to lookup instance on ' + server + ' - ' + err.message);
+              return;
             } else {
               message = message.toString('ascii', MYSTERY_HEADER_LENGTH);
               var port = _this.parseBrowserResponse(message, instanceName);
 
               if (port) {
-                return callback(undefined, port);
+                callback(undefined, port);
               } else {
-                return callback('Port for ' + instanceName + ' not found in ' + message);
+                callback('Port for ' + instanceName + ' not found in ' + message);
               }
             }
           });
 
-          return timer = setTimeout(onTimeout, timeout);
+          timer = setTimeout(onTimeout, timeout);
         } else {
-          return callback('Failed to get response from SQL Server Browser on ' + server);
+          callback('Failed to get response from SQL Server Browser on ' + server);
         }
       };
 
-      return makeAttempt();
+      makeAttempt();
     }
   }, {
     key: 'parseBrowserResponse',

package/lib/message-io.js

@@ -225,7 +225,7 @@ module.exports = function (_EventEmitter) {
     key: 'logPacket',
     value: function logPacket(direction, packet) {
       this.debug.packet(direction, packet);
-      return this.debug.data(packet);
+      this.debug.data(packet);
     }
 
     // Temporarily suspends the flow of incoming packets.

package/lib/packet.js

@@ -78,7 +78,7 @@ var Packet = function () {
   (0, _createClass3.default)(Packet, [{
     key: 'setLength',
     value: function setLength() {
-      return this.buffer.writeUInt16BE(this.buffer.length, OFFSET.Length);
+      this.buffer.writeUInt16BE(this.buffer.length, OFFSET.Length);
     }
   }, {
     key: 'length',
@@ -94,7 +94,7 @@ var Packet = function () {
       } else {
         status &= 0xFF - STATUS.RESETCONNECTION;
       }
-      return this.buffer.writeUInt8(status, OFFSET.Status);
+      this.buffer.writeUInt8(status, OFFSET.Status);
     }
   }, {
     key: 'last',

package/lib/prelogin-payload.js

@@ -95,7 +95,7 @@ module.exports = function () {
         optionDataOffset += _option.data.length;
       }
 
-      return this.data.writeUInt8(TOKEN.TERMINATOR, optionOffset);
+      this.data.writeUInt8(TOKEN.TERMINATOR, optionOffset);
     }
   }, {
     key: 'createVersionOption',
@@ -184,7 +184,7 @@ module.exports = function () {
   }, {
     key: 'extractVersion',
     value: function extractVersion(offset) {
-      return this.version = {
+      this.version = {
         major: this.data.readUInt8(offset + 0),
         minor: this.data.readUInt8(offset + 1),
         patch: this.data.readUInt8(offset + 2),
@@ -196,23 +196,23 @@ module.exports = function () {
     key: 'extractEncryption',
     value: function extractEncryption(offset) {
       this.encryption = this.data.readUInt8(offset);
-      return this.encryptionString = encryptByValue[this.encryption];
+      this.encryptionString = encryptByValue[this.encryption];
     }
   }, {
     key: 'extractInstance',
     value: function extractInstance(offset) {
-      return this.instance = this.data.readUInt8(offset);
+      this.instance = this.data.readUInt8(offset);
     }
   }, {
     key: 'extractThreadId',
     value: function extractThreadId(offset) {
-      return this.threadId = this.data.readUInt32BE(offset);
+      this.threadId = this.data.readUInt32BE(offset);
     }
   }, {
     key: 'extractMars',
     value: function extractMars(offset) {
       this.mars = this.data.readUInt8(offset);
-      return this.marsString = marsByValue[this.mars];
+      this.marsString = marsByValue[this.mars];
     }
   }, {
     key: 'toString',

package/lib/request.js

@@ -87,7 +87,7 @@ module.exports = function (_EventEmitter) {
         scale: options.scale
       };
       this.parameters.push(parameter);
-      return this.parametersByName[name] = parameter;
+      this.parametersByName[name] = parameter;
     }
 
     // TODO: `type` must be a valid TDS value type
@@ -99,7 +99,7 @@ module.exports = function (_EventEmitter) {
         options = {};
       }
       options.output = true;
-      return this.addParameter(name, type, value, options);
+      this.addParameter(name, type, value, options);
     }
   }, {
     key: 'makeParamsParameter',
@@ -136,7 +136,7 @@ module.exports = function (_EventEmitter) {
         var parameter = this.originalParameters[i];
         this.parameters.push(parameter);
       }
-      return this.sqlTextOrProcedure = 'sp_executesql';
+      this.sqlTextOrProcedure = 'sp_executesql';
     }
   }, {
     key: 'transformIntoPrepareRpc',
@@ -150,11 +150,11 @@ module.exports = function (_EventEmitter) {
       this.addParameter('stmt', TYPES.NVarChar, this.sqlTextOrProcedure);
       this.sqlTextOrProcedure = 'sp_prepare';
       this.preparing = true;
-      return this.on('returnValue', function (name, value) {
+      this.on('returnValue', function (name, value) {
         if (name === 'handle') {
-          return _this2.handle = value;
+          _this2.handle = value;
         } else {
-          return _this2.error = RequestError('Tedious > Unexpected output parameter ' + name + ' from sp_prepare');
+          _this2.error = RequestError(`Tedious > Unexpected output parameter ${name} from sp_prepare`);
         }
       });
     }
@@ -163,7 +163,7 @@ module.exports = function (_EventEmitter) {
     value: function transformIntoUnprepareRpc() {
       this.parameters = [];
       this.addParameter('handle', TYPES.Int, this.handle);
-      return this.sqlTextOrProcedure = 'sp_unprepare';
+      this.sqlTextOrProcedure = 'sp_unprepare';
     }
   }, {
     key: 'transformIntoExecuteRpc',
@@ -181,7 +181,7 @@ module.exports = function (_EventEmitter) {
         return;
       }
 
-      return this.sqlTextOrProcedure = 'sp_execute';
+      this.sqlTextOrProcedure = 'sp_execute';
     }
   }, {
     key: 'validateParameters',