feat(types): transition lib/errors

lib/dialects/mssql/async-queue.ts

@@ -0,0 +1,59 @@
+import { BaseError, ConnectionError } from '../../errors';
+
+/**
+ * Thrown when a connection to a database is closed while an operation is in progress
+ */
+export class AsyncQueueError extends BaseError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SequelizeAsyncQueueError';
+  }
+}
+
+class AsyncQueue {
+  previous: Promise<unknown>;
+  closed: boolean;
+  rejectCurrent: (reason?: any) => void;
+
+  constructor() {
+    this.previous = Promise.resolve();
+    this.closed = false;
+    this.rejectCurrent = () => {
+      /** do nothing */
+    };
+  }
+
+  close() {
+    this.closed = true;
+    this.rejectCurrent(
+      new ConnectionError(
+        new AsyncQueueError(
+          'the connection was closed before this query could finish executing'
+        )
+      )
+    );
+  }
+
+  enqueue(asyncFunction: (...args: any[]) => Promise<unknown>) {
+    // This outer promise might seems superflous since down below we return asyncFunction().then(resolve, reject).
+    // However, this ensures that this.previous will never be a rejected promise so the queue will
+    // always keep going, while still communicating rejection from asyncFunction to the user.
+    return new Promise((resolve, reject) => {
+      this.previous = this.previous.then(() => {
+        this.rejectCurrent = reject;
+        if (this.closed) {
+          return reject(
+            new ConnectionError(
+              new AsyncQueueError(
+                'the connection was closed before this query could be executed'
+              )
+            )
+          );
+        }
+        return asyncFunction().then(resolve, reject);
+      });
+    });
+  }
+}
+
+export default AsyncQueue;

lib/errors/aggregate-error.ts

@@ -0,0 +1,33 @@
+import BaseError from './base-error';
+
+/**
+ * A wrapper for multiple Errors
+ *
+ * @param {Error[]} [errors] Array of errors
+ *
+ * @property errors {Error[]}
+ */
+class AggregateError extends BaseError {
+  errors: Array<AggregateError | Error>;
+
+  constructor(errors: Array<AggregateError | Error>) {
+    super('');
+    this.errors = errors;
+    this.name = 'AggregateError';
+  }
+
+  toString(): string {
+    const message = `AggregateError of:\n${this.errors
+      .map((error: Error | AggregateError) =>
+        error === this
+          ? '[Circular AggregateError]'
+          : error instanceof AggregateError
+            ? String(error).replace(/\n$/, '').replace(/^/gm, '  ')
+            : String(error).replace(/^/gm, '    ').substring(2)
+      )
+      .join('\n')}\n`;
+    return message;
+  }
+}
+
+export default AggregateError;

