ts-prorm-orm 1.1.0

package/dist/errors/index.js

@@ -0,0 +1,472 @@
+"use strict";
+/**
+ * Error classes for the ORM
+ * Provides structured error handling with error codes for programmatic handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyResultError = exports.AssociationError = exports.BulkRecordError = exports.ResourceLockedError = exports.TimeoutError = exports.ExclusionConstraintError = exports.ForeignKeyConstraintError = exports.UniqueConstraintError = exports.ValidationError = exports.DatabaseError = exports.ConnectionError = exports.PrormError = exports.ErrorCodes = void 0;
+exports.isPrormError = isPrormError;
+exports.isValidationError = isValidationError;
+exports.isConnectionError = isConnectionError;
+exports.isConstraintError = isConstraintError;
+exports.isEmptyResultError = isEmptyResultError;
+// Error code constants for programmatic error handling
+exports.ErrorCodes = {
+    // Connection errors
+    CONNECTION_ERROR: 'CONNECTION_ERROR',
+    CONNECTION_REFUSED: 'CONNECTION_REFUSED',
+    CONNECTION_TIMED_OUT: 'CONNECTION_TIMED_OUT',
+    HOST_NOT_REACHABLE: 'HOST_NOT_REACHABLE',
+    INVALID_CONNECTION: 'INVALID_CONNECTION',
+    // Database errors
+    DATABASE_ERROR: 'DATABASE_ERROR',
+    QUERY_ERROR: 'QUERY_ERROR',
+    UNKNOWN: 'UNKNOWN',
+    // Validation errors
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    VALIDATION_FAILED: 'VALIDATION_FAILED',
+    // Constraint errors
+    UNIQUE_CONSTRAINT_ERROR: 'UNIQUE_CONSTRAINT_ERROR',
+    FOREIGN_KEY_CONSTRAINT_ERROR: 'FOREIGN_KEY_CONSTRAINT_ERROR',
+    EXCLUSION_CONSTRAINT_ERROR: 'EXCLUSION_CONSTRAINT_ERROR',
+    CHECK_CONSTRAINT_ERROR: 'CHECK_CONSTRAINT_ERROR',
+    NOT_NULL_CONSTRAINT_ERROR: 'NOT_NULL_CONSTRAINT_ERROR',
+    // Resource errors
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    RESOURCE_LOCKED_ERROR: 'RESOURCE_LOCKED_ERROR',
+    DEADLOCK_ERROR: 'DEADLOCK_ERROR',
+    // Bulk operation errors
+    BULK_RECORD_ERROR: 'BULK_RECORD_ERROR',
+    // Association errors
+    ASSOCIATION_ERROR: 'ASSOCIATION_ERROR',
+    EAGER_LOAD_ERROR: 'EAGER_LOAD_ERROR',
+};
+/**
+ * Base error class for all Prorm errors
+ */
+class PrormError extends Error {
+    constructor(message, options = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = options.code || exports.ErrorCodes.UNKNOWN;
+        this.parent = options.parent;
+        this.sql = options.sql;
+        this.metadata = options.metadata;
+        // Maintains proper stack trace for where our error was thrown (V8 engines)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PrormError);
+        }
+    }
+    /**
+     * Convert to JSON for serialization
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            parent: this.parent?.message,
+            sql: this.sql,
+            metadata: this.metadata,
+            stack: this.stack,
+        };
+    }
+}
+exports.PrormError = PrormError;
+/**
+ * Error for database connection issues
+ */
+class ConnectionError extends PrormError {
+    constructor(message = 'Unable to connect to database', options = {}) {
+        super(message, {
+            code: options.code || exports.ErrorCodes.CONNECTION_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                database: options.database,
+                host: options.host,
+            },
+        });
+        this.database = options.database;
+        this.host = options.host;
+        this.name = 'ConnectionError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ConnectionError);
+        }
+    }
+    /**
+     * Create a connection refused error
+     */
+    static refused(options = {}) {
+        return new ConnectionError('Connection refused', {
+            code: exports.ErrorCodes.CONNECTION_REFUSED,
+            ...options,
+        });
+    }
+    /**
+     * Create a connection timeout error
+     */
+    static timedOut(options = {}) {
+        return new ConnectionError('Connection timed out', {
+            code: exports.ErrorCodes.CONNECTION_TIMED_OUT,
+            ...options,
+        });
+    }
+    /**
+     * Create a host unreachable error
+     */
+    static unreachable(options = {}) {
+        return new ConnectionError('Database host not reachable', {
+            code: exports.ErrorCodes.HOST_NOT_REACHABLE,
+            ...options,
+        });
+    }
+    /**
+     * Create an invalid connection error
+     */
+    static invalid(options = {}) {
+        return new ConnectionError('Invalid connection configuration', {
+            code: exports.ErrorCodes.INVALID_CONNECTION,
+            ...options,
+        });
+    }
+}
+exports.ConnectionError = ConnectionError;
+/**
+ * Error for general database errors
+ */
+class DatabaseError extends PrormError {
+    constructor(message = 'Database error occurred', options = {}) {
+        super(message, {
+            code: options.code || exports.ErrorCodes.DATABASE_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                original: options.original,
+            },
+        });
+        this.original = options.original;
+        this.name = 'DatabaseError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, DatabaseError);
+        }
+    }
+    /**
+     * Create from a parent error
+     */
+    static from(parent, options = {}) {
+        return new DatabaseError(options.message || parent.message, {
+            code: exports.ErrorCodes.QUERY_ERROR,
+            parent,
+            sql: options.sql,
+            original: parent.message,
+        });
+    }
+}
+exports.DatabaseError = DatabaseError;
+/**
+ * Error for validation failures
+ */
+class ValidationError extends PrormError {
+    constructor(message = 'Validation error', errors = []) {
+        super(message, {
+            code: exports.ErrorCodes.VALIDATION_ERROR,
+            metadata: { errors },
+        });
+        this.errors = errors;
+        this.name = 'ValidationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidationError);
+        }
+    }
+    /**
+     * Get all validation error messages
+     */
+    getMessages() {
+        return this.errors.map((err) => err.message);
+    }
+    /**
+     * Get errors for a specific field
+     */
+    getFieldErrors(path) {
+        return this.errors.filter((err) => err.path === path);
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Error for unique constraint violations
+ */
+class UniqueConstraintError extends ValidationError {
+    constructor(message = 'Unique constraint violation', options = {}) {
+        super(message, options.errors || []);
+        this.fields = options.fields;
+        this.name = 'UniqueConstraintError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, UniqueConstraintError);
+        }
+    }
+    /**
+     * Create from database error
+     */
+    static from(parent, options = {}) {
+        const errorItem = {
+            message: parent.message || 'Unique constraint violation',
+            type: 'UNIQUE_CONSTRAINT_ERROR',
+            value: undefined,
+        };
+        return new UniqueConstraintError(options.message || 'Unique constraint violation', {
+            errors: [errorItem],
+            fields: options.fields,
+            parent,
+            sql: options.sql,
+        });
+    }
+}
+exports.UniqueConstraintError = UniqueConstraintError;
+/**
+ * Error for foreign key constraint violations
+ */
+class ForeignKeyConstraintError extends PrormError {
+    constructor(message = 'Foreign key constraint violation', options = {}) {
+        super(message, {
+            code: options.code || exports.ErrorCodes.FOREIGN_KEY_CONSTRAINT_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                field: options.field,
+                table: options.table,
+                value: options.value,
+            },
+        });
+        this.field = options.field;
+        this.table = options.table;
+        this.value = options.value;
+        this.name = 'ForeignKeyConstraintError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ForeignKeyConstraintError);
+        }
+    }
+    /**
+     * Create from database error
+     */
+    static from(parent, options = {}) {
+        return new ForeignKeyConstraintError('Foreign key constraint violation', {
+            field: options.field,
+            table: options.table,
+            value: options.value,
+            parent,
+            sql: options.sql,
+        });
+    }
+}
+exports.ForeignKeyConstraintError = ForeignKeyConstraintError;
+/**
+ * Error for exclusion constraint violations
+ */
+class ExclusionConstraintError extends PrormError {
+    constructor(message = 'Exclusion constraint violation', options = {}) {
+        super(message, {
+            code: exports.ErrorCodes.EXCLUSION_CONSTRAINT_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                constraint: options.constraint,
+            },
+        });
+        this.constraint = options.constraint;
+        this.name = 'ExclusionConstraintError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ExclusionConstraintError);
+        }
+    }
+}
+exports.ExclusionConstraintError = ExclusionConstraintError;
+/**
+ * Error for query timeout
+ */
+class TimeoutError extends PrormError {
+    constructor(message = 'Query timeout', options = {}) {
+        super(message, {
+            code: exports.ErrorCodes.TIMEOUT_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                timeout: options.timeout,
+            },
+        });
+        this.timeout = options.timeout || 0;
+        this.name = 'TimeoutError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, TimeoutError);
+        }
+    }
+}
+exports.TimeoutError = TimeoutError;
+/**
+ * Error for resource locked
+ */
+class ResourceLockedError extends PrormError {
+    constructor(message = 'Resource is locked', options = {}) {
+        super(message, {
+            code: exports.ErrorCodes.RESOURCE_LOCKED_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                resource: options.resource,
+            },
+        });
+        this.resource = options.resource;
+        this.name = 'ResourceLockedError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ResourceLockedError);
+        }
+    }
+}
+exports.ResourceLockedError = ResourceLockedError;
+/**
+ * Error for bulk operation failures
+ */
+class BulkRecordError extends PrormError {
+    constructor(message = 'Bulk operation error', options = {}) {
+        super(message, {
+            code: exports.ErrorCodes.BULK_RECORD_ERROR,
+            parent: options.parent,
+            sql: options.sql,
+            metadata: {
+                errorCount: options.errors?.length || 0,
+            },
+        });
+        this.errors = options.errors || [];
+        this.name = 'BulkRecordError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, BulkRecordError);
+        }
+    }
+    /**
+     * Get total number of errors
+     */
+    get errorCount() {
+        return this.errors.length;
+    }
+    /**
+     * Get all error messages
+     */
+    getMessages() {
+        return this.errors.map((err) => {
+            const errorMsg = typeof err.error === 'string' ? err.error : err.error.message;
+            return `Record ${err.index}: ${errorMsg}`;
+        });
+    }
+}
+exports.BulkRecordError = BulkRecordError;
+/**
+ * Error for association errors
+ */
+class AssociationError extends PrormError {
+    constructor(message = 'Association error', options = {}) {
+        super(message, {
+            code: exports.ErrorCodes.ASSOCIATION_ERROR,
+            parent: options.parent,
+            metadata: {
+                association: options.association,
+            },
+        });
+        this.association = options.association;
+        this.name = 'AssociationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, AssociationError);
+        }
+    }
+}
+exports.AssociationError = AssociationError;
+/**
+ * Error when no results are found but results were expected
+ */
+class EmptyResultError extends PrormError {
+    constructor(message = 'No results found', options = {}) {
+        super(message, {
+            code: exports.ErrorCodes.UNKNOWN,
+            parent: options.parent,
+            metadata: {
+                model: options.model,
+                primaryKey: options.primaryKey,
+                where: options.where,
+            },
+        });
+        this.model = options.model;
+        this.primaryKey = options.primaryKey;
+        this.where = options.where;
+        this.name = 'EmptyResultError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, EmptyResultError);
+        }
+    }
+    /**
+     * Get a descriptive message for the error
+     */
+    getMessage() {
+        if (this.model && this.primaryKey !== undefined) {
+            return `Instance with ${this.model} and primary key ${JSON.stringify(this.primaryKey)} not found`;
+        }
+        if (this.model) {
+            return `No instance with the provided criteria found in ${this.model}`;
+        }
+        return this.message;
+    }
+}
+exports.EmptyResultError = EmptyResultError;
+/**
+ * Type guard to check if error is a Prorm error
+ */
+function isPrormError(error) {
+    return error instanceof PrormError;
+}
+/**
+ * Type guard to check if error is a ValidationError
+ */
+function isValidationError(error) {
+    return error instanceof ValidationError;
+}
+/**
+ * Type guard to check if error is a ConnectionError
+ */
+function isConnectionError(error) {
+    return error instanceof ConnectionError;
+}
+/**
+ * Type guard to check if error is a constraint error
+ */
+function isConstraintError(error) {
+    return (error instanceof UniqueConstraintError ||
+        error instanceof ForeignKeyConstraintError ||
+        error instanceof ExclusionConstraintError);
+}
+/**
+ * Type guard to check if error is an EmptyResultError
+ */
+function isEmptyResultError(error) {
+    return error instanceof EmptyResultError;
+}
+/**
+ * Export all error classes
+ */
+exports.default = {
+    PrormError,
+    ConnectionError,
+    DatabaseError,
+    ValidationError,
+    UniqueConstraintError,
+    ForeignKeyConstraintError,
+    ExclusionConstraintError,
+    TimeoutError,
+    ResourceLockedError,
+    BulkRecordError,
+    AssociationError,
+    EmptyResultError,
+    ErrorCodes: exports.ErrorCodes,
+    isPrormError,
+    isValidationError,
+    isConnectionError,
+    isConstraintError,
+    isEmptyResultError,
+};