tedious 13.0.5 → 14.1.0

package/lib/token/handler.js

@@ -0,0 +1,552 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AttentionTokenHandler = exports.RequestTokenHandler = exports.Login7TokenHandler = exports.InitialSqlTokenHandler = exports.TokenHandler = exports.UnexpectedTokenError = void 0;
+
+var _errors = require("../errors");
+
+class UnexpectedTokenError extends Error {
+  constructor(handler, token) {
+    super('Unexpected token `' + token.name + '` in `' + handler.constructor.name + '`');
+  }
+
+}
+
+exports.UnexpectedTokenError = UnexpectedTokenError;
+
+class TokenHandler {
+  onInfoMessage(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onErrorMessage(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onSSPI(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onDatabaseChange(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onLanguageChange(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onCharsetChange(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onSqlCollationChange(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onRoutingChange(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onPacketSizeChange(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onResetConnection(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onBeginTransaction(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onCommitTransaction(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onRollbackTransaction(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onFedAuthInfo(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onFeatureExtAck(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onLoginAck(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onColMetadata(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onOrder(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onRow(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onReturnStatus(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onReturnValue(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onDoneProc(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onDoneInProc(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onDone(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+  onDatabaseMirroringPartner(token) {
+    throw new UnexpectedTokenError(this, token);
+  }
+
+}
+/**
+ * A handler for tokens received in the response message to the initial SQL Batch request
+ * that sets up different connection settings.
+ */
+
+
+exports.TokenHandler = TokenHandler;
+
+class InitialSqlTokenHandler extends TokenHandler {
+  constructor(connection) {
+    super();
+    this.connection = void 0;
+    this.connection = connection;
+  }
+
+  onInfoMessage(token) {
+    this.connection.emit('infoMessage', token);
+  }
+
+  onErrorMessage(token) {
+    this.connection.emit('errorMessage', token);
+  }
+
+  onDatabaseChange(token) {
+    this.connection.emit('databaseChange', token.newValue);
+  }
+
+  onLanguageChange(token) {
+    this.connection.emit('languageChange', token.newValue);
+  }
+
+  onCharsetChange(token) {
+    this.connection.emit('charsetChange', token.newValue);
+  }
+
+  onSqlCollationChange(token) {
+    this.connection.databaseCollation = token.newValue;
+  }
+
+  onPacketSizeChange(token) {
+    this.connection.messageIo.packetSize(token.newValue);
+  }
+
+  onBeginTransaction(token) {
+    this.connection.transactionDescriptors.push(token.newValue);
+    this.connection.inTransaction = true;
+  }
+
+  onCommitTransaction(token) {
+    this.connection.transactionDescriptors.length = 1;
+    this.connection.inTransaction = false;
+  }
+
+  onRollbackTransaction(token) {
+    this.connection.transactionDescriptors.length = 1; // An outermost transaction was rolled back. Reset the transaction counter
+
+    this.connection.inTransaction = false;
+    this.connection.emit('rollbackTransaction');
+  }
+
+  onColMetadata(token) {
+    this.connection.emit('error', new Error("Received 'columnMetadata' when no sqlRequest is in progress"));
+    this.connection.close();
+  }
+
+  onOrder(token) {
+    this.connection.emit('error', new Error("Received 'order' when no sqlRequest is in progress"));
+    this.connection.close();
+  }
+
+  onRow(token) {
+    this.connection.emit('error', new Error("Received 'row' when no sqlRequest is in progress"));
+    this.connection.close();
+  }
+
+  onReturnStatus(token) {// Do nothing
+  }
+
+  onReturnValue(token) {// Do nothing
+  }
+
+  onDoneProc(token) {// Do nothing
+  }
+
+  onDoneInProc(token) {// Do nothing
+  }
+
+  onDone(token) {// Do nothing
+  }
+
+  onResetConnection(token) {
+    this.connection.emit('resetConnection');
+  }
+
+}
+/**
+ * A handler for tokens received in the response message to a Login7 message.
+ */
+
+
+exports.InitialSqlTokenHandler = InitialSqlTokenHandler;
+
+class Login7TokenHandler extends TokenHandler {
+  constructor(connection) {
+    super();
+    this.connection = void 0;
+    this.fedAuthInfoToken = void 0;
+    this.routingData = void 0;
+    this.loginAckReceived = false;
+    this.connection = connection;
+  }
+
+  onInfoMessage(token) {
+    this.connection.emit('infoMessage', token);
+  }
+
+  onErrorMessage(token) {
+    this.connection.emit('errorMessage', token);
+    const error = new _errors.ConnectionError(token.message, 'ELOGIN');
+    const isLoginErrorTransient = this.connection.transientErrorLookup.isTransientError(token.number);
+
+    if (isLoginErrorTransient && this.connection.curTransientRetryCount !== this.connection.config.options.maxRetriesOnTransientErrors) {
+      error.isTransient = true;
+    }
+
+    this.connection.loginError = error;
+  }
+
+  onSSPI(token) {
+    if (token.ntlmpacket) {
+      this.connection.ntlmpacket = token.ntlmpacket;
+      this.connection.ntlmpacketBuffer = token.ntlmpacketBuffer;
+    }
+  }
+
+  onDatabaseChange(token) {
+    this.connection.emit('databaseChange', token.newValue);
+  }
+
+  onLanguageChange(token) {
+    this.connection.emit('languageChange', token.newValue);
+  }
+
+  onCharsetChange(token) {
+    this.connection.emit('charsetChange', token.newValue);
+  }
+
+  onSqlCollationChange(token) {
+    this.connection.databaseCollation = token.newValue;
+  }
+
+  onFedAuthInfo(token) {
+    this.fedAuthInfoToken = token;
+  }
+
+  onFeatureExtAck(token) {
+    const {
+      authentication
+    } = this.connection.config;
+
+    if (authentication.type === 'azure-active-directory-password' || authentication.type === 'azure-active-directory-access-token' || authentication.type === 'azure-active-directory-msi-vm' || authentication.type === 'azure-active-directory-msi-app-service' || authentication.type === 'azure-active-directory-service-principal-secret') {
+      if (token.fedAuth === undefined) {
+        this.connection.loginError = new _errors.ConnectionError('Did not receive Active Directory authentication acknowledgement');
+      } else if (token.fedAuth.length !== 0) {
+        this.connection.loginError = new _errors.ConnectionError(`Active Directory authentication acknowledgment for ${authentication.type} authentication method includes extra data`);
+      }
+    } else if (token.fedAuth === undefined && token.utf8Support === undefined) {
+      this.connection.loginError = new _errors.ConnectionError('Received acknowledgement for unknown feature');
+    } else if (token.fedAuth) {
+      this.connection.loginError = new _errors.ConnectionError('Did not request Active Directory authentication, but received the acknowledgment');
+    }
+  }
+
+  onLoginAck(token) {
+    if (!token.tdsVersion) {
+      // unsupported TDS version
+      this.connection.loginError = new _errors.ConnectionError('Server responded with unknown TDS version.', 'ETDS');
+      return;
+    }
+
+    if (!token.interface) {
+      // unsupported interface
+      this.connection.loginError = new _errors.ConnectionError('Server responded with unsupported interface.', 'EINTERFACENOTSUPP');
+      return;
+    } // use negotiated version
+
+
+    this.connection.config.options.tdsVersion = token.tdsVersion;
+    this.loginAckReceived = true;
+  }
+
+  onRoutingChange(token) {
+    // Removes instance name attached to the redirect url. E.g., redirect.db.net\instance1 --> redirect.db.net
+    const [server] = token.newValue.server.split('\\');
+    this.routingData = {
+      server,
+      port: token.newValue.port
+    };
+  }
+
+  onDoneInProc(token) {// Do nothing
+  }
+
+  onDone(token) {// Do nothing
+  }
+
+  onPacketSizeChange(token) {
+    this.connection.messageIo.packetSize(token.newValue);
+  }
+
+  onDatabaseMirroringPartner(token) {// Do nothing
+  }
+
+}
+/**
+ * A handler for tokens received in the response message to a RPC Request,
+ * a SQL Batch Request, a Bulk Load BCP Request or a Transaction Manager Request.
+ */
+
+
+exports.Login7TokenHandler = Login7TokenHandler;
+
+class RequestTokenHandler extends TokenHandler {
+  constructor(connection, request) {
+    super();
+    this.connection = void 0;
+    this.request = void 0;
+    this.connection = connection;
+    this.request = request;
+  }
+
+  onInfoMessage(token) {
+    this.connection.emit('infoMessage', token);
+  }
+
+  onErrorMessage(token) {
+    this.connection.emit('errorMessage', token);
+
+    if (!this.request.canceled) {
+      const error = new _errors.RequestError(token.message, 'EREQUEST');
+      error.number = token.number;
+      error.state = token.state;
+      error.class = token.class;
+      error.serverName = token.serverName;
+      error.procName = token.procName;
+      error.lineNumber = token.lineNumber;
+      this.request.error = error;
+    }
+  }
+
+  onDatabaseChange(token) {
+    this.connection.emit('databaseChange', token.newValue);
+  }
+
+  onLanguageChange(token) {
+    this.connection.emit('languageChange', token.newValue);
+  }
+
+  onCharsetChange(token) {
+    this.connection.emit('charsetChange', token.newValue);
+  }
+
+  onSqlCollationChange(token) {
+    this.connection.databaseCollation = token.newValue;
+  }
+
+  onPacketSizeChange(token) {
+    this.connection.messageIo.packetSize(token.newValue);
+  }
+
+  onBeginTransaction(token) {
+    this.connection.transactionDescriptors.push(token.newValue);
+    this.connection.inTransaction = true;
+  }
+
+  onCommitTransaction(token) {
+    this.connection.transactionDescriptors.length = 1;
+    this.connection.inTransaction = false;
+  }
+
+  onRollbackTransaction(token) {
+    this.connection.transactionDescriptors.length = 1; // An outermost transaction was rolled back. Reset the transaction counter
+
+    this.connection.inTransaction = false;
+    this.connection.emit('rollbackTransaction');
+  }
+
+  onColMetadata(token) {
+    if (!this.request.canceled) {
+      if (this.connection.config.options.useColumnNames) {
+        const columns = Object.create(null);
+
+        for (let j = 0, len = token.columns.length; j < len; j++) {
+          const col = token.columns[j];
+
+          if (columns[col.colName] == null) {
+            columns[col.colName] = col;
+          }
+        }
+
+        this.request.emit('columnMetadata', columns);
+      } else {
+        this.request.emit('columnMetadata', token.columns);
+      }
+    }
+  }
+
+  onOrder(token) {
+    if (!this.request.canceled) {
+      this.request.emit('order', token.orderColumns);
+    }
+  }
+
+  onRow(token) {
+    if (!this.request.canceled) {
+      if (this.connection.config.options.rowCollectionOnRequestCompletion) {
+        this.request.rows.push(token.columns);
+      }
+
+      if (this.connection.config.options.rowCollectionOnDone) {
+        this.request.rst.push(token.columns);
+      }
+
+      this.request.emit('row', token.columns);
+    }
+  }
+
+  onReturnStatus(token) {
+    if (!this.request.canceled) {
+      // Keep value for passing in 'doneProc' event.
+      this.connection.procReturnStatusValue = token.value;
+    }
+  }
+
+  onReturnValue(token) {
+    if (!this.request.canceled) {
+      this.request.emit('returnValue', token.paramName, token.value, token.metadata);
+    }
+  }
+
+  onDoneProc(token) {
+    if (!this.request.canceled) {
+      if (token.sqlError && !this.request.error) {
+        // check if the DONE_ERROR flags was set, but an ERROR token was not sent.
+        this.request.error = new _errors.RequestError('An unknown error has occurred.', 'UNKNOWN');
+      }
+
+      this.request.emit('doneProc', token.rowCount, token.more, this.connection.procReturnStatusValue, this.request.rst);
+      this.connection.procReturnStatusValue = undefined;
+
+      if (token.rowCount !== undefined) {
+        this.request.rowCount += token.rowCount;
+      }
+
+      if (this.connection.config.options.rowCollectionOnDone) {
+        this.request.rst = [];
+      }
+    }
+  }
+
+  onDoneInProc(token) {
+    if (!this.request.canceled) {
+      this.request.emit('doneInProc', token.rowCount, token.more, this.request.rst);
+
+      if (token.rowCount !== undefined) {
+        this.request.rowCount += token.rowCount;
+      }
+
+      if (this.connection.config.options.rowCollectionOnDone) {
+        this.request.rst = [];
+      }
+    }
+  }
+
+  onDone(token) {
+    if (!this.request.canceled) {
+      if (token.sqlError && !this.request.error) {
+        // check if the DONE_ERROR flags was set, but an ERROR token was not sent.
+        this.request.error = new _errors.RequestError('An unknown error has occurred.', 'UNKNOWN');
+      }
+
+      this.request.emit('done', token.rowCount, token.more, this.request.rst);
+
+      if (token.rowCount !== undefined) {
+        this.request.rowCount += token.rowCount;
+      }
+
+      if (this.connection.config.options.rowCollectionOnDone) {
+        this.request.rst = [];
+      }
+    }
+  }
+
+  onResetConnection(token) {
+    this.connection.emit('resetConnection');
+  }
+
+}
+/**
+ * A handler for the attention acknowledgement message.
+ *
+ * This message only contains a `DONE` token that acknowledges
+ * that the attention message was received by the server.
+ */
+
+
+exports.RequestTokenHandler = RequestTokenHandler;
+
+class AttentionTokenHandler extends TokenHandler {
+  /**
+   * Returns whether an attention acknowledgement was received.
+   */
+  constructor(connection, request) {
+    super();
+    this.connection = void 0;
+    this.request = void 0;
+    this.attentionReceived = void 0;
+    this.connection = connection;
+    this.request = request;
+    this.attentionReceived = false;
+  }
+
+  onDone(token) {
+    if (token.attention) {
+      this.attentionReceived = true;
+    }
+  }
+
+}
+
+exports.AttentionTokenHandler = AttentionTokenHandler;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/token/handler.ts"],"names":["UnexpectedTokenError","Error","constructor","handler","token","name","TokenHandler","onInfoMessage","onErrorMessage","onSSPI","onDatabaseChange","onLanguageChange","onCharsetChange","onSqlCollationChange","onRoutingChange","onPacketSizeChange","onResetConnection","onBeginTransaction","onCommitTransaction","onRollbackTransaction","onFedAuthInfo","onFeatureExtAck","onLoginAck","onColMetadata","onOrder","onRow","onReturnStatus","onReturnValue","onDoneProc","onDoneInProc","onDone","onDatabaseMirroringPartner","InitialSqlTokenHandler","connection","emit","newValue","databaseCollation","messageIo","packetSize","transactionDescriptors","push","inTransaction","length","close","Login7TokenHandler","fedAuthInfoToken","routingData","loginAckReceived","error","ConnectionError","message","isLoginErrorTransient","transientErrorLookup","isTransientError","number","curTransientRetryCount","config","options","maxRetriesOnTransientErrors","isTransient","loginError","ntlmpacket","ntlmpacketBuffer","authentication","type","fedAuth","undefined","utf8Support","tdsVersion","interface","server","split","port","RequestTokenHandler","request","canceled","RequestError","state","class","serverName","procName","lineNumber","useColumnNames","columns","Object","create","j","len","col","colName","orderColumns","rowCollectionOnRequestCompletion","rows","rowCollectionOnDone","rst","procReturnStatusValue","value","paramName","metadata","sqlError","rowCount","more","AttentionTokenHandler","attentionReceived","attention"],"mappings":"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","sourcesContent":["import Connection from '../connection';\nimport Request from '../request';\nimport { ConnectionError, RequestError } from '../errors';\nimport { ColumnMetadata } from './colmetadata-token-parser';\nimport {\n  BeginTransactionEnvChangeToken,\n  CharsetEnvChangeToken,\n  CollationChangeToken,\n  ColMetadataToken,\n  CommitTransactionEnvChangeToken,\n  DatabaseEnvChangeToken,\n  DatabaseMirroringPartnerEnvChangeToken,\n  DoneInProcToken,\n  DoneProcToken,\n  DoneToken,\n  ErrorMessageToken,\n  FeatureExtAckToken,\n  FedAuthInfoToken,\n  InfoMessageToken,\n  LanguageEnvChangeToken,\n  LoginAckToken,\n  NBCRowToken,\n  OrderToken,\n  PacketSizeEnvChangeToken,\n  ResetConnectionEnvChangeToken,\n  ReturnStatusToken,\n  ReturnValueToken,\n  RollbackTransactionEnvChangeToken,\n  RoutingEnvChangeToken,\n  RowToken,\n  SSPIToken,\n  Token\n} from './token';\nimport BulkLoad from '../bulk-load';\n\nexport class UnexpectedTokenError extends Error {\n  constructor(handler: TokenHandler, token: Token) {\n    super('Unexpected token `' + token.name + '` in `' + handler.constructor.name + '`');\n  }\n}\n\nexport class TokenHandler {\n  onInfoMessage(token: InfoMessageToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onErrorMessage(token: ErrorMessageToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onSSPI(token: SSPIToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onDatabaseChange(token: DatabaseEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onLanguageChange(token: LanguageEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onCharsetChange(token: CharsetEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onSqlCollationChange(token: CollationChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onRoutingChange(token: RoutingEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onPacketSizeChange(token: PacketSizeEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onResetConnection(token: ResetConnectionEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onBeginTransaction(token: BeginTransactionEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onCommitTransaction(token: CommitTransactionEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onRollbackTransaction(token: RollbackTransactionEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onFedAuthInfo(token: FedAuthInfoToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onFeatureExtAck(token: FeatureExtAckToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onLoginAck(token: LoginAckToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onColMetadata(token: ColMetadataToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onOrder(token: OrderToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onRow(token: RowToken | NBCRowToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onReturnStatus(token: ReturnStatusToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onReturnValue(token: ReturnValueToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onDoneProc(token: DoneProcToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onDoneInProc(token: DoneInProcToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onDone(token: DoneToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n\n  onDatabaseMirroringPartner(token: DatabaseMirroringPartnerEnvChangeToken) {\n    throw new UnexpectedTokenError(this, token);\n  }\n}\n\n/**\n * A handler for tokens received in the response message to the initial SQL Batch request\n * that sets up different connection settings.\n */\nexport class InitialSqlTokenHandler extends TokenHandler {\n  connection: Connection;\n\n  constructor(connection: Connection) {\n    super();\n\n    this.connection = connection;\n  }\n\n  onInfoMessage(token: InfoMessageToken) {\n    this.connection.emit('infoMessage', token);\n  }\n\n  onErrorMessage(token: ErrorMessageToken) {\n    this.connection.emit('errorMessage', token);\n  }\n\n  onDatabaseChange(token: DatabaseEnvChangeToken) {\n    this.connection.emit('databaseChange', token.newValue);\n  }\n\n  onLanguageChange(token: LanguageEnvChangeToken) {\n    this.connection.emit('languageChange', token.newValue);\n  }\n\n  onCharsetChange(token: CharsetEnvChangeToken) {\n    this.connection.emit('charsetChange', token.newValue);\n  }\n\n  onSqlCollationChange(token: CollationChangeToken) {\n    this.connection.databaseCollation = token.newValue;\n  }\n\n  onPacketSizeChange(token: PacketSizeEnvChangeToken) {\n    this.connection.messageIo.packetSize(token.newValue);\n  }\n\n  onBeginTransaction(token: BeginTransactionEnvChangeToken) {\n    this.connection.transactionDescriptors.push(token.newValue);\n    this.connection.inTransaction = true;\n  }\n\n  onCommitTransaction(token: CommitTransactionEnvChangeToken) {\n    this.connection.transactionDescriptors.length = 1;\n    this.connection.inTransaction = false;\n  }\n\n  onRollbackTransaction(token: RollbackTransactionEnvChangeToken) {\n    this.connection.transactionDescriptors.length = 1;\n    // An outermost transaction was rolled back. Reset the transaction counter\n    this.connection.inTransaction = false;\n    this.connection.emit('rollbackTransaction');\n  }\n\n  onColMetadata(token: ColMetadataToken) {\n    this.connection.emit('error', new Error(\"Received 'columnMetadata' when no sqlRequest is in progress\"));\n    this.connection.close();\n  }\n\n  onOrder(token: OrderToken) {\n    this.connection.emit('error', new Error(\"Received 'order' when no sqlRequest is in progress\"));\n    this.connection.close();\n  }\n\n  onRow(token: RowToken | NBCRowToken) {\n    this.connection.emit('error', new Error(\"Received 'row' when no sqlRequest is in progress\"));\n    this.connection.close();\n  }\n\n  onReturnStatus(token: ReturnStatusToken) {\n    // Do nothing\n  }\n\n  onReturnValue(token: ReturnValueToken) {\n    // Do nothing\n  }\n\n  onDoneProc(token: DoneProcToken) {\n    // Do nothing\n  }\n\n  onDoneInProc(token: DoneInProcToken) {\n    // Do nothing\n  }\n\n  onDone(token: DoneToken) {\n    // Do nothing\n  }\n\n  onResetConnection(token: ResetConnectionEnvChangeToken) {\n    this.connection.emit('resetConnection');\n  }\n}\n\n/**\n * A handler for tokens received in the response message to a Login7 message.\n */\nexport class Login7TokenHandler extends TokenHandler {\n  connection: Connection;\n\n  fedAuthInfoToken: FedAuthInfoToken | undefined;\n  routingData: { server: string, port: number } | undefined;\n\n  loginAckReceived = false;\n\n  constructor(connection: Connection) {\n    super();\n\n    this.connection = connection;\n  }\n\n  onInfoMessage(token: InfoMessageToken) {\n    this.connection.emit('infoMessage', token);\n  }\n\n  onErrorMessage(token: ErrorMessageToken) {\n    this.connection.emit('errorMessage', token);\n\n    const error = new ConnectionError(token.message, 'ELOGIN');\n\n    const isLoginErrorTransient = this.connection.transientErrorLookup.isTransientError(token.number);\n    if (isLoginErrorTransient && this.connection.curTransientRetryCount !== this.connection.config.options.maxRetriesOnTransientErrors) {\n      error.isTransient = true;\n    }\n\n    this.connection.loginError = error;\n  }\n\n  onSSPI(token: SSPIToken) {\n    if (token.ntlmpacket) {\n      this.connection.ntlmpacket = token.ntlmpacket;\n      this.connection.ntlmpacketBuffer = token.ntlmpacketBuffer;\n    }\n  }\n\n  onDatabaseChange(token: DatabaseEnvChangeToken) {\n    this.connection.emit('databaseChange', token.newValue);\n  }\n\n  onLanguageChange(token: LanguageEnvChangeToken) {\n    this.connection.emit('languageChange', token.newValue);\n  }\n\n  onCharsetChange(token: CharsetEnvChangeToken) {\n    this.connection.emit('charsetChange', token.newValue);\n  }\n\n  onSqlCollationChange(token: CollationChangeToken) {\n    this.connection.databaseCollation = token.newValue;\n  }\n\n  onFedAuthInfo(token: FedAuthInfoToken) {\n    this.fedAuthInfoToken = token;\n  }\n\n  onFeatureExtAck(token: FeatureExtAckToken) {\n    const { authentication } = this.connection.config;\n\n    if (authentication.type === 'azure-active-directory-password' || authentication.type === 'azure-active-directory-access-token' || authentication.type === 'azure-active-directory-msi-vm' || authentication.type === 'azure-active-directory-msi-app-service' || authentication.type === 'azure-active-directory-service-principal-secret') {\n      if (token.fedAuth === undefined) {\n        this.connection.loginError = new ConnectionError('Did not receive Active Directory authentication acknowledgement');\n      } else if (token.fedAuth.length !== 0) {\n        this.connection.loginError = new ConnectionError(`Active Directory authentication acknowledgment for ${authentication.type} authentication method includes extra data`);\n      }\n    } else if (token.fedAuth === undefined && token.utf8Support === undefined) {\n      this.connection.loginError = new ConnectionError('Received acknowledgement for unknown feature');\n    } else if (token.fedAuth) {\n      this.connection.loginError = new ConnectionError('Did not request Active Directory authentication, but received the acknowledgment');\n    }\n  }\n\n  onLoginAck(token: LoginAckToken) {\n    if (!token.tdsVersion) {\n      // unsupported TDS version\n      this.connection.loginError = new ConnectionError('Server responded with unknown TDS version.', 'ETDS');\n      return;\n    }\n\n    if (!token.interface) {\n      // unsupported interface\n      this.connection.loginError = new ConnectionError('Server responded with unsupported interface.', 'EINTERFACENOTSUPP');\n      return;\n    }\n\n    // use negotiated version\n    this.connection.config.options.tdsVersion = token.tdsVersion;\n\n    this.loginAckReceived = true;\n  }\n\n  onRoutingChange(token: RoutingEnvChangeToken) {\n    // Removes instance name attached to the redirect url. E.g., redirect.db.net\\instance1 --> redirect.db.net\n    const [ server ] = token.newValue.server.split('\\\\');\n\n    this.routingData = {\n      server, port: token.newValue.port\n    };\n  }\n\n  onDoneInProc(token: DoneInProcToken) {\n    // Do nothing\n  }\n\n  onDone(token: DoneToken) {\n    // Do nothing\n  }\n\n  onPacketSizeChange(token: PacketSizeEnvChangeToken) {\n    this.connection.messageIo.packetSize(token.newValue);\n  }\n\n  onDatabaseMirroringPartner(token: DatabaseMirroringPartnerEnvChangeToken) {\n    // Do nothing\n  }\n}\n\n/**\n * A handler for tokens received in the response message to a RPC Request,\n * a SQL Batch Request, a Bulk Load BCP Request or a Transaction Manager Request.\n */\nexport class RequestTokenHandler extends TokenHandler {\n  connection: Connection;\n  request: Request | BulkLoad;\n\n  constructor(connection: Connection, request: Request | BulkLoad) {\n    super();\n\n    this.connection = connection;\n    this.request = request;\n  }\n\n  onInfoMessage(token: InfoMessageToken) {\n    this.connection.emit('infoMessage', token);\n  }\n\n  onErrorMessage(token: ErrorMessageToken) {\n    this.connection.emit('errorMessage', token);\n\n    if (!this.request.canceled) {\n      const error = new RequestError(token.message, 'EREQUEST');\n\n      error.number = token.number;\n      error.state = token.state;\n      error.class = token.class;\n      error.serverName = token.serverName;\n      error.procName = token.procName;\n      error.lineNumber = token.lineNumber;\n\n      this.request.error = error;\n    }\n  }\n\n  onDatabaseChange(token: DatabaseEnvChangeToken) {\n    this.connection.emit('databaseChange', token.newValue);\n  }\n\n  onLanguageChange(token: LanguageEnvChangeToken) {\n    this.connection.emit('languageChange', token.newValue);\n  }\n\n  onCharsetChange(token: CharsetEnvChangeToken) {\n    this.connection.emit('charsetChange', token.newValue);\n  }\n\n  onSqlCollationChange(token: CollationChangeToken) {\n    this.connection.databaseCollation = token.newValue;\n  }\n\n  onPacketSizeChange(token: PacketSizeEnvChangeToken) {\n    this.connection.messageIo.packetSize(token.newValue);\n  }\n\n  onBeginTransaction(token: BeginTransactionEnvChangeToken) {\n    this.connection.transactionDescriptors.push(token.newValue);\n    this.connection.inTransaction = true;\n  }\n\n  onCommitTransaction(token: CommitTransactionEnvChangeToken) {\n    this.connection.transactionDescriptors.length = 1;\n    this.connection.inTransaction = false;\n  }\n\n  onRollbackTransaction(token: RollbackTransactionEnvChangeToken) {\n    this.connection.transactionDescriptors.length = 1;\n    // An outermost transaction was rolled back. Reset the transaction counter\n    this.connection.inTransaction = false;\n    this.connection.emit('rollbackTransaction');\n  }\n\n  onColMetadata(token: ColMetadataToken) {\n    if (!this.request.canceled) {\n      if (this.connection.config.options.useColumnNames) {\n        const columns: { [key: string]: ColumnMetadata } = Object.create(null);\n\n        for (let j = 0, len = token.columns.length; j < len; j++) {\n          const col = token.columns[j];\n          if (columns[col.colName] == null) {\n            columns[col.colName] = col;\n          }\n        }\n\n        this.request.emit('columnMetadata', columns);\n      } else {\n        this.request.emit('columnMetadata', token.columns);\n      }\n    }\n  }\n\n  onOrder(token: OrderToken) {\n    if (!this.request.canceled) {\n      this.request.emit('order', token.orderColumns);\n    }\n  }\n\n  onRow(token: RowToken | NBCRowToken) {\n    if (!this.request.canceled) {\n      if (this.connection.config.options.rowCollectionOnRequestCompletion) {\n        this.request.rows!.push(token.columns);\n      }\n\n      if (this.connection.config.options.rowCollectionOnDone) {\n        this.request.rst!.push(token.columns);\n      }\n\n      this.request.emit('row', token.columns);\n    }\n  }\n\n  onReturnStatus(token: ReturnStatusToken) {\n    if (!this.request.canceled) {\n      // Keep value for passing in 'doneProc' event.\n      this.connection.procReturnStatusValue = token.value;\n    }\n  }\n\n  onReturnValue(token: ReturnValueToken) {\n    if (!this.request.canceled) {\n      this.request.emit('returnValue', token.paramName, token.value, token.metadata);\n    }\n  }\n\n  onDoneProc(token: DoneProcToken) {\n    if (!this.request.canceled) {\n      if (token.sqlError && !this.request.error) {\n        // check if the DONE_ERROR flags was set, but an ERROR token was not sent.\n        this.request.error = new RequestError('An unknown error has occurred.', 'UNKNOWN');\n      }\n\n      this.request.emit('doneProc', token.rowCount, token.more, this.connection.procReturnStatusValue, this.request.rst);\n\n      this.connection.procReturnStatusValue = undefined;\n\n      if (token.rowCount !== undefined) {\n        this.request.rowCount! += token.rowCount;\n      }\n\n      if (this.connection.config.options.rowCollectionOnDone) {\n        this.request.rst = [];\n      }\n    }\n  }\n\n  onDoneInProc(token: DoneInProcToken) {\n    if (!this.request.canceled) {\n      this.request.emit('doneInProc', token.rowCount, token.more, this.request.rst);\n\n      if (token.rowCount !== undefined) {\n        this.request.rowCount! += token.rowCount;\n      }\n\n      if (this.connection.config.options.rowCollectionOnDone) {\n        this.request.rst = [];\n      }\n    }\n  }\n\n  onDone(token: DoneToken) {\n    if (!this.request.canceled) {\n      if (token.sqlError && !this.request.error) {\n        // check if the DONE_ERROR flags was set, but an ERROR token was not sent.\n        this.request.error = new RequestError('An unknown error has occurred.', 'UNKNOWN');\n      }\n\n      this.request.emit('done', token.rowCount, token.more, this.request.rst);\n\n      if (token.rowCount !== undefined) {\n        this.request.rowCount! += token.rowCount;\n      }\n\n      if (this.connection.config.options.rowCollectionOnDone) {\n        this.request.rst = [];\n      }\n    }\n  }\n\n  onResetConnection(token: ResetConnectionEnvChangeToken) {\n    this.connection.emit('resetConnection');\n  }\n}\n\n/**\n * A handler for the attention acknowledgement message.\n *\n * This message only contains a `DONE` token that acknowledges\n * that the attention message was received by the server.\n */\nexport class AttentionTokenHandler extends TokenHandler {\n  connection: Connection;\n  request: Request | BulkLoad;\n\n  /**\n   * Returns whether an attention acknowledgement was received.\n   */\n  attentionReceived: boolean;\n\n  constructor(connection: Connection, request: Request | BulkLoad) {\n    super();\n\n    this.connection = connection;\n    this.request = request;\n\n    this.attentionReceived = false;\n  }\n\n  onDone(token: DoneToken) {\n    if (token.attention) {\n      this.attentionReceived = true;\n    }\n  }\n}\n"]}

package/lib/token/token-stream-parser.js

@@ -14,7 +14,7 @@ var _stream = require("stream");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 class Parser extends _events.EventEmitter {
-  constructor(message, debug, options) {
+  constructor(message, debug, handler, options) {
     super();
     this.debug = void 0;
     this.options = void 0;
@@ -23,9 +23,7 @@ class Parser extends _events.EventEmitter {
     this.options = options;
     this.parser = _stream.Readable.from(_streamParser.default.parseTokens(message, this.debug, this.options));
     this.parser.on('data', token => {
-      if (token.event) {
-        this.emit(token.event, token);
-      }
+      handler[token.handlerName](token);
     });
     this.parser.on('drain', () => {
       this.emit('drain');
@@ -46,4 +44,4 @@ class Parser extends _events.EventEmitter {
 }
 
 exports.Parser = Parser;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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