lib/errors/association-error.js → lib/errors/association-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const BaseError = require('./base-error');
+import BaseError from './base-error';
 
 /**
  * Thrown when an association is improperly constructed (see message for details)
  */
 class AssociationError extends BaseError {
-  constructor(message) {
+  constructor(message: string) {
     super(message);
     this.name = 'SequelizeAssociationError';
   }
 }
 
-module.exports = AssociationError;
+export default AssociationError;

lib/errors/base-error.js → lib/errors/base-error.ts

@@ -1,4 +1,17 @@
-'use strict';
+export interface ErrorOptions {
+  stack?: string;
+}
+
+export interface CommonErrorProperties {
+  /** The database specific error which triggered this one */
+  readonly parent: Error;
+
+  /** The database specific error which triggered this one */
+  readonly original: Error;
+
+  /** The SQL that triggered the error */
+  readonly sql: string;
+}
 
 /**
  * Sequelize provides a host of custom error classes, to allow you to do easier debugging. All of these errors are exposed on the sequelize object and the sequelize constructor.
@@ -8,10 +21,10 @@
  * The Base Error all Sequelize Errors inherit from.
  */
 class BaseError extends Error {
-  constructor(message) {
+  constructor(message: string) {
     super(message);
     this.name = 'SequelizeBaseError';
   }
 }
 
-module.exports = BaseError;
+export default BaseError;

lib/errors/bulk-record-error.js → lib/errors/bulk-record-error.ts

@@ -1,6 +1,5 @@
-'use strict';
-
-const BaseError = require('./base-error');
+import BaseError from './base-error';
+import type { Model } from '../../types/lib/model';
 
 /**
  * Thrown when bulk operation fails, it represent per record level error.
@@ -10,12 +9,15 @@ const BaseError = require('./base-error');
  * @param {object} record  DAO instance that error belongs to
  */
 class BulkRecordError extends BaseError {
-  constructor(error, record) {
+  errors: Error;
+  record: Model;
+
+  constructor(error: Error, record: Model) {
     super(error.message);
     this.name = 'SequelizeBulkRecordError';
     this.errors = error;
     this.record = record;
   }
 }
 
-module.exports = BulkRecordError;
+export default BulkRecordError;

lib/errors/connection-error.js → lib/errors/connection-error.ts

@@ -1,12 +1,13 @@
-'use strict';
-
-const BaseError = require('./base-error');
+import BaseError from './base-error';
 
 /**
  * A base class for all connection related errors.
  */
 class ConnectionError extends BaseError {
-  constructor(parent) {
+  parent: Error;
+  original: Error;
+
+  constructor(parent: Error) {
     super(parent ? parent.message : '');
     this.name = 'SequelizeConnectionError';
     /**
@@ -19,4 +20,4 @@ class ConnectionError extends BaseError {
   }
 }
 
-module.exports = ConnectionError;
+export default ConnectionError;

lib/errors/connection/access-denied-error.js → lib/errors/connection/access-denied-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const ConnectionError = require('./../connection-error');
+import ConnectionError from './../connection-error';
 
 /**
  * Thrown when a connection to a database is refused due to insufficient privileges
  */
 class AccessDeniedError extends ConnectionError {
-  constructor(parent) {
+  constructor(parent: Error) {
     super(parent);
     this.name = 'SequelizeAccessDeniedError';
   }
 }
 
-module.exports = AccessDeniedError;
+export default AccessDeniedError;

lib/errors/connection/connection-acquire-timeout-error.js → lib/errors/connection/connection-acquire-timeout-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const ConnectionError = require('./../connection-error');
+import ConnectionError from '../connection-error';
 
 /**
  * Thrown when connection is not acquired due to timeout
  */
 class ConnectionAcquireTimeoutError extends ConnectionError {
-  constructor(parent) {
+  constructor(parent: Error) {
     super(parent);
     this.name = 'SequelizeConnectionAcquireTimeoutError';
   }
 }
 
-module.exports = ConnectionAcquireTimeoutError;
+export default ConnectionAcquireTimeoutError;

lib/errors/connection/connection-refused-error.js → lib/errors/connection/connection-refused-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const ConnectionError = require('./../connection-error');
+import ConnectionError from '../connection-error';
 
 /**
  * Thrown when a connection to a database is refused
  */
 class ConnectionRefusedError extends ConnectionError {
-  constructor(parent) {
+  constructor(parent: Error) {
     super(parent);
     this.name = 'SequelizeConnectionRefusedError';
   }
 }
 
-module.exports = ConnectionRefusedError;
+export default ConnectionRefusedError;

lib/errors/connection/connection-timed-out-error.js → lib/errors/connection/connection-timed-out-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const ConnectionError = require('./../connection-error');
+import ConnectionError from '../connection-error';
 
 /**
  * Thrown when a connection to a database times out
  */
 class ConnectionTimedOutError extends ConnectionError {
-  constructor(parent) {
+  constructor(parent: Error) {
     super(parent);
     this.name = 'SequelizeConnectionTimedOutError';
   }
 }
 
-module.exports = ConnectionTimedOutError;
+export default ConnectionTimedOutError;

lib/errors/connection/host-not-found-error.js → lib/errors/connection/host-not-found-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const ConnectionError = require('./../connection-error');
+import ConnectionError from '../connection-error';
 
 /**
  * Thrown when a connection to a database has a hostname that was not found
  */
 class HostNotFoundError extends ConnectionError {
-  constructor(parent) {
+  constructor(parent: Error) {
     super(parent);
     this.name = 'SequelizeHostNotFoundError';
   }
 }
 
-module.exports = HostNotFoundError;
+export default HostNotFoundError;

lib/errors/connection/host-not-reachable-error.js → lib/errors/connection/host-not-reachable-error.ts

@@ -1,15 +1,13 @@
-'use strict';
-
-const ConnectionError = require('./../connection-error');
+import ConnectionError from '../connection-error';
 
 /**
  * Thrown when a connection to a database has a hostname that was not reachable
  */
 class HostNotReachableError extends ConnectionError {
-  constructor(parent) {
+  constructor(parent: Error) {
     super(parent);
     this.name = 'SequelizeHostNotReachableError';
   }
 }
 
-module.exports = HostNotReachableError;
+export default HostNotReachableError;