@hemia/common 0.0.4 → 0.0.6

package/dist/hemia-common.esm.js

@@ -250,4 +250,235 @@ class HttpErrorWithDetails extends HttpError {
     }
 }
 
-export { ApiResponse, BadRequestError, Body, ConflictError, Controller, CustomHttpError, Delete, ForbiddenError, GatewayTimeoutError, Get, Head, Header, Headers, Host, HttpError, HttpErrorWithDetails, HttpMethod, InternalServerError, Ip, METADATA_KEYS, Next, NotFoundError, Options, Param, ParamType, Patch, Post, Put, Query, Redirect, Req, Request, Res, Response, Serialize, ServiceUnavailableError, Session, SetMetadata, UnauthorizedError, UnprocessableEntityError, UseGuards, UseInterceptors, isRedirectResponse };
+class PersistenceError extends Error {
+    constructor(message, originalError) {
+        super(message);
+        this.originalError = originalError;
+        this.name = 'PersistenceError';
+    }
+}
+class DataNotFoundError extends PersistenceError {
+    constructor(entity, criteria, originalError) {
+        super(`${entity} not found with criteria: ${criteria}`, originalError);
+        this.name = 'DataNotFoundError';
+    }
+}
+class DataConflictError extends PersistenceError {
+    constructor(entity, criteria, originalError) {
+        super(`Data conflict for ${entity} with criteria: ${criteria}`, originalError);
+        this.name = 'DataConflictError';
+    }
+}
+class DataValidationError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Data Validation Error: ${message}`, originalError);
+        this.name = 'DataValidationError';
+    }
+}
+class TransactionError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Transaction Error: ${message}`, originalError);
+        this.name = 'TransactionError';
+    }
+}
+class QueryExecutionError extends PersistenceError {
+    constructor(query, originalError) {
+        super(`Query Execution Error for query: ${query}`, originalError);
+        this.name = 'QueryExecutionError';
+    }
+}
+class ConnectionError extends PersistenceError {
+    constructor(databaseType, originalError) {
+        super(`Connection Error to ${databaseType} database`, originalError);
+        this.name = 'ConnectionError';
+    }
+}
+class SchemaMismatchError extends PersistenceError {
+    constructor(expectedSchema, actualSchema, originalError) {
+        super(`Schema Mismatch Error: expected ${expectedSchema}, got ${actualSchema}`, originalError);
+        this.name = 'SchemaMismatchError';
+    }
+}
+class DataIntegrityError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Data Integrity Error: ${message}`, originalError);
+        this.name = 'DataIntegrityError';
+    }
+}
+class BackupError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Backup Error: ${message}`, originalError);
+        this.name = 'BackupError';
+    }
+}
+class RestoreError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Restore Error: ${message}`, originalError);
+        this.name = 'RestoreError';
+    }
+}
+class IndexingError extends PersistenceError {
+    constructor(indexName, originalError) {
+        super(`Indexing Error on index: ${indexName}`, originalError);
+        this.name = 'IndexingError';
+    }
+}
+class DataMigrationError extends PersistenceError {
+    constructor(migrationName, originalError) {
+        super(`Data Migration Error during migration: ${migrationName}`, originalError);
+        this.name = 'DataMigrationError';
+    }
+}
+class ResourceLimitError extends PersistenceError {
+    constructor(resourceType, limit, originalError) {
+        super(`Resource Limit Exceeded: ${resourceType} limit of ${limit} has been exceeded`, originalError);
+        this.name = 'ResourceLimitError';
+    }
+}
+
+/**
+ * Errores de lógica de negocio (Business Layer)
+ * No conocen HTTP, son agnósticos a la infraestructura
+ */
+class DomainError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DomainError';
+    }
+}
+class EntityNotFoundError extends DomainError {
+    constructor(entity, criteria) {
+        super(`${entity} not found with criteria: ${criteria}`);
+        this.name = 'EntityNotFoundError';
+    }
+}
+class DuplicateEntityError extends DomainError {
+    constructor(entity, criteria) {
+        super(`Duplicate ${entity} found with criteria: ${criteria}`);
+        this.name = 'DuplicateEntityError';
+    }
+}
+class ValidationError extends DomainError {
+    constructor(message) {
+        super(`Validation Error: ${message}`);
+        this.name = 'ValidationError';
+    }
+}
+class BusinessRuleViolationError extends DomainError {
+    constructor(message) {
+        super(`Business Rule Violation: ${message}`);
+        this.name = 'BusinessRuleViolationError';
+    }
+}
+class OperationNotAllowedError extends DomainError {
+    constructor(operation) {
+        super(`Operation not allowed: ${operation}`);
+        this.name = 'OperationNotAllowedError';
+    }
+}
+class DependencyError extends DomainError {
+    constructor(dependency, message) {
+        super(`Dependency Error in ${dependency}: ${message}`);
+        this.name = 'DependencyError';
+    }
+}
+class TimeoutError extends DomainError {
+    constructor(operation, timeout) {
+        super(`Timeout Error: Operation "${operation}" exceeded time limit of ${timeout}ms`);
+        this.name = 'TimeoutError';
+    }
+}
+class ResourceLimitExceededError extends DomainError {
+    constructor(resource, limit) {
+        super(`Resource Limit Exceeded: ${resource} limit of ${limit} has been exceeded`);
+        this.name = 'ResourceLimitExceededError';
+    }
+}
+class ConfigurationError extends DomainError {
+    constructor(message) {
+        super(`Configuration Error: ${message}`);
+        this.name = 'ConfigurationError';
+    }
+}
+
+class InfrastructureError extends Error {
+    constructor(message, originalError) {
+        super(message);
+        this.originalError = originalError;
+        this.name = 'InfrastructureError';
+    }
+}
+class InfraDatabaseConnectionError extends InfrastructureError {
+    constructor(dbType, originalError) {
+        super(`Failed to connect to the ${dbType} database`, originalError);
+        this.name = 'InfraDatabaseConnectionError';
+    }
+}
+class InfraCacheConnectionError extends InfrastructureError {
+    constructor(cacheType, originalError) {
+        super(`Failed to connect to the ${cacheType} cache`, originalError);
+        this.name = 'InfraCacheConnectionError';
+    }
+}
+class InfraMessageQueueError extends InfrastructureError {
+    constructor(queueType, originalError) {
+        super(`Message Queue Error in ${queueType}`, originalError);
+        this.name = 'InfraMessageQueueError';
+    }
+}
+class InfraExternalServiceError extends InfrastructureError {
+    constructor(serviceName, originalError) {
+        super(`External Service Error: ${serviceName}`, originalError);
+        this.name = 'InfraExternalServiceError';
+    }
+}
+class InfraConfigurationError extends InfrastructureError {
+    constructor(configItem, originalError) {
+        super(`Configuration Error: ${configItem}`, originalError);
+        this.name = 'InfraConfigurationError';
+    }
+}
+class InfraNetworkError extends InfrastructureError {
+    constructor(message, originalError) {
+        super(`Network Error: ${message}`, originalError);
+        this.name = 'InfraNetworkError';
+    }
+}
+class InfraTimeoutError extends InfrastructureError {
+    constructor(operation, timeout, originalError) {
+        super(`Timeout Error: Operation "${operation}" exceeded time limit of ${timeout}ms`, originalError);
+        this.name = 'InfraTimeoutError';
+    }
+}
+class InfraAuthenticationError extends InfrastructureError {
+    constructor(message, originalError) {
+        super(`Authentication Error: ${message}`, originalError);
+        this.name = 'InfraAuthenticationError';
+    }
+}
+class InfraAuthorizationError extends InfrastructureError {
+    constructor(message, originalError) {
+        super(`Authorization Error: ${message}`, originalError);
+        this.name = 'InfraAuthorizationError';
+    }
+}
+class InfraServiceUnavailableError extends InfrastructureError {
+    constructor(serviceName, originalError) {
+        super(`Service Unavailable: ${serviceName}`, originalError);
+        this.name = 'InfraServiceUnavailableError';
+    }
+}
+class InfraDataSerializationError extends InfrastructureError {
+    constructor(dataType, originalError) {
+        super(`Data Serialization Error for type: ${dataType}`, originalError);
+        this.name = 'InfraDataSerializationError';
+    }
+}
+class InfraDataDeserializationError extends InfrastructureError {
+    constructor(dataType, originalError) {
+        super(`Data Deserialization Error for type: ${dataType}`, originalError);
+        this.name = 'InfraDataDeserializationError';
+    }
+}
+
+export { ApiResponse, BackupError, BadRequestError, Body, BusinessRuleViolationError, ConfigurationError, ConflictError, ConnectionError, Controller, CustomHttpError, DataConflictError, DataIntegrityError, DataMigrationError, DataNotFoundError, DataValidationError, Delete, DependencyError, DomainError, DuplicateEntityError, EntityNotFoundError, ForbiddenError, GatewayTimeoutError, Get, Head, Header, Headers, Host, HttpError, HttpErrorWithDetails, HttpMethod, IndexingError, InfraAuthenticationError, InfraAuthorizationError, InfraCacheConnectionError, InfraConfigurationError, InfraDataDeserializationError, InfraDataSerializationError, InfraDatabaseConnectionError, InfraExternalServiceError, InfraMessageQueueError, InfraNetworkError, InfraServiceUnavailableError, InfraTimeoutError, InfrastructureError, InternalServerError, Ip, METADATA_KEYS, Next, NotFoundError, OperationNotAllowedError, Options, Param, ParamType, Patch, PersistenceError, Post, Put, Query, QueryExecutionError, Redirect, Req, Request, Res, ResourceLimitError, ResourceLimitExceededError, Response, RestoreError, SchemaMismatchError, Serialize, ServiceUnavailableError, Session, SetMetadata, TimeoutError, TransactionError, UnauthorizedError, UnprocessableEntityError, UseGuards, UseInterceptors, ValidationError, isRedirectResponse };

package/dist/hemia-common.js

@@ -252,13 +252,257 @@ class HttpErrorWithDetails extends HttpError {
     }
 }
 
+class PersistenceError extends Error {
+    constructor(message, originalError) {
+        super(message);
+        this.originalError = originalError;
+        this.name = 'PersistenceError';
+    }
+}
+class DataNotFoundError extends PersistenceError {
+    constructor(entity, criteria, originalError) {
+        super(`${entity} not found with criteria: ${criteria}`, originalError);
+        this.name = 'DataNotFoundError';
+    }
+}
+class DataConflictError extends PersistenceError {
+    constructor(entity, criteria, originalError) {
+        super(`Data conflict for ${entity} with criteria: ${criteria}`, originalError);
+        this.name = 'DataConflictError';
+    }
+}
+class DataValidationError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Data Validation Error: ${message}`, originalError);
+        this.name = 'DataValidationError';
+    }
+}
+class TransactionError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Transaction Error: ${message}`, originalError);
+        this.name = 'TransactionError';
+    }
+}
+class QueryExecutionError extends PersistenceError {
+    constructor(query, originalError) {
+        super(`Query Execution Error for query: ${query}`, originalError);
+        this.name = 'QueryExecutionError';
+    }
+}
+class ConnectionError extends PersistenceError {
+    constructor(databaseType, originalError) {
+        super(`Connection Error to ${databaseType} database`, originalError);
+        this.name = 'ConnectionError';
+    }
+}
+class SchemaMismatchError extends PersistenceError {
+    constructor(expectedSchema, actualSchema, originalError) {
+        super(`Schema Mismatch Error: expected ${expectedSchema}, got ${actualSchema}`, originalError);
+        this.name = 'SchemaMismatchError';
+    }
+}
+class DataIntegrityError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Data Integrity Error: ${message}`, originalError);
+        this.name = 'DataIntegrityError';
+    }
+}
+class BackupError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Backup Error: ${message}`, originalError);
+        this.name = 'BackupError';
+    }
+}
+class RestoreError extends PersistenceError {
+    constructor(message, originalError) {
+        super(`Restore Error: ${message}`, originalError);
+        this.name = 'RestoreError';
+    }
+}
+class IndexingError extends PersistenceError {
+    constructor(indexName, originalError) {
+        super(`Indexing Error on index: ${indexName}`, originalError);
+        this.name = 'IndexingError';
+    }
+}
+class DataMigrationError extends PersistenceError {
+    constructor(migrationName, originalError) {
+        super(`Data Migration Error during migration: ${migrationName}`, originalError);
+        this.name = 'DataMigrationError';
+    }
+}
+class ResourceLimitError extends PersistenceError {
+    constructor(resourceType, limit, originalError) {
+        super(`Resource Limit Exceeded: ${resourceType} limit of ${limit} has been exceeded`, originalError);
+        this.name = 'ResourceLimitError';
+    }
+}
+
+/**
+ * Errores de lógica de negocio (Business Layer)
+ * No conocen HTTP, son agnósticos a la infraestructura
+ */
+class DomainError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DomainError';
+    }
+}
+class EntityNotFoundError extends DomainError {
+    constructor(entity, criteria) {
+        super(`${entity} not found with criteria: ${criteria}`);
+        this.name = 'EntityNotFoundError';
+    }
+}
+class DuplicateEntityError extends DomainError {
+    constructor(entity, criteria) {
+        super(`Duplicate ${entity} found with criteria: ${criteria}`);
+        this.name = 'DuplicateEntityError';
+    }
+}
+class ValidationError extends DomainError {
+    constructor(message) {
+        super(`Validation Error: ${message}`);
+        this.name = 'ValidationError';
+    }
+}
+class BusinessRuleViolationError extends DomainError {
+    constructor(message) {
+        super(`Business Rule Violation: ${message}`);
+        this.name = 'BusinessRuleViolationError';
+    }
+}
+class OperationNotAllowedError extends DomainError {
+    constructor(operation) {
+        super(`Operation not allowed: ${operation}`);
+        this.name = 'OperationNotAllowedError';
+    }
+}
+class DependencyError extends DomainError {
+    constructor(dependency, message) {
+        super(`Dependency Error in ${dependency}: ${message}`);
+        this.name = 'DependencyError';
+    }
+}
+class TimeoutError extends DomainError {
+    constructor(operation, timeout) {
+        super(`Timeout Error: Operation "${operation}" exceeded time limit of ${timeout}ms`);
+        this.name = 'TimeoutError';
+    }
+}
+class ResourceLimitExceededError extends DomainError {
+    constructor(resource, limit) {
+        super(`Resource Limit Exceeded: ${resource} limit of ${limit} has been exceeded`);
+        this.name = 'ResourceLimitExceededError';
+    }
+}
+class ConfigurationError extends DomainError {
+    constructor(message) {
+        super(`Configuration Error: ${message}`);
+        this.name = 'ConfigurationError';
+    }
+}
+
+class InfrastructureError extends Error {
+    constructor(message, originalError) {
+        super(message);
+        this.originalError = originalError;
+        this.name = 'InfrastructureError';
+    }
+}
+class InfraDatabaseConnectionError extends InfrastructureError {
+    constructor(dbType, originalError) {
+        super(`Failed to connect to the ${dbType} database`, originalError);
+        this.name = 'InfraDatabaseConnectionError';
+    }
+}
+class InfraCacheConnectionError extends InfrastructureError {
+    constructor(cacheType, originalError) {
+        super(`Failed to connect to the ${cacheType} cache`, originalError);
+        this.name = 'InfraCacheConnectionError';
+    }
+}
+class InfraMessageQueueError extends InfrastructureError {
+    constructor(queueType, originalError) {
+        super(`Message Queue Error in ${queueType}`, originalError);
+        this.name = 'InfraMessageQueueError';
+    }
+}
+class InfraExternalServiceError extends InfrastructureError {
+    constructor(serviceName, originalError) {
+        super(`External Service Error: ${serviceName}`, originalError);
+        this.name = 'InfraExternalServiceError';
+    }
+}
+class InfraConfigurationError extends InfrastructureError {
+    constructor(configItem, originalError) {
+        super(`Configuration Error: ${configItem}`, originalError);
+        this.name = 'InfraConfigurationError';
+    }
+}
+class InfraNetworkError extends InfrastructureError {
+    constructor(message, originalError) {
+        super(`Network Error: ${message}`, originalError);
+        this.name = 'InfraNetworkError';
+    }
+}
+class InfraTimeoutError extends InfrastructureError {
+    constructor(operation, timeout, originalError) {
+        super(`Timeout Error: Operation "${operation}" exceeded time limit of ${timeout}ms`, originalError);
+        this.name = 'InfraTimeoutError';
+    }
+}
+class InfraAuthenticationError extends InfrastructureError {
+    constructor(message, originalError) {
+        super(`Authentication Error: ${message}`, originalError);
+        this.name = 'InfraAuthenticationError';
+    }
+}
+class InfraAuthorizationError extends InfrastructureError {
+    constructor(message, originalError) {
+        super(`Authorization Error: ${message}`, originalError);
+        this.name = 'InfraAuthorizationError';
+    }
+}
+class InfraServiceUnavailableError extends InfrastructureError {
+    constructor(serviceName, originalError) {
+        super(`Service Unavailable: ${serviceName}`, originalError);
+        this.name = 'InfraServiceUnavailableError';
+    }
+}
+class InfraDataSerializationError extends InfrastructureError {
+    constructor(dataType, originalError) {
+        super(`Data Serialization Error for type: ${dataType}`, originalError);
+        this.name = 'InfraDataSerializationError';
+    }
+}
+class InfraDataDeserializationError extends InfrastructureError {
+    constructor(dataType, originalError) {
+        super(`Data Deserialization Error for type: ${dataType}`, originalError);
+        this.name = 'InfraDataDeserializationError';
+    }
+}
+
 exports.ApiResponse = ApiResponse;
+exports.BackupError = BackupError;
 exports.BadRequestError = BadRequestError;
 exports.Body = Body;
+exports.BusinessRuleViolationError = BusinessRuleViolationError;
+exports.ConfigurationError = ConfigurationError;
 exports.ConflictError = ConflictError;
+exports.ConnectionError = ConnectionError;
 exports.Controller = Controller;
 exports.CustomHttpError = CustomHttpError;
+exports.DataConflictError = DataConflictError;
+exports.DataIntegrityError = DataIntegrityError;
+exports.DataMigrationError = DataMigrationError;
+exports.DataNotFoundError = DataNotFoundError;
+exports.DataValidationError = DataValidationError;
 exports.Delete = Delete;
+exports.DependencyError = DependencyError;
+exports.DomainError = DomainError;
+exports.DuplicateEntityError = DuplicateEntityError;
+exports.EntityNotFoundError = EntityNotFoundError;
 exports.ForbiddenError = ForbiddenError;
 exports.GatewayTimeoutError = GatewayTimeoutError;
 exports.Get = Get;
@@ -268,28 +512,52 @@ exports.Headers = Headers;
 exports.Host = Host;
 exports.HttpError = HttpError;
 exports.HttpErrorWithDetails = HttpErrorWithDetails;
+exports.IndexingError = IndexingError;
+exports.InfraAuthenticationError = InfraAuthenticationError;
+exports.InfraAuthorizationError = InfraAuthorizationError;
+exports.InfraCacheConnectionError = InfraCacheConnectionError;
+exports.InfraConfigurationError = InfraConfigurationError;
+exports.InfraDataDeserializationError = InfraDataDeserializationError;
+exports.InfraDataSerializationError = InfraDataSerializationError;
+exports.InfraDatabaseConnectionError = InfraDatabaseConnectionError;
+exports.InfraExternalServiceError = InfraExternalServiceError;
+exports.InfraMessageQueueError = InfraMessageQueueError;
+exports.InfraNetworkError = InfraNetworkError;
+exports.InfraServiceUnavailableError = InfraServiceUnavailableError;
+exports.InfraTimeoutError = InfraTimeoutError;
+exports.InfrastructureError = InfrastructureError;
 exports.InternalServerError = InternalServerError;
 exports.Ip = Ip;
 exports.METADATA_KEYS = METADATA_KEYS;
 exports.Next = Next;
 exports.NotFoundError = NotFoundError;
+exports.OperationNotAllowedError = OperationNotAllowedError;
 exports.Options = Options;
 exports.Param = Param;
 exports.Patch = Patch;
+exports.PersistenceError = PersistenceError;
 exports.Post = Post;
 exports.Put = Put;
 exports.Query = Query;
+exports.QueryExecutionError = QueryExecutionError;
 exports.Redirect = Redirect;
 exports.Req = Req;
 exports.Request = Request;
 exports.Res = Res;
+exports.ResourceLimitError = ResourceLimitError;
+exports.ResourceLimitExceededError = ResourceLimitExceededError;
 exports.Response = Response;
+exports.RestoreError = RestoreError;
+exports.SchemaMismatchError = SchemaMismatchError;
 exports.Serialize = Serialize;
 exports.ServiceUnavailableError = ServiceUnavailableError;
 exports.Session = Session;
 exports.SetMetadata = SetMetadata;
+exports.TimeoutError = TimeoutError;
+exports.TransactionError = TransactionError;
 exports.UnauthorizedError = UnauthorizedError;
 exports.UnprocessableEntityError = UnprocessableEntityError;
 exports.UseGuards = UseGuards;
 exports.UseInterceptors = UseInterceptors;
+exports.ValidationError = ValidationError;
 exports.isRedirectResponse = isRedirectResponse;

package/dist/types/errors/domain.error.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Errores de lógica de negocio (Business Layer)
+ * No conocen HTTP, son agnósticos a la infraestructura
+ */
+export declare class DomainError extends Error {
+    constructor(message: string);
+}
+export declare class EntityNotFoundError extends DomainError {
+    constructor(entity: string, criteria: string);
+}
+export declare class DuplicateEntityError extends DomainError {
+    constructor(entity: string, criteria: string);
+}
+export declare class ValidationError extends DomainError {
+    constructor(message: string);
+}
+export declare class BusinessRuleViolationError extends DomainError {
+    constructor(message: string);
+}
+export declare class OperationNotAllowedError extends DomainError {
+    constructor(operation: string);
+}
+export declare class DependencyError extends DomainError {
+    constructor(dependency: string, message: string);
+}
+export declare class TimeoutError extends DomainError {
+    constructor(operation: string, timeout: number);
+}
+export declare class ResourceLimitExceededError extends DomainError {
+    constructor(resource: string, limit: number);
+}
+export declare class ConfigurationError extends DomainError {
+    constructor(message: string);
+}

package/dist/types/errors/index.d.ts

@@ -1 +1,4 @@
 export * from "./http.error";
+export * from "./persistence.error";
+export * from "./domain.error";
+export * from "./infrastructure.error";

package/dist/types/errors/infrastructure.error.d.ts

@@ -0,0 +1,40 @@
+export declare class InfrastructureError extends Error {
+    readonly originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+export declare class InfraDatabaseConnectionError extends InfrastructureError {
+    constructor(dbType: string, originalError?: Error);
+}
+export declare class InfraCacheConnectionError extends InfrastructureError {
+    constructor(cacheType: string, originalError?: Error);
+}
+export declare class InfraMessageQueueError extends InfrastructureError {
+    constructor(queueType: string, originalError?: Error);
+}
+export declare class InfraExternalServiceError extends InfrastructureError {
+    constructor(serviceName: string, originalError?: Error);
+}
+export declare class InfraConfigurationError extends InfrastructureError {
+    constructor(configItem: string, originalError?: Error);
+}
+export declare class InfraNetworkError extends InfrastructureError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class InfraTimeoutError extends InfrastructureError {
+    constructor(operation: string, timeout: number, originalError?: Error);
+}
+export declare class InfraAuthenticationError extends InfrastructureError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class InfraAuthorizationError extends InfrastructureError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class InfraServiceUnavailableError extends InfrastructureError {
+    constructor(serviceName: string, originalError?: Error);
+}
+export declare class InfraDataSerializationError extends InfrastructureError {
+    constructor(dataType: string, originalError?: Error);
+}
+export declare class InfraDataDeserializationError extends InfrastructureError {
+    constructor(dataType: string, originalError?: Error);
+}

package/dist/types/errors/persistence.error.d.ts

@@ -0,0 +1,43 @@
+export declare class PersistenceError extends Error {
+    readonly originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+export declare class DataNotFoundError extends PersistenceError {
+    constructor(entity: string, criteria: string, originalError?: Error);
+}
+export declare class DataConflictError extends PersistenceError {
+    constructor(entity: string, criteria: string, originalError?: Error);
+}
+export declare class DataValidationError extends PersistenceError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class TransactionError extends PersistenceError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class QueryExecutionError extends PersistenceError {
+    constructor(query: string, originalError?: Error);
+}
+export declare class ConnectionError extends PersistenceError {
+    constructor(databaseType: string, originalError?: Error);
+}
+export declare class SchemaMismatchError extends PersistenceError {
+    constructor(expectedSchema: string, actualSchema: string, originalError?: Error);
+}
+export declare class DataIntegrityError extends PersistenceError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class BackupError extends PersistenceError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class RestoreError extends PersistenceError {
+    constructor(message: string, originalError?: Error);
+}
+export declare class IndexingError extends PersistenceError {
+    constructor(indexName: string, originalError?: Error);
+}
+export declare class DataMigrationError extends PersistenceError {
+    constructor(migrationName: string, originalError?: Error);
+}
+export declare class ResourceLimitError extends PersistenceError {
+    constructor(resourceType: string, limit: number, originalError?: Error);
+}

package/dist/types/interfaces/configuration/aws-s3-configuration.interface.d.ts

@@ -0,0 +1,6 @@
+export interface AWSS3Configuration {
+    ACCESS_KEY: string;
+    SECRET_KEY: string;
+    REGION: string;
+    BUCKET_NAME?: string;
+}

package/dist/types/interfaces/configuration/drizzle-db-configuration.interface.d.ts

@@ -0,0 +1,7 @@
+export interface PostgresDBConfiguration {
+    POSTGRES_HOST: string;
+    POSTGRES_PORT: number;
+    POSTGRES_USER: string;
+    POSTGRES_PASSWORD: string;
+    POSTGRES_DB: string;
+}

package/dist/types/interfaces/configuration/mongo-db-configuration.interface.d.ts

@@ -0,0 +1,7 @@
+export interface MongoDBConfiguration {
+    DB: string;
+    HOST: string;
+    PASS: string;
+    SOURCE: string;
+    USER: string;
+}

package/dist/types/interfaces/configuration/olap-db-configuration.interface.d.ts

@@ -0,0 +1,6 @@
+export interface OlapDBConfiguration {
+    OLAPDB_USER: string;
+    OLAPDB_PASSWORD: string;
+    OLAPDB_HOST: string;
+    OLAPDB_DATABASE: string;
+}

package/dist/types/interfaces/configuration/redis-configuration.interface.d.ts

@@ -0,0 +1,8 @@
+export interface RedisConfiguration {
+    REDIS_HOST: string;
+    REDIS_PORT: number;
+    REDIS_PASSWORD: string;
+    REDIS_DB: string;
+    REDIS_TLS: boolean;
+    REDIS_USER?: string;
+}

package/dist/types/interfaces/configuration/smtp-configuration.interface.d.ts

@@ -0,0 +1,7 @@
+export interface SmtpConfiguration {
+    SMTP_HOST: string;
+    SMTP_PORT: number;
+    SMTP_USER: string;
+    SMTP_PASSWORD: string;
+    SMTP_SECURE: boolean;
+}

package/dist/types/interfaces/index.d.ts

@@ -7,3 +7,9 @@ export * from "./features/arguments-host.interface";
 export * from './type.interface';
 export * from './handler.interface';
 export * from './interceptor.interface';
+export * from './configuration/redis-configuration.interface';
+export * from './configuration/mongo-db-configuration.interface';
+export * from './configuration/aws-s3-configuration.interface';
+export * from './configuration/drizzle-db-configuration.interface';
+export * from './configuration/olap-db-configuration.interface';
+export * from './configuration/smtp-configuration.interface';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hemia/common",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Paquete común para proyectos de Hemia",
   "main": "dist/hemia-common.js",
   "module": "dist/hemia-common.esm.js",