mongodb 4.1.0 → 4.1.4

package/src/cmap/auth/mongo_credentials.ts

@@ -1,7 +1,7 @@
 // Resolves the default auth mechanism according to
 
 import type { Document } from '../../bson';
-import { MongoDriverError, MongoMissingCredentialsError } from '../../error';
+import { MongoAPIError, MongoMissingCredentialsError } from '../../error';
 import { AuthMechanism } from './defaultAuthProviders';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
@@ -25,6 +25,14 @@ function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
   return AuthMechanism.MONGODB_CR;
 }
 
+/** @public */
+export interface AuthMechanismProperties extends Document {
+  SERVICE_NAME?: string;
+  SERVICE_REALM?: string;
+  CANONICALIZE_HOST_NAME?: boolean;
+  AWS_SESSION_TOKEN?: string;
+}
+
 /** @public */
 export interface MongoCredentialsOptions {
   username: string;
@@ -32,7 +40,7 @@ export interface MongoCredentialsOptions {
   source: string;
   db?: string;
   mechanism?: AuthMechanism;
-  mechanismProperties: Document;
+  mechanismProperties: AuthMechanismProperties;
 }
 
 /**
@@ -49,7 +57,7 @@ export class MongoCredentials {
   /** The method used to authenticate */
   readonly mechanism: AuthMechanism;
   /** Special properties used by some types of auth mechanisms */
-  readonly mechanismProperties: Document;
+  readonly mechanismProperties: AuthMechanismProperties;
 
   constructor(options: MongoCredentialsOptions) {
     this.username = options.username;
@@ -70,7 +78,10 @@ export class MongoCredentials {
         this.password = process.env.AWS_SECRET_ACCESS_KEY;
       }
 
-      if (!this.mechanismProperties.AWS_SESSION_TOKEN && process.env.AWS_SESSION_TOKEN) {
+      if (
+        this.mechanismProperties.AWS_SESSION_TOKEN == null &&
+        process.env.AWS_SESSION_TOKEN != null
+      ) {
         this.mechanismProperties = {
           ...this.mechanismProperties,
           AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN
@@ -131,16 +142,16 @@ export class MongoCredentials {
       this.mechanism === AuthMechanism.MONGODB_X509
     ) {
       if (this.source != null && this.source !== '$external') {
-        // TODO(NODE-3483): Replace this with a MongoAuthValidationError
-        throw new MongoDriverError(
+        // TODO(NODE-3485): Replace this with a MongoAuthValidationError
+        throw new MongoAPIError(
           `Invalid source '${this.source}' for mechanism '${this.mechanism}' specified.`
         );
       }
     }
 
     if (this.mechanism === AuthMechanism.MONGODB_PLAIN && this.source == null) {
-      // TODO(NODE-3483): Replace this with a MongoAuthValidationError
-      throw new MongoDriverError('PLAIN Authentication Mechanism needs an auth source');
+      // TODO(NODE-3485): Replace this with a MongoAuthValidationError
+      throw new MongoAPIError('PLAIN Authentication Mechanism needs an auth source');
     }
 
     if (this.mechanism === AuthMechanism.MONGODB_X509 && this.password != null) {
@@ -148,8 +159,8 @@ export class MongoCredentials {
         Reflect.set(this, 'password', undefined);
         return;
       }
-      // TODO(NODE-3483): Replace this with a MongoAuthValidationError
-      throw new MongoDriverError(`Password not allowed for mechanism MONGODB-X509`);
+      // TODO(NODE-3485): Replace this with a MongoAuthValidationError
+      throw new MongoAPIError(`Password not allowed for mechanism MONGODB-X509`);
     }
   }
 

package/src/cmap/auth/mongodb_aws.ts

@@ -5,7 +5,7 @@ import * as BSON from '../../bson';
 import { AuthProvider, AuthContext } from './auth_provider';
 import { MongoCredentials } from './mongo_credentials';
 import {
-  MongoDriverError,
+  MongoRuntimeError,
   MongoMissingCredentialsError,
   MongoCompatibilityError
 } from '../../error';
@@ -14,6 +14,7 @@ import type { BSONSerializeOptions } from '../../bson';
 
 import { aws4 } from '../../deps';
 import { AuthMechanism } from './defaultAuthProviders';
+import type { Binary } from 'bson';
 
 const ASCII_N = 110;
 const AWS_RELATIVE_URI = 'http://169.254.170.2';
@@ -64,10 +65,19 @@ export class MongoDBAWS extends AuthProvider {
       return;
     }
 
-    const username = credentials.username;
-    const password = credentials.password;
+    const accessKeyId = credentials.username;
+    const secretAccessKey = credentials.password;
+    const sessionToken = credentials.mechanismProperties.AWS_SESSION_TOKEN;
+
+    // If all three defined, include sessionToken, else include username and pass, else no credentials
+    const awsCredentials =
+      accessKeyId && secretAccessKey && sessionToken
+        ? { accessKeyId, secretAccessKey, sessionToken }
+        : accessKeyId && secretAccessKey
+        ? { accessKeyId, secretAccessKey }
+        : undefined;
+
     const db = credentials.source;
-    const token = credentials.mechanismProperties.AWS_SESSION_TOKEN;
     crypto.randomBytes(32, (err, nonce) => {
       if (err) {
         callback(err);
@@ -83,24 +93,30 @@ export class MongoDBAWS extends AuthProvider {
       connection.command(ns(`${db}.$cmd`), saslStart, undefined, (err, res) => {
         if (err) return callback(err);
 
-        const serverResponse = BSON.deserialize(res.payload.buffer, bsonOptions);
+        const serverResponse = BSON.deserialize(res.payload.buffer, bsonOptions) as {
+          s: Binary;
+          h: string;
+        };
         const host = serverResponse.h;
         const serverNonce = serverResponse.s.buffer;
         if (serverNonce.length !== 64) {
           callback(
-            new MongoDriverError(`Invalid server nonce length ${serverNonce.length}, expected 64`)
+            // TODO(NODE-3483)
+            new MongoRuntimeError(`Invalid server nonce length ${serverNonce.length}, expected 64`)
           );
 
           return;
         }
 
         if (serverNonce.compare(nonce, 0, nonce.length, 0, nonce.length) !== 0) {
-          callback(new MongoDriverError('Server nonce does not begin with client nonce'));
+          // TODO(NODE-3483)
+          callback(new MongoRuntimeError('Server nonce does not begin with client nonce'));
           return;
         }
 
         if (host.length < 1 || host.length > 255 || host.indexOf('..') !== -1) {
-          callback(new MongoDriverError(`Server returned an invalid host: "${host}"`));
+          // TODO(NODE-3483)
+          callback(new MongoRuntimeError(`Server returned an invalid host: "${host}"`));
           return;
         }
 
@@ -120,18 +136,15 @@ export class MongoDBAWS extends AuthProvider {
             path: '/',
             body
           },
-          {
-            accessKeyId: username,
-            secretAccessKey: password,
-            token
-          }
+          awsCredentials
         );
 
-        const authorization = options.headers.Authorization;
-        const date = options.headers['X-Amz-Date'];
-        const payload: AWSSaslContinuePayload = { a: authorization, d: date };
-        if (token) {
-          payload.t = token;
+        const payload: AWSSaslContinuePayload = {
+          a: options.headers.Authorization,
+          d: options.headers['X-Amz-Date']
+        };
+        if (sessionToken) {
+          payload.t = sessionToken;
         }
 
         const saslContinue = {
@@ -146,14 +159,16 @@ export class MongoDBAWS extends AuthProvider {
   }
 }
 
-interface AWSCredentials {
+interface AWSTempCredentials {
   AccessKeyId?: string;
   SecretAccessKey?: string;
   Token?: string;
+  RoleArn?: string;
+  Expiration?: Date;
 }
 
 function makeTempCredentials(credentials: MongoCredentials, callback: Callback<MongoCredentials>) {
-  function done(creds: AWSCredentials) {
+  function done(creds: AWSTempCredentials) {
     if (!creds.AccessKeyId || !creds.SecretAccessKey || !creds.Token) {
       callback(
         new MongoMissingCredentialsError('Could not obtain temporary MONGODB-AWS credentials')
@@ -180,6 +195,7 @@ function makeTempCredentials(credentials: MongoCredentials, callback: Callback<M
   if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
     request(
       `${AWS_RELATIVE_URI}${process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}`,
+      undefined,
       (err, res) => {
         if (err) return callback(err);
         done(res);
@@ -236,27 +252,15 @@ interface RequestOptions {
   headers?: http.OutgoingHttpHeaders;
 }
 
-function request(uri: string, callback: Callback): void;
-function request(uri: string, options: RequestOptions, callback: Callback): void;
-function request(uri: string, _options: RequestOptions | Callback, _callback?: Callback) {
-  let options = _options as RequestOptions;
-  if ('function' === typeof _options) {
-    options = {};
-  }
-
-  let callback: Callback = _options as Callback;
-  if (_callback) {
-    callback = _callback;
-  }
-
-  options = Object.assign(
+function request(uri: string, _options: RequestOptions | undefined, callback: Callback) {
+  const options = Object.assign(
     {
       method: 'GET',
       timeout: 10000,
       json: true
     },
     url.parse(uri),
-    options
+    _options
   );
 
   const req = http.request(options, res => {
@@ -274,7 +278,8 @@ function request(uri: string, _options: RequestOptions | Callback, _callback?: C
         const parsed = JSON.parse(data);
         callback(undefined, parsed);
       } catch (err) {
-        callback(new MongoDriverError(`Invalid JSON response: "${data}"`));
+        // TODO(NODE-3483)
+        callback(new MongoRuntimeError(`Invalid JSON response: "${data}"`));
       }
     });
   });

package/src/cmap/auth/scram.ts

@@ -2,7 +2,7 @@ import * as crypto from 'crypto';
 import { Binary, Document } from '../../bson';
 import {
   AnyError,
-  MongoDriverError,
+  MongoRuntimeError,
   MongoServerError,
   MongoInvalidArgumentError,
   MongoMissingCredentialsError
@@ -169,7 +169,8 @@ function continueScramConversation(
   const iterations = parseInt(dict.i, 10);
   if (iterations && iterations < 4096) {
     callback(
-      new MongoDriverError(`Server returned an invalid iteration count ${iterations}`),
+      // TODO(NODE-3483)
+      new MongoRuntimeError(`Server returned an invalid iteration count ${iterations}`),
       false
     );
     return;
@@ -178,7 +179,8 @@ function continueScramConversation(
   const salt = dict.s;
   const rnonce = dict.r;
   if (rnonce.startsWith('nonce')) {
-    callback(new MongoDriverError(`Server returned an invalid nonce: ${rnonce}`), false);
+    // TODO(NODE-3483)
+    callback(new MongoRuntimeError(`Server returned an invalid nonce: ${rnonce}`), false);
     return;
   }
 
@@ -217,7 +219,7 @@ function continueScramConversation(
 
     const parsedResponse = parsePayload(r.payload.value());
     if (!compareDigest(Buffer.from(parsedResponse.v, 'base64'), serverSignature)) {
-      callback(new MongoDriverError('Server returned an invalid signature'));
+      callback(new MongoRuntimeError('Server returned an invalid signature'));
       return;
     }
 

package/src/cmap/command_monitoring_events.ts

@@ -274,7 +274,7 @@ function extractCommand(command: WriteProtocolMessageType): Document {
 
   for (const k in command) {
     if (k === 'query') continue;
-    clonedCommand[k] = deepCopy(((command as unknown) as Record<string, unknown>)[k]);
+    clonedCommand[k] = deepCopy((command as unknown as Record<string, unknown>)[k]);
   }
   return command.query ? clonedQuery : clonedCommand;
 }

package/src/cmap/commands.ts

@@ -5,7 +5,7 @@ import { OP_QUERY, OP_GETMORE, OP_KILL_CURSORS, OP_MSG } from './wire_protocol/c
 import type { Long, Document, BSONSerializeOptions } from '../bson';
 import type { ClientSession } from '../sessions';
 import type { CommandOptions } from './connection';
-import { MongoDriverError, MongoInvalidArgumentError } from '../error';
+import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
 
 // Incrementing request id
 let _requestId = 0;
@@ -78,14 +78,14 @@ export class Query {
   constructor(ns: string, query: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
     // TODO(NODE-3483): Replace with MongoCommandError
-    if (ns == null) throw new MongoDriverError('Namespace must be specified for query');
+    if (ns == null) throw new MongoRuntimeError('Namespace must be specified for query');
     // TODO(NODE-3483): Replace with MongoCommandError
-    if (query == null) throw new MongoDriverError('A query document must be specified for query');
+    if (query == null) throw new MongoRuntimeError('A query document must be specified for query');
 
     // Validate that we are not passing 0x00 in the collection name
     if (ns.indexOf('\x00') !== -1) {
-      // TODO(NODE-3483): Replace with MongoCommandError
-      throw new MongoDriverError('Namespace cannot contain a null character');
+      // TODO(NODE-3483): Use MongoNamespace static method
+      throw new MongoRuntimeError('Namespace cannot contain a null character');
     }
 
     // Basic options
@@ -858,7 +858,7 @@ export class BinMsg {
         // It was decided that no driver makes use of payload type 1
 
         // TODO(NODE-3483): Replace with MongoDeprecationError
-        throw new MongoDriverError('OP_MSG Payload Type 1 detected unsupported protocol');
+        throw new MongoRuntimeError('OP_MSG Payload Type 1 detected unsupported protocol');
       }
     }
 

package/src/cmap/connect.ts

@@ -5,10 +5,10 @@ import {
   MongoNetworkError,
   MongoNetworkTimeoutError,
   AnyError,
-  MongoDriverError,
   MongoCompatibilityError,
+  MongoInvalidArgumentError,
   MongoServerError,
-  MongoInvalidArgumentError
+  MongoRuntimeError
 } from '../error';
 import { AUTH_PROVIDERS, AuthMechanism } from './auth/defaultAuthProviders';
 import { AuthContext } from './auth/auth_provider';
@@ -144,7 +144,7 @@ function performInitialHandshake(
         }
         if (!response.serviceId) {
           return callback(
-            new MongoDriverError(
+            new MongoCompatibilityError(
               'Driver attempted to initialize in load balancing mode, ' +
                 'but the server does not support this mode.'
             )
@@ -284,7 +284,8 @@ function parseConnectOptions(options: ConnectionOptions): SocketConnectOpts {
   } else {
     // This should never happen since we set up HostAddresses
     // But if we don't throw here the socket could hang until timeout
-    throw new MongoDriverError(`Unexpected HostAddress ${JSON.stringify(hostAddress)}`);
+    // TODO(NODE-3483)
+    throw new MongoRuntimeError(`Unexpected HostAddress ${JSON.stringify(hostAddress)}`);
   }
 }
 

package/src/cmap/connection.ts

@@ -17,7 +17,7 @@ import {
   HostAddress
 } from '../utils';
 import {
-  MongoDriverError,
+  MongoRuntimeError,
   MongoMissingDependencyError,
   MongoCompatibilityError,
   MongoNetworkError,
@@ -63,6 +63,8 @@ const kDescription = Symbol('description');
 const kIsMaster = Symbol('ismaster');
 /** @internal */
 const kAutoEncrypter = Symbol('autoEncrypter');
+/** @internal */
+const kFullResult = Symbol('fullResult');
 
 /** @internal */
 export interface QueryOptions extends BSONSerializeOptions {
@@ -81,7 +83,7 @@ export interface QueryOptions extends BSONSerializeOptions {
   oplogReplay?: boolean;
 }
 
-/** @public */
+/** @internal */
 export interface CommandOptions extends BSONSerializeOptions {
   command?: boolean;
   slaveOk?: boolean;
@@ -89,7 +91,7 @@ export interface CommandOptions extends BSONSerializeOptions {
   readPreference?: ReadPreferenceLike;
   raw?: boolean;
   monitoring?: boolean;
-  fullResult?: boolean;
+  [kFullResult]?: boolean;
   socketTimeoutMS?: number;
   /** Session to use for the operation */
   session?: ClientSession;
@@ -363,7 +365,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   ): void {
     if (!(ns instanceof MongoDBNamespace)) {
       // TODO(NODE-3483): Replace this with a MongoCommandError
-      throw new MongoDriverError('Must provide a MongoDBNamespace instance');
+      throw new MongoRuntimeError('Must provide a MongoDBNamespace instance');
     }
 
     const readPreference = getReadPreference(cmd, options);
@@ -492,7 +494,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     write(
       this,
       query,
-      { fullResult: true, ...pluckBSONSerializeOptions(options) },
+      { [kFullResult]: true, ...pluckBSONSerializeOptions(options) },
       (err, result) => {
         if (err || !result) return callback(err, result);
         if (isExplain && result.documents && result.documents[0]) {
@@ -511,11 +513,11 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     options: GetMoreOptions,
     callback: Callback<Document>
   ): void {
-    const fullResult = typeof options.fullResult === 'boolean' ? options.fullResult : false;
+    const fullResult = !!options[kFullResult];
     const wireVersion = maxWireVersion(this);
     if (!cursorId) {
       // TODO(NODE-3483): Replace this with a MongoCommandError
-      callback(new MongoDriverError('Invalid internal cursor state, no known cursor id'));
+      callback(new MongoRuntimeError('Invalid internal cursor state, no known cursor id'));
       return;
     }
 
@@ -526,7 +528,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
         Object.assign(options, { ...pluckBSONSerializeOptions(options) })
       );
 
-      queryOptions.fullResult = true;
+      queryOptions[kFullResult] = true;
       queryOptions.command = true;
       write(this, getMoreOp, queryOptions, (err, response) => {
         if (fullResult) return callback(err, response);
@@ -570,7 +572,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   ): void {
     if (!cursorIds || !Array.isArray(cursorIds)) {
       // TODO(NODE-3483): Replace this with a MongoCommandError
-      throw new MongoDriverError(`Invalid list of cursor ids provided: ${cursorIds}`);
+      throw new MongoRuntimeError(`Invalid list of cursor ids provided: ${cursorIds}`);
     }
 
     if (maxWireVersion(this) < 4) {
@@ -591,7 +593,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this.command(
       ns,
       { killCursors: ns.collection, cursors: cursorIds },
-      { fullResult: true, ...options },
+      { [kFullResult]: true, ...options },
       (err, response) => {
         if (err || !response) return callback(err);
         if (response.cursorNotFound) {
@@ -600,7 +602,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
         if (!Array.isArray(response.documents) || response.documents.length === 0) {
           return callback(
-            new MongoDriverError(
+            // TODO(NODE-3483)
+            new MongoRuntimeError(
               `invalid killCursors result returned for cursor id ${cursorIds[0]}`
             )
           );
@@ -773,7 +776,7 @@ function write(
     requestId: command.requestId,
     cb: callback,
     session: options.session,
-    fullResult: typeof options.fullResult === 'boolean' ? options.fullResult : false,
+    fullResult: !!options[kFullResult],
     noResponse: typeof options.noResponse === 'boolean' ? options.noResponse : false,
     documentsReturnedIn: options.documentsReturnedIn,
     command: !!options.command,

package/src/cmap/connection_pool.ts

@@ -5,7 +5,7 @@ import { Logger } from '../logger';
 import { ConnectionPoolMetrics } from './metrics';
 import { connect } from './connect';
 import { eachAsync, makeCounter, Callback } from '../utils';
-import { MongoDriverError, MongoError, MongoInvalidArgumentError } from '../error';
+import { MongoError, MongoInvalidArgumentError, MongoRuntimeError } from '../error';
 import { PoolClosedError, WaitQueueTimeoutError } from './errors';
 import {
   ConnectionPoolCreatedEvent,
@@ -350,7 +350,8 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       // Only need to worry if the generation exists, since it should
       // always be there but typescript needs the check.
       if (generation == null) {
-        throw new MongoDriverError('Service generations are required in load balancer mode.');
+        // TODO(NODE-3483)
+        throw new MongoRuntimeError('Service generations are required in load balancer mode.');
       } else {
         // Increment the generation for the service id.
         this.serviceGenerations.set(sid, generation + 1);
@@ -388,7 +389,8 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
           clearTimeout(waitQueueMember.timer);
         }
         if (!waitQueueMember[kCancelled]) {
-          waitQueueMember.callback(new MongoDriverError('connection pool closed'));
+          // TODO(NODE-3483): Replace with MongoConnectionPoolClosedError
+          waitQueueMember.callback(new MongoRuntimeError('Connection pool closed'));
         }
       }
     }

package/src/cmap/message_stream.ts

@@ -1,6 +1,6 @@
 import { Duplex, DuplexOptions } from 'stream';
 import { Response, Msg, BinMsg, Query, WriteProtocolMessageType, MessageHeader } from './commands';
-import { MongoDriverError, MongoParseError } from '../error';
+import { MongoDecompressionError, MongoParseError } from '../error';
 import { OP_COMPRESSED, OP_MSG } from './wire_protocol/constants';
 import {
   compress,
@@ -191,9 +191,7 @@ function processIncomingData(stream: MessageStream, callback: Callback<Buffer>)
 
     if (messageBody.length !== messageHeader.length) {
       callback(
-        new MongoDriverError(
-          'Decompressing a compressed message from the server failed. The message is corrupt.'
-        )
+        new MongoDecompressionError('Message body and message header must be the same length')
       );
 
       return;

package/src/cmap/wire_protocol/compression.ts

@@ -2,8 +2,8 @@ import * as zlib from 'zlib';
 import type { Callback } from '../../utils';
 import type { OperationDescription } from '../message_stream';
 
-import { Snappy } from '../../deps';
-import { MongoDriverError } from '../../error';
+import { PKG_VERSION, Snappy } from '../../deps';
+import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
 
 /** @public */
 export const Compressor = Object.freeze({
@@ -39,12 +39,20 @@ export function compress(
 ): void {
   const zlibOptions = {} as zlib.ZlibOptions;
   switch (self.options.agreedCompressor) {
-    case 'snappy':
+    case 'snappy': {
       if ('kModuleError' in Snappy) {
         return callback(Snappy['kModuleError']);
       }
-      Snappy.compress(dataToBeCompressed, callback);
+
+      if (Snappy[PKG_VERSION].major <= 6) {
+        Snappy.compress(dataToBeCompressed, callback);
+      } else {
+        Snappy.compress(dataToBeCompressed)
+          .then(buffer => callback(undefined, buffer))
+          .catch(error => callback(error));
+      }
       break;
+    }
     case 'zlib':
       // Determine zlibCompressionLevel
       if (self.options.zlibCompressionLevel) {
@@ -53,10 +61,8 @@ export function compress(
       zlib.deflate(dataToBeCompressed, zlibOptions, callback as zlib.CompressCallback);
       break;
     default:
-      throw new MongoDriverError(
-        'Attempt to compress message using unknown compressor "' +
-          self.options.agreedCompressor +
-          '".'
+      throw new MongoInvalidArgumentError(
+        `Unknown compressor ${self.options.agreedCompressor} failed to compress`
       );
   }
 }
@@ -68,19 +74,26 @@ export function decompress(
   callback: Callback<Buffer>
 ): void {
   if (compressorID < 0 || compressorID > Math.max(2)) {
-    throw new MongoDriverError(
-      `Server sent message compressed using an unsupported compressor.` +
-        ` (Received compressor ID ${compressorID})`
+    throw new MongoDecompressionError(
+      `Server sent message compressed using an unsupported compressor. (Received compressor ID ${compressorID})`
     );
   }
 
   switch (compressorID) {
-    case Compressor.snappy:
+    case Compressor.snappy: {
       if ('kModuleError' in Snappy) {
         return callback(Snappy['kModuleError']);
       }
-      Snappy.uncompress(compressedData, { asBuffer: true }, callback as Callback);
+
+      if (Snappy[PKG_VERSION].major <= 6) {
+        Snappy.uncompress(compressedData, { asBuffer: true }, callback);
+      } else {
+        Snappy.uncompress(compressedData, { asBuffer: true })
+          .then(buffer => callback(undefined, buffer))
+          .catch(error => callback(error));
+      }
       break;
+    }
     case Compressor.zlib:
       zlib.inflate(compressedData, callback as zlib.CompressCallback);
       break;