@carbonbox/domain 0.29.1 → 0.30.0

package/build/carbonbox/shared/domain/exceptions/InvalidUserPrefixError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserPrefixError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserPrefixError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserPrefixError extends CodedRootError_1.CodedRootError {
     constructor(userId, prefix, validPrefixes) {
-        const message = `The UserId "${userId}" has invalid prefix "${prefix}". Expected one of: [${validPrefixes.join(', ')}]. ${InvalidUserPrefixError.INVALID_USER_PREFIX_ERROR_MESSAGE}`;
-        super(message);
+        const technicalMessage = `The UserId "${userId}" has invalid prefix "${prefix}". Expected one of: [${validPrefixes.join(', ')}]. User prefixes must match valid stakeholder types.`;
+        const context = {
+            userId,
+            prefix,
+            validPrefixes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Valid user prefixes are: ${validPrefixes.join(', ')}`,
+            'HST = Carbon Host (Administrator)',
+            'MGR = Carbon Manager',
+            'CRD = Carbon Coordinator',
+            'CLT = Carbon Client (End User)',
+            'Ensure the prefix matches your user role type',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_PREFIX, technicalMessage, context, suggestions);
         this.name = 'InvalidUserPrefixError';
     }
     static create(userId, prefix, validPrefixes) {
         return new InvalidUserPrefixError(userId, prefix, validPrefixes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserPrefixError = InvalidUserPrefixError;
-InvalidUserPrefixError.INVALID_USER_PREFIX_ERROR_MESSAGE = 'Invalid user prefix for UserId';

package/build/carbonbox/shared/domain/exceptions/InvalidUserTypeError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserTypeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserTypeError extends CodedRootError_1.CodedRootError {
     constructor(value, validTypes) {
-        const message = `Invalid user type: '${value}'. Valid types are: ${validTypes.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid user type: '${value}'. Valid types are: ${validTypes.join(', ')}.`;
+        const context = {
+            value,
+            validTypes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid user types: ${validTypes.join(', ')}`,
+            'Verify the user type matches the system requirements',
+            'Check the API documentation for valid user type values',
+            'Ensure the user type is spelled correctly',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidUserTypeError';
     }
     static create(value, validTypes) {
         return new InvalidUserTypeError(value, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserTypeError = InvalidUserTypeError;

package/build/carbonbox/shared/domain/exceptions/InvalidUuidFormatError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUuidFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUuidFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUuidFormatError extends CodedRootError_1.CodedRootError {
     constructor(uuid, semanticUuid) {
-        const message = `The UUID "${uuid}" extracted from semantic UUID "${semanticUuid}" does not conform to UUID v4 format. ${InvalidUuidFormatError.INVALID_UUID_FORMAT_ERROR_MESSAGE}`;
-        super(message);
+        const technicalMessage = `The UUID "${uuid}" extracted from semantic UUID "${semanticUuid}" does not conform to UUID v4 format. Expected a valid UUIDv4 with proper structure.`;
+        const context = {
+            uuid,
+            semanticUuid,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the UUID follows UUIDv4 format (8-4-4-4-12 hexadecimal pattern)',
+            'Verify the UUID contains only valid hexadecimal characters (0-9, a-f)',
+            'Check the UUID has exactly 36 characters including hyphens',
+            'Example valid UUID: 550e8400-e29b-41d4-a716-446655440000',
+            'Validate that the version field (first digit of third group) is 4',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_UUID_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidUuidFormatError';
     }
     static create(uuid, semanticUuid) {
         return new InvalidUuidFormatError(uuid, semanticUuid);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUuidFormatError = InvalidUuidFormatError;
-InvalidUuidFormatError.INVALID_UUID_FORMAT_ERROR_MESSAGE = 'Invalid UUID v4 format';

package/build/carbonbox/shared/domain/exceptions/InvalidValueObjectConfigurationError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidValueObjectConfigurationError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidValueObjectConfigurationError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidValueObjectConfigurationError extends CodedRootError_1.CodedRootError {
     constructor() {
-        const message = 'Invalid configuration: Cannot allow both null and undefined simultaneously';
-        super(message);
+        const technicalMessage = 'Invalid Value Object configuration: Cannot allow both null and undefined simultaneously. Choose one or neither.';
+        const context = {
+            configurationError: 'allowNull and allowUndefined both enabled',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Set allowNull to true OR allowUndefined to true, but not both',
+            'Use allowNull: true if the value can be explicitly null',
+            'Use allowUndefined: true if the value can be explicitly undefined',
+            'Set both to false if the value is required and must be present',
+            'Review the Value Object configuration documentation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_VALUE_OBJECT_CONFIGURATION, technicalMessage, context, suggestions);
         this.name = 'InvalidValueObjectConfigurationError';
     }
     static create() {
         return new InvalidValueObjectConfigurationError();
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidValueObjectConfigurationError = InvalidValueObjectConfigurationError;

package/build/carbonbox/shared/domain/exceptions/JobAlreadyRunningError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobAlreadyRunningError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class JobAlreadyRunningError extends CodedRootError_1.CodedRootError {
+    constructor(jobId, startedAt) {
+        const technicalMessage = startedAt
+            ? `Calculation job '${jobId}' is already running since ${startedAt}`
+            : `Calculation job '${jobId}' is already running`;
+        const context = {
+            jobId,
+            startedAt,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Wait for the current job execution to complete',
+            'Check the job status before starting a new execution',
+            'Cancel the running job if it is stuck or no longer needed',
+            'Verify job scheduling to avoid concurrent executions',
+            'Contact support if the job appears to be stuck',
+        ];
+        super(ErrorCode_1.ErrorCode.JOB_ALREADY_RUNNING, technicalMessage, context, suggestions);
+        this.name = 'JobAlreadyRunningError';
+    }
+    static create(jobId, startedAt) {
+        return new JobAlreadyRunningError(jobId, startedAt);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.JobAlreadyRunningError = JobAlreadyRunningError;

package/build/carbonbox/shared/domain/exceptions/JobNotFoundError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobNotFoundError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class JobNotFoundError extends CodedRootError_1.CodedRootError {
+    constructor(jobId) {
+        const technicalMessage = `Calculation job with ID '${jobId}' was not found`;
+        const context = {
+            jobId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the job ID is correct',
+            'Check if the job has been deleted or has expired',
+            'Ensure you have permission to access this job',
+            'Check if the job completed and was archived',
+            'Contact support if the job should exist',
+        ];
+        super(ErrorCode_1.ErrorCode.JOB_NOT_FOUND, technicalMessage, context, suggestions);
+        this.name = 'JobNotFoundError';
+    }
+    static create(jobId) {
+        return new JobNotFoundError(jobId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.JobNotFoundError = JobNotFoundError;

package/build/carbonbox/shared/domain/exceptions/ManagerRequiredError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagerRequiredError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class ManagerRequiredError extends CodedRootError_1.CodedRootError {
+    constructor(stakeholderId, operation) {
+        const technicalMessage = `Manager assignment is required for stakeholder '${stakeholderId}' to perform operation: ${operation}`;
+        const context = {
+            stakeholderId,
+            operation,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Assign a manager to this stakeholder before performing this operation',
+            'Contact your administrator to assign the appropriate manager',
+            'Verify the stakeholder hierarchy requirements',
+            'Check if manager assignment is pending approval',
+        ];
+        super(ErrorCode_1.ErrorCode.MANAGER_REQUIRED, technicalMessage, context, suggestions);
+        this.name = 'ManagerRequiredError';
+    }
+    static create(stakeholderId, operation) {
+        return new ManagerRequiredError(stakeholderId, operation);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ManagerRequiredError = ManagerRequiredError;

package/build/carbonbox/shared/domain/exceptions/MaximumValueViolationError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaximumValueViolationError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class MaximumValueViolationError extends CodedRootError_1.CodedRootError {
+    constructor(propertyName, maximumValue, actualValue) {
+        const technicalMessage = `Value constraint violation: '${propertyName}' exceeds maximum allowed value. Maximum: ${maximumValue}, Actual: ${actualValue}.`;
+        const context = {
+            propertyName,
+            maximumValue,
+            actualValue,
+            difference: actualValue - maximumValue,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure '${propertyName}' is at most ${maximumValue}`,
+            `The current value ${actualValue} is ${actualValue - maximumValue} above the maximum`,
+            'Reduce the value to meet the maximum requirement',
+            'Check validation rules for this field',
+        ];
+        super(ErrorCode_1.ErrorCode.MAXIMUM_VALUE_VIOLATION, technicalMessage, context, suggestions);
+        this.name = 'MaximumValueViolationError';
+    }
+    static create(propertyName, maximumValue, actualValue) {
+        return new MaximumValueViolationError(propertyName, maximumValue, actualValue);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.MaximumValueViolationError = MaximumValueViolationError;

package/build/carbonbox/shared/domain/exceptions/MethodNotImplementedError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MethodNotImplementedError = void 0;
-const RootError_1 = require("./RootError");
-class MethodNotImplementedError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class MethodNotImplementedError extends CodedRootError_1.CodedRootError {
     constructor(methodName) {
-        const message = `The method '${methodName}' must be implemented in the derived class.`;
-        super(message);
+        const technicalMessage = `The method '${methodName}' must be implemented in the derived class. This abstract method is required by the base class contract.`;
+        const context = {
+            methodName,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Implement the '${methodName}' method in your derived class`,
+            'Check the base class or interface for the method signature',
+            'Ensure the method implementation matches the expected contract',
+            'Abstract methods must be implemented in all concrete subclasses',
+            'Review the class hierarchy and inheritance chain',
+        ];
+        super(ErrorCode_1.ErrorCode.METHOD_NOT_IMPLEMENTED, technicalMessage, context, suggestions);
         this.name = 'MethodNotImplementedError';
     }
     static create(methodName) {
         return new MethodNotImplementedError(methodName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.MethodNotImplementedError = MethodNotImplementedError;

package/build/carbonbox/shared/domain/exceptions/MinimumValueViolationError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinimumValueViolationError = void 0;
-const RootError_1 = require("./RootError");
-class MinimumValueViolationError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class MinimumValueViolationError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, minimumValue, actualValue) {
-        const message = `Value constraint violation: '${propertyName}' is below minimum allowed value. Minimum: ${minimumValue}, Actual: ${actualValue}.`;
-        super(message);
+        const technicalMessage = `Value constraint violation: '${propertyName}' is below minimum allowed value. Minimum: ${minimumValue}, Actual: ${actualValue}.`;
+        const context = {
+            propertyName,
+            minimumValue,
+            actualValue,
+            difference: minimumValue - actualValue,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure '${propertyName}' is at least ${minimumValue}`,
+            `The current value ${actualValue} is ${minimumValue - actualValue} below the minimum`,
+            'Increase the value to meet the minimum requirement',
+            'Check validation rules for this field',
+        ];
+        super(ErrorCode_1.ErrorCode.MINIMUM_VALUE_VIOLATION, technicalMessage, context, suggestions);
         this.name = 'MinimumValueViolationError';
     }
     static create(propertyName, minimumValue, actualValue) {
         return new MinimumValueViolationError(propertyName, minimumValue, actualValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.MinimumValueViolationError = MinimumValueViolationError;

package/build/carbonbox/shared/domain/exceptions/MissingEmissionFactorError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingEmissionFactorError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class MissingEmissionFactorError extends CodedRootError_1.CodedRootError {
+    constructor(activityType, scope) {
+        const technicalMessage = scope
+            ? `Required emission factor not found for activity type '${activityType}' in scope ${scope}`
+            : `Required emission factor not found for activity type '${activityType}'`;
+        const context = {
+            activityType,
+            scope,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Add the missing emission factor to the system',
+            'Verify the activity type is correctly specified',
+            'Check if emission factors are configured for this scope',
+            'Contact your carbon accounting administrator',
+            'Use a different activity type with available emission factors',
+        ];
+        super(ErrorCode_1.ErrorCode.MISSING_EMISSION_FACTOR, technicalMessage, context, suggestions);
+        this.name = 'MissingEmissionFactorError';
+    }
+    static create(activityType, scope) {
+        return new MissingEmissionFactorError(activityType, scope);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.MissingEmissionFactorError = MissingEmissionFactorError;

package/build/carbonbox/shared/domain/exceptions/MissingRequiredFieldsError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRequiredFieldsError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class MissingRequiredFieldsError extends CodedRootError_1.CodedRootError {
+    constructor(missingFields) {
+        const technicalMessage = `Required fields are missing: ${missingFields.join(', ')}`;
+        const context = {
+            missingFields: Array.from(missingFields),
+            count: missingFields.length,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Provide values for the following required fields: ${missingFields.join(', ')}`,
+            'Check the form documentation for required field information',
+            'Ensure all mandatory fields are included in your request',
+            'Verify field names match the expected format',
+        ];
+        super(ErrorCode_1.ErrorCode.MISSING_REQUIRED_FIELDS, technicalMessage, context, suggestions);
+        this.name = 'MissingRequiredFieldsError';
+    }
+    static create(missingFields) {
+        return new MissingRequiredFieldsError(missingFields);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.MissingRequiredFieldsError = MissingRequiredFieldsError;

package/build/carbonbox/shared/domain/exceptions/MoneyOverflowError.js

@@ -1,21 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoneyOverflowError = void 0;
-const RootError_1 = require("./RootError");
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
 /**
  * Error para cuando hay un desbordamiento aritmético en operaciones con Money
  */
-class MoneyOverflowError extends RootError_1.RootError {
+class MoneyOverflowError extends CodedRootError_1.CodedRootError {
     constructor(operation) {
-        const message = `Arithmetic overflow error: The ${operation} operation resulted in a value outside the acceptable range for Money.`;
-        super(message);
+        const technicalMessage = `Arithmetic overflow error: The ${operation} operation resulted in a value outside the acceptable range for Money.`;
+        const context = {
+            operation,
+            errorType: 'arithmetic_overflow',
+            maxSafeInteger: Number.MAX_SAFE_INTEGER,
+            minSafeInteger: Number.MIN_SAFE_INTEGER,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Verify that the ${operation} operation does not exceed JavaScript's safe integer limits`,
+            'Consider using arbitrary precision libraries for large monetary calculations',
+            'Break down large operations into smaller, validated steps',
+            'Implement range checks before performing arithmetic operations on Money values',
+        ];
+        super(ErrorCode_1.ErrorCode.MONEY_OVERFLOW, technicalMessage, context, suggestions);
         this.name = 'MoneyOverflowError';
     }
     static create(operation) {
         return new MoneyOverflowError(operation);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.MoneyOverflowError = MoneyOverflowError;

package/build/carbonbox/shared/domain/exceptions/NegativeAmountError.js

@@ -1,21 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NegativeAmountError = void 0;
-const RootError_1 = require("./RootError");
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
 /**
  * Error para cuando se intenta crear Money con un monto negativo
  */
-class NegativeAmountError extends RootError_1.RootError {
+class NegativeAmountError extends CodedRootError_1.CodedRootError {
     constructor(amount) {
-        const message = `Invalid operation: Cannot create Money with negative amount '${amount}'.`;
-        super(message);
+        const technicalMessage = `Invalid operation: Cannot create Money with negative amount '${amount}'.`;
+        const context = {
+            amount,
+            constraint: 'non_negative',
+            minimumAllowed: 0,
+            violationType: 'negative_value',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the amount is non-negative (>= 0) before creating a Money value object',
+            'Validate input amounts to prevent negative values from being used',
+            'Check calculations and data sources to identify where negative amounts are being generated',
+            'If you need to represent debts or credits, consider using a separate domain concept with explicit semantics',
+        ];
+        super(ErrorCode_1.ErrorCode.NEGATIVE_AMOUNT, technicalMessage, context, suggestions);
         this.name = 'NegativeAmountError';
     }
     static create(amount) {
         return new NegativeAmountError(amount);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.NegativeAmountError = NegativeAmountError;

package/build/carbonbox/shared/domain/exceptions/NotIntegerError.js

@@ -1,10 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotIntegerError = void 0;
-const RootError_1 = require("./RootError");
-class NotIntegerError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class NotIntegerError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, actualValue) {
-        super(`Value constraint violation: '${propertyName}' must be an integer. Actual value: ${actualValue}.`);
+        const technicalMessage = `Value constraint violation: '${propertyName}' must be an integer. Actual value: ${actualValue}.`;
+        const context = {
+            propertyName,
+            actualValue,
+            constraint: 'integer',
+            fractionalPart: actualValue - Math.floor(actualValue),
+            isDecimal: !Number.isInteger(actualValue),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure that '${propertyName}' contains only integer values (no decimal places)`,
+            'Round or truncate decimal values before creating the value object',
+            'Validate input data to ensure integers are provided where required',
+            'Check calculations that produce this value to ensure they result in whole numbers',
+        ];
+        super(ErrorCode_1.ErrorCode.NOT_INTEGER, technicalMessage, context, suggestions);
         this.propertyName = propertyName;
         this.actualValue = actualValue;
         this.name = 'NotIntegerError';
@@ -19,7 +35,7 @@ class NotIntegerError extends RootError_1.RootError {
         return this.actualValue;
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.NotIntegerError = NotIntegerError;

package/build/carbonbox/shared/domain/exceptions/PasswordPolicyViolationError.js

@@ -1,17 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PasswordPolicyViolationError = void 0;
-const RootError_1 = require("./RootError");
-class PasswordPolicyViolationError extends RootError_1.RootError {
-    constructor(message = "The password does not comply with the domain's security policies") {
-        super(message);
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class PasswordPolicyViolationError extends CodedRootError_1.CodedRootError {
+    constructor(violationDetails) {
+        const technicalMessage = violationDetails
+            ? `Password policy violation: ${violationDetails}`
+            : "The password does not comply with the domain's security policies";
+        const context = {
+            violationDetails,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure password has at least 8 characters',
+            'Include at least one uppercase letter, one lowercase letter, and one number',
+            'Add at least one special character (!@#$%^&*)',
+            'Avoid using common words or easily guessable patterns',
+            'Do not reuse previous passwords',
+        ];
+        super(ErrorCode_1.ErrorCode.PASSWORD_POLICY_VIOLATION, technicalMessage, context, suggestions);
         this.name = 'PasswordPolicyViolationError';
     }
-    static create(message) {
-        return new PasswordPolicyViolationError(message);
+    static create(violationDetails) {
+        return new PasswordPolicyViolationError(violationDetails);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.PasswordPolicyViolationError = PasswordPolicyViolationError;

package/build/carbonbox/shared/domain/exceptions/SecurityContextReconstructionError.js

@@ -1,15 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecurityContextReconstructionError = void 0;
-const RootError_1 = require("./RootError");
-class SecurityContextReconstructionError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class SecurityContextReconstructionError extends CodedRootError_1.CodedRootError {
     constructor(primitives) {
-        const message = 'SecurityContext.fromPrimitives() is not supported. '
+        const technicalMessage = 'SecurityContext.fromPrimitives() is not supported. '
             + 'User is an abstract class and cannot be reconstructed without knowing the specific User type '
             + '(CarbonHost, CarbonManager, CarbonCoordinator, CarbonClient). '
             + 'Use SecurityContext.create() or SecurityContext.fromUser() instead. '
             + 'User entities must be constructed with their specific factory methods.';
-        super(message);
+        const debugInfo = {
+            userType: primitives.user?.userType || 'unknown',
+            userId: primitives.user?.id || 'unknown',
+            userEmail: primitives.user?.email?.value || 'unknown',
+            hasResource: primitives.resource !== null && primitives.resource !== undefined,
+            hasEnvironment: primitives.environment !== null && primitives.environment !== undefined,
+            environmentTimestamp: primitives.environment?.timestamp || 'unknown',
+            environmentIpAddress: primitives.environment?.ipAddress || 'unknown',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Use SecurityContext.create() with proper user instance instead',
+            'Use SecurityContext.fromUser() if you have a user entity',
+            'Construct the specific user type first (CarbonHost, CarbonManager, etc.)',
+            'Avoid using fromPrimitives() for SecurityContext - use factory methods instead',
+        ];
+        super(ErrorCode_1.ErrorCode.SECURITY_CONTEXT_RECONSTRUCTION_ERROR, technicalMessage, debugInfo, suggestions);
         this.name = 'SecurityContextReconstructionError';
         this.primitives = primitives;
     }
@@ -17,17 +34,8 @@ class SecurityContextReconstructionError extends RootError_1.RootError {
         return new SecurityContextReconstructionError(primitives);
     }
     logError() {
-        const debugInfo = {
-            userType: this.primitives.user?.userType || 'unknown',
-            userId: this.primitives.user?.id || 'unknown',
-            userEmail: this.primitives.user?.email?.value || 'unknown',
-            hasResource: this.primitives.resource !== null && this.primitives.resource !== undefined,
-            hasEnvironment: this.primitives.environment !== null && this.primitives.environment !== undefined,
-            environmentTimestamp: this.primitives.environment?.timestamp || 'unknown',
-            environmentIpAddress: this.primitives.environment?.ipAddress || 'unknown',
-        };
-        return `${this.name}: ${this.message}\n`
-            + `Debug Info: ${JSON.stringify(debugInfo, null, 2)}\n`
+        return `${this.name}: ${this.technicalMessage}\n`
+            + `Debug Info: ${JSON.stringify(this.context, null, 2)}\n`
             + `Full primitives: ${JSON.stringify(this.primitives, null, 2)}`;
     }
     getReceivedPrimitives() {