fix(types): deduplicate error typings

lib/errors/aggregate-error.ts

@@ -3,10 +3,11 @@ import BaseError from './base-error';
 /**
  * A wrapper for multiple Errors
  *
- * @param errors Array of errors
+ * @param errors The aggregated errors that occurred
  */
 class AggregateError extends BaseError {
-  errors: Array<AggregateError | Error>;
+  /** the aggregated errors that occurred */
+  readonly errors: Array<AggregateError | Error>;
 
   constructor(errors: Array<AggregateError | Error>) {
     super();

lib/errors/base-error.ts

@@ -14,11 +14,12 @@ export interface CommonErrorProperties {
 }
 
 /**
+ * The Base Error all Sequelize Errors inherit from.
+ *
  * 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.
  * All sequelize errors inherit from the base JS error object.
  *
  * This means that errors can be accessed using `Sequelize.ValidationError`
- * The Base Error all Sequelize Errors inherit from.
  */
 abstract class BaseError extends Error {
   constructor(message?: string) {

lib/errors/bulk-record-error.ts

@@ -1,4 +1,4 @@
-import type { Model } from '../../types/lib/model';
+import type { Model } from '../..';
 import BaseError from './base-error';
 
 /**

lib/errors/database-error.ts

@@ -24,6 +24,10 @@ class DatabaseError
   sql: string;
   parameters: object;
 
+  /**
+   * @param parent The database specific error which triggered this one
+   * @param options
+   */
   constructor(parent: DatabaseErrorParent, options: ErrorOptions = {}) {
     super(parent.message);
     this.name = 'SequelizeDatabaseError';

lib/errors/database/exclusion-constraint-error.ts

@@ -2,20 +2,18 @@ import type { DatabaseErrorSubclassOptions } from '../database-error';
 import DatabaseError from '../database-error';
 
 interface ExclusionConstraintErrorOptions {
-  constraint: string;
-  fields: Record<string, string | number>;
-  table: string;
+  constraint?: string;
+  fields?: Record<string, string | number>;
+  table?: string;
 }
 
 /**
  * Thrown when an exclusion constraint is violated in the database
  */
-class ExclusionConstraintError
-  extends DatabaseError
-  implements ExclusionConstraintErrorOptions {
-  constraint: string;
-  fields: Record<string, string | number>;
-  table: string;
+class ExclusionConstraintError extends DatabaseError implements ExclusionConstraintErrorOptions {
+  constraint: string | undefined;
+  fields: Record<string, string | number> | undefined;
+  table: string | undefined;
 
   constructor(
     options: DatabaseErrorSubclassOptions & ExclusionConstraintErrorOptions,

lib/errors/database/foreign-key-constraint-error.ts

@@ -7,22 +7,22 @@ export enum RelationshipType {
 }
 
 interface ForeignKeyConstraintErrorOptions {
-  table: string;
-  fields: { [field: string]: string };
-  value: unknown;
-  index: string;
-  reltype: RelationshipType;
+  table?: string;
+  fields?: { [field: string]: string };
+  value?: unknown;
+  index?: string;
+  reltype?: RelationshipType;
 }
 
 /**
  * Thrown when a foreign key constraint is violated in the database
  */
 class ForeignKeyConstraintError extends DatabaseError {
-  table: string;
-  fields: { [field: string]: string };
+  table: string | undefined;
+  fields: { [field: string]: string } | undefined;
   value: unknown;
-  index: string;
-  reltype: RelationshipType;
+  index: string | undefined;
+  reltype: RelationshipType | undefined;
 
   constructor(
     options: ForeignKeyConstraintErrorOptions & DatabaseErrorSubclassOptions,

lib/errors/database/unknown-constraint-error.ts

@@ -2,20 +2,18 @@ import type { DatabaseErrorSubclassOptions } from '../database-error';
 import DatabaseError from '../database-error';
 
 interface UnknownConstraintErrorOptions {
-  constraint: string;
-  fields: Record<string, string | number>;
-  table: string;
+  constraint?: string;
+  fields?: Record<string, string | number>;
+  table?: string;
 }
 
 /**
  * Thrown when constraint name is not found in the database
  */
-class UnknownConstraintError
-  extends DatabaseError
-  implements UnknownConstraintErrorOptions {
-  constraint: string;
-  fields: Record<string, string | number>;
-  table: string;
+class UnknownConstraintError extends DatabaseError implements UnknownConstraintErrorOptions {
+  constraint: string | undefined;
+  fields: Record<string, string | number> | undefined;
+  table: string | undefined;
 
   constructor(
     options: UnknownConstraintErrorOptions & DatabaseErrorSubclassOptions,

lib/errors/optimistic-lock-error.ts

@@ -15,9 +15,9 @@ interface OptimisticLockErrorOptions {
  * Thrown when attempting to update a stale model instance
  */
 class OptimisticLockError extends BaseError {
-  modelName?: string;
-  values?: Record<string, unknown>;
-  where?: Record<string, unknown>;
+  modelName: string | undefined;
+  values: Record<string, unknown> | undefined;
+  where: Record<string, unknown> | undefined;
 
   constructor(options: OptimisticLockErrorOptions) {
     options = options || {};

lib/errors/validation-error.ts

@@ -1,4 +1,4 @@
-import type { Model } from '../../types/lib/model';
+import type { Model } from '../..';
 import type { ErrorOptions } from './base-error';
 import BaseError from './base-error';
 
@@ -52,44 +52,44 @@ export class ValidationErrorItem {
   /**
    * An error message
    */
-  message: string;
+  readonly message: string;
 
   /**
    * The type/origin of the validation error
    */
-  type: keyof typeof ValidationErrorItemType | null;
+  readonly type: keyof typeof ValidationErrorItemType | null;
 
   /**
    * The field that triggered the validation error
    */
-  path: string | null;
+  readonly path: string | null;
 
   /**
    * The value that generated the error
    */
-  value: string | null;
+  readonly value: string | null;
 
-  origin: keyof typeof ValidationErrorItemOrigin | null;
+  readonly origin: keyof typeof ValidationErrorItemOrigin | null;
 
   /**
    * The DAO instance that caused the validation error
    */
-  instance: Model | null;
+  readonly instance: Model | null;
 
   /**
    * A validation "key", used for identification
    */
-  validatorKey: string | null;
+  readonly validatorKey: string | null;
 
   /**
    * Property name of the BUILT-IN validator function that caused the validation error (e.g. "in" or "len"), if applicable
    */
-  validatorName: string | null;
+  readonly validatorName: string | null;
 
   /**
    * Parameters used with the BUILT-IN validator function, if applicable
    */
-  validatorArgs: unknown[];
+  readonly validatorArgs: unknown[];
 
   /**
    * Creates a new ValidationError item. Instances of this class are included in the `ValidationError.errors` property.
@@ -203,7 +203,8 @@ export class ValidationErrorItem {
  * @param errors Array of ValidationErrorItem objects describing the validation errors
  */
 class ValidationError extends BaseError {
-  errors: ValidationErrorItem[];
+  /** Array of ValidationErrorItem objects describing the validation errors */
+  readonly errors: ValidationErrorItem[];
 
   constructor(
     message: string,

lib/errors/validation/unique-constraint-error.ts

@@ -6,7 +6,7 @@ interface UniqueConstraintErrorParent
   extends Error,
     Pick<CommonErrorProperties, 'sql'> {}
 
-interface UniqueConstraintErrorOptions extends ErrorOptions {
+export interface UniqueConstraintErrorOptions extends ErrorOptions {
   parent?: UniqueConstraintErrorParent;
   original?: UniqueConstraintErrorParent;
   errors?: ValidationErrorItem[];
@@ -17,13 +17,11 @@ interface UniqueConstraintErrorOptions extends ErrorOptions {
 /**
  * Thrown when a unique constraint is violated in the database
  */
-class UniqueConstraintError
-  extends ValidationError
-  implements CommonErrorProperties {
-  parent: UniqueConstraintErrorParent;
-  original: UniqueConstraintErrorParent;
-  fields: Record<string, unknown>;
-  sql: string;
+class UniqueConstraintError extends ValidationError implements CommonErrorProperties {
+  readonly parent: UniqueConstraintErrorParent;
+  readonly original: UniqueConstraintErrorParent;
+  readonly fields: Record<string, unknown>;
+  readonly sql: string;
 
   constructor(options: UniqueConstraintErrorOptions) {
     options = options ?? {};
@@ -34,7 +32,6 @@ class UniqueConstraintError
     super(options.message, options.errors, { stack: options.stack });
 
     this.name = 'SequelizeUniqueConstraintError';
-    this.errors = options.errors;
     this.fields = options.fields ?? {};
     this.parent = options.parent;
     this.original = options.parent;

types/index.d.ts

@@ -11,8 +11,8 @@ export * from "../lib/transaction";
 export type { Connection } from "./lib/connection-manager";
 export * from "./lib/associations/index";
 export * from "./lib/data-types";
-export * from "./lib/errors";
-export { BaseError as Error } from "./lib/errors";
+export * from "../lib/errors";
+export { BaseError as Error } from "../lib/errors";
 export * from "./lib/model";
 export * from "./lib/query-interface";
 export * from "./lib/sequelize";