@carbonbox/domain 0.29.1 → 0.30.0

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCountryCodeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidCountryCodeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidCountryCodeError extends CodedRootError_1.CodedRootError {
     constructor(countryCode) {
-        const message = `Invalid country code format: '${countryCode}'. It must start with '+' and be 2-4 characters long.`;
-        super(message);
+        const technicalMessage = `Invalid country code format: '${countryCode}'. It must start with '+' and be 2-4 characters long.`;
+        const context = {
+            countryCode,
+            expectedFormat: '+XX or +XXX or +XXXX',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the country code starts with a plus sign (+)',
+            'Verify the code has 2-4 characters after the plus sign',
+            'Examples: +1 (USA/Canada), +57 (Colombia), +44 (UK), +123',
+            'Remove any spaces or special characters except the leading plus sign',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COUNTRY_CODE, technicalMessage, context, suggestions);
         this.name = 'InvalidCountryCodeError';
     }
     static create(countryCode) {
         return new InvalidCountryCodeError(countryCode);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCountryCodeError = InvalidCountryCodeError;

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

@@ -1,18 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCountrySpecificTaxIdentificationNumberError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidCountrySpecificTaxIdentificationNumberError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidCountrySpecificTaxIdentificationNumberError extends CodedRootError_1.CodedRootError {
     constructor(country, value, expectedFormat) {
-        const message = `Invalid ${country} tax identification number: '${value}'. Expected format: ${expectedFormat}.`;
-        super(message);
+        const technicalMessage = `Invalid ${country} tax identification number: '${value}'. Expected format: ${expectedFormat}.`;
+        const context = {
+            country,
+            value,
+            expectedFormat,
+            constraint: 'country_specific_tax_id_format',
+            errorType: 'format_validation_failed',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the tax identification number '${value}' matches the ${country} format: ${expectedFormat}`,
+            `Verify that the tax ID follows ${country} country-specific validation rules`,
+            'Check for country-specific formatting requirements (check digits, structure, etc.)',
+            `Review ${country} tax identification number standards and update the value accordingly`,
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COUNTRY_SPECIFIC_TAX_IDENTIFICATION_NUMBER, technicalMessage, context, suggestions);
         this.name = 'InvalidCountrySpecificTaxIdentificationNumberError';
     }
     static create(country, value, expectedFormat) {
         return new InvalidCountrySpecificTaxIdentificationNumberError(country, value, expectedFormat);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCountrySpecificTaxIdentificationNumberError = InvalidCountrySpecificTaxIdentificationNumberError;

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

@@ -47,7 +47,7 @@ class InvalidCurrencyError extends CodedRootError_1.CodedRootError {
         if (!currency || !validCurrencies)
             return false;
         // Check if it's just a case issue
-        return validCurrencies.some(valid => valid.toLowerCase() === currency.toLowerCase());
+        return validCurrencies.some((valid) => valid.toLowerCase() === currency.toLowerCase());
     }
     /**
      * Returns a user-friendly message based on the locale

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

@@ -29,7 +29,7 @@ class InvalidDateFormatError extends CodedRootError_1.CodedRootError {
             'YYYY-MM-DD': '2024-03-15',
             'DD/MM/YYYY': '15/03/2024',
             'MM/DD/YYYY': '03/15/2024',
-            'ISO8601': '2024-03-15T10:30:00Z',
+            ISO8601: '2024-03-15T10:30:00Z',
             'YYYY-MM-DDTHH:mm:ss': '2024-03-15T10:30:00',
         };
         return examples[format] || '2024-03-15';

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidDateRangeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidDateRangeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidDateRangeError extends CodedRootError_1.CodedRootError {
     constructor(validFrom, validUntil) {
-        const message = `Invalid date range: validFrom date '${validFrom}' must be before validUntil date '${validUntil}'.`;
-        super(message);
+        const technicalMessage = `Invalid date range: validFrom date '${validFrom}' must be before validUntil date '${validUntil}'.`;
+        const context = {
+            validFrom,
+            validUntil,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the start date (validFrom) is before the end date (validUntil)',
+            'Verify both dates are in valid ISO 8601 format',
+            'Check for timezone differences that may affect the date comparison',
+            'Ensure dates are not equal - the range must have a positive duration',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_DATE_RANGE, technicalMessage, context, suggestions);
         this.name = 'InvalidDateRangeError';
     }
     static create(validFrom, validUntil) {
         return new InvalidDateRangeError(validFrom, validUntil);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidDateRangeError = InvalidDateRangeError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidDomainCodeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidDomainCodeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidDomainCodeError extends CodedRootError_1.CodedRootError {
     constructor(code, propertyName) {
-        const message = `The code "${code}" violates the domain policy - The propertyName's ${propertyName}`;
-        super(message);
+        const technicalMessage = `The code "${code}" violates the domain policy for property '${propertyName}'. Expected a valid domain code that conforms to business rules.`;
+        const context = {
+            code,
+            propertyName,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the domain code follows the expected format and conventions',
+            'Verify the code matches allowed domain values',
+            'Check that the code does not contain invalid characters',
+            'Review domain policy documentation for valid code patterns',
+            'Domain codes should be alphanumeric and follow naming conventions',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_DOMAIN_CODE, technicalMessage, context, suggestions);
         this.name = 'InvalidDomainCodeError';
     }
     static create(code, propertyName) {
         return new InvalidDomainCodeError(code, propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidDomainCodeError = InvalidDomainCodeError;

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

@@ -1,17 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidDomainEventNameError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidDomainEventNameError extends RootError_1.RootError {
-    constructor(message) {
-        super(message);
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidDomainEventNameError extends CodedRootError_1.CodedRootError {
+    constructor(value, reason) {
+        const technicalMessage = `Invalid DomainEventName '${String(value)}': ${reason}. Domain event names must follow naming conventions.`;
+        const context = {
+            value: String(value),
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Domain event names should be in PascalCase',
+            'Event names should describe past actions (e.g., UserCreated, OrderPlaced)',
+            'Ensure the event name follows the pattern: EntityActionPastTense',
+            'Avoid using special characters or spaces in event names',
+            'Example valid names: ProductAddedToCart, PaymentProcessed, UserRegistered',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_DOMAIN_EVENT_NAME, technicalMessage, context, suggestions);
+        this.name = 'InvalidDomainEventNameError';
         Object.setPrototypeOf(this, InvalidDomainEventNameError.prototype);
     }
     static create(value, reason) {
-        return new InvalidDomainEventNameError(`Invalid DomainEventName '${String(value)}': ${reason}`);
+        return new InvalidDomainEventNameError(value, reason);
     }
     logError() {
-        return `[${this.name}] ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidDomainEventNameError = InvalidDomainEventNameError;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFieldTypeError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidFieldTypeError extends CodedRootError_1.CodedRootError {
+    constructor(fieldName, expectedType, receivedType) {
+        const technicalMessage = `Field '${fieldName}' has invalid type: expected ${expectedType}, but received ${receivedType}`;
+        const context = {
+            fieldName,
+            expectedType,
+            receivedType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure field '${fieldName}' is of type ${expectedType}`,
+            `Convert the value from ${receivedType} to ${expectedType}`,
+            'Check the field type documentation for this form',
+            'Verify data type conversion in your request payload',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_FIELD_TYPE, technicalMessage, context, suggestions);
+        this.name = 'InvalidFieldTypeError';
+    }
+    static create(fieldName, expectedType, receivedType) {
+        return new InvalidFieldTypeError(fieldName, expectedType, receivedType);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidFieldTypeError = InvalidFieldTypeError;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFormulaError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidFormulaError extends CodedRootError_1.CodedRootError {
+    constructor(formulaId, reason) {
+        const technicalMessage = `Calculation formula '${formulaId}' is invalid: ${reason}`;
+        const context = {
+            formulaId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Review the formula syntax for errors',
+            'Ensure all variables used in the formula are defined',
+            'Check mathematical operations are valid',
+            'Verify the formula structure follows the expected format',
+            'Test the formula with sample data before using it',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_FORMULA, technicalMessage, context, suggestions);
+        this.name = 'InvalidFormulaError';
+    }
+    static create(formulaId, reason) {
+        return new InvalidFormulaError(formulaId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidFormulaError = InvalidFormulaError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidFullInternationalNumberError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidFullInternationalNumberError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidFullInternationalNumberError extends CodedRootError_1.CodedRootError {
     constructor(fullNumber, expected) {
-        const message = `Invalid full international number format: received '${fullNumber}', expected '${expected}' (format: '+<countryCode><nationalNumber>').`;
-        super(message);
+        const technicalMessage = `Invalid full international number format: received '${fullNumber}', expected '${expected}' (format: '+<countryCode><nationalNumber>').`;
+        const context = {
+            receivedValue: fullNumber,
+            expectedValue: expected,
+            expectedFormat: '+<countryCode><nationalNumber>',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the phone number starts with a "+" sign',
+            'Include the country code after the "+" (e.g., +57 for Colombia)',
+            'Follow the format: +<countryCode><nationalNumber>',
+            'Remove any spaces, hyphens, or parentheses from the number',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_FULL_INTERNATIONAL_NUMBER, technicalMessage, context, suggestions);
         this.name = 'InvalidFullInternationalNumberError';
     }
     static create(fullNumber, expected) {
         return new InvalidFullInternationalNumberError(fullNumber, expected);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidFullInternationalNumberError = InvalidFullInternationalNumberError;

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

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidGenderError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidGenderError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidGenderError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue, validValues) {
-        const message = `Gender constraint violation: '${invalidValue}' is not a valid gender. Valid values are: [${validValues.join(', ')}].`;
-        super(message);
+        const technicalMessage = `Gender constraint violation: '${invalidValue}' is not a valid gender. Valid values are: [${validValues.join(', ')}].`;
+        const context = {
+            invalidValue,
+            validValues,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Choose one of the valid gender values: ${validValues.join(', ')}`,
+            'Verify the gender field matches the expected format',
+            'Check for typos or extra whitespace in the gender value',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_GENDER, technicalMessage, context, suggestions);
         this.name = 'InvalidGenderError';
     }
     static create(invalidValue, validValues) {
         return new InvalidGenderError(invalidValue, validValues);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidGenderError = InvalidGenderError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidIdentityDocumentTypeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidIdentityDocumentTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidIdentityDocumentTypeError extends CodedRootError_1.CodedRootError {
     constructor(invalidType, validTypes) {
-        const message = `Invalid identity document type: '${invalidType}'. Valid types: ${validTypes.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid identity document type: '${invalidType}'. Valid types: ${validTypes.join(', ')}.`;
+        const context = {
+            invalidType,
+            validTypes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid identity document types: ${validTypes.join(', ')}`,
+            'Common types include: passport, national_id, drivers_license, cedula',
+            'Verify the document type matches your country standards',
+            'Check the identity verification documentation for valid types',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_IDENTITY_DOCUMENT_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidIdentityDocumentTypeError';
     }
     static create(invalidType, validTypes) {
         return new InvalidIdentityDocumentTypeError(invalidType, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidIdentityDocumentTypeError = InvalidIdentityDocumentTypeError;

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

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidManagedStakeholderRoleError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidManagedStakeholderRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidManagedStakeholderRoleError extends CodedRootError_1.CodedRootError {
     constructor(invalidRole, allowedRoles, contextMessage) {
         const baseMessage = `Invalid managed stakeholder role: '${invalidRole}'. Allowed managed roles: ${allowedRoles.join(', ')}.`;
-        const fullMessage = contextMessage ? `${contextMessage}. ${baseMessage}` : baseMessage;
-        super(fullMessage);
+        const technicalMessage = contextMessage ? `${contextMessage}. ${baseMessage}` : baseMessage;
+        const context = {
+            invalidRole,
+            allowedRoles,
+            contextMessage,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the allowed managed stakeholder roles: ${allowedRoles.join(', ')}`,
+            'Verify the stakeholder role can be managed by the current user',
+            'Check the role management hierarchy',
+            'Common managed roles: Coordinator, Client',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_MANAGED_STAKEHOLDER_ROLE, technicalMessage, context, suggestions);
         this.name = 'InvalidManagedStakeholderRoleError';
     }
     static create(invalidRole, allowedRoles, contextMessage) {
         return new InvalidManagedStakeholderRoleError(invalidRole, allowedRoles, contextMessage);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidManagedStakeholderRoleError = InvalidManagedStakeholderRoleError;

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

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidMeasurementUnitOperationError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidMeasurementUnitOperationError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidMeasurementUnitOperationError extends CodedRootError_1.CodedRootError {
     constructor(operation, currentUnit, requiredUnitType) {
-        super(`Cannot perform operation '${operation}' with measurement unit '${currentUnit}'. This operation requires ${requiredUnitType} units.`);
+        const technicalMessage = `Cannot perform operation '${operation}' with measurement unit '${currentUnit}'. This operation requires ${requiredUnitType} units.`;
+        const context = {
+            operation,
+            currentUnit,
+            requiredUnitType,
+            errorType: 'unit_type_mismatch',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Convert the measurement unit '${currentUnit}' to ${requiredUnitType} before performing the operation`,
+            `Ensure the operation '${operation}' is only called with compatible ${requiredUnitType} unit types`,
+            'Implement unit conversion logic to handle different measurement unit types',
+            'Validate measurement units before performing operations to prevent type mismatches',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_MEASUREMENT_UNIT_OPERATION, technicalMessage, context, suggestions);
         this.operation = operation;
         this.currentUnit = currentUnit;
         this.requiredUnitType = requiredUnitType;
@@ -23,7 +38,7 @@ class InvalidMeasurementUnitOperationError extends RootError_1.RootError {
         return this.requiredUnitType;
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidMeasurementUnitOperationError = InvalidMeasurementUnitOperationError;

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

@@ -1,12 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidMinutesDurationError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidMinutesDurationError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidMinutesDurationError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue) {
-        super(`Invalid duration value in minutes: ${invalidValue}. Duration must be a non-negative integer.`);
-        this.invalidValue = invalidValue;
+        const technicalMessage = `Invalid duration value in minutes: ${invalidValue}. Duration must be a non-negative integer.`;
+        const context = {
+            receivedValue: invalidValue,
+            isNegative: invalidValue < 0,
+            isInteger: Number.isInteger(invalidValue),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide a non-negative integer value for duration',
+            'Duration must be 0 or greater',
+            'Ensure the value is a whole number (no decimals)',
+            'Check that the value is not NaN or Infinity',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_MINUTES_DURATION, technicalMessage, context, suggestions);
         this.name = 'InvalidMinutesDurationError';
+        this.invalidValue = invalidValue;
     }
     static create(invalidValue) {
         return new InvalidMinutesDurationError(invalidValue);
@@ -15,7 +29,7 @@ class InvalidMinutesDurationError extends RootError_1.RootError {
         return this.invalidValue;
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidMinutesDurationError = InvalidMinutesDurationError;

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

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidNationalNumberError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidNationalNumberError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidNationalNumberError extends CodedRootError_1.CodedRootError {
     constructor(nationalNumber) {
-        const message = `Invalid national number format: '${nationalNumber}'. It must contain 6-15 digits.`;
-        super(message);
+        const technicalMessage = `Invalid national number format: '${nationalNumber}'. It must contain 6-15 digits.`;
+        const context = {
+            receivedValue: nationalNumber,
+            valueLength: nationalNumber.length,
+            minLength: 6,
+            maxLength: 15,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide a national number with 6-15 digits',
+            'Remove any non-digit characters (spaces, hyphens, etc.)',
+            'Verify the national number is complete and correct',
+            'Check that the number matches the expected format for the country',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_NATIONAL_NUMBER, technicalMessage, context, suggestions);
         this.name = 'InvalidNationalNumberError';
     }
     static create(nationalNumber) {
         return new InvalidNationalNumberError(nationalNumber);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidNationalNumberError = InvalidNationalNumberError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPhoneNumberError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidPhoneNumberError extends CodedRootError_1.CodedRootError {
+    constructor(phoneNumber, reason) {
+        const technicalMessage = reason
+            ? `Phone number '${phoneNumber}' is invalid: ${reason}`
+            : `Phone number '${phoneNumber}' has an invalid format`;
+        const context = {
+            phoneNumber,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the phone number follows the international format (e.g., +1234567890)',
+            'Include the country code at the beginning',
+            'Remove any spaces, dashes, or special characters',
+            'Verify the phone number has the correct number of digits',
+            'Check for invalid characters or formatting',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PHONE_NUMBER, technicalMessage, context, suggestions);
+        this.name = 'InvalidPhoneNumberError';
+    }
+    static create(phoneNumber, reason) {
+        return new InvalidPhoneNumberError(phoneNumber, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidPhoneNumberError = InvalidPhoneNumberError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPropertyTypeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidPropertyTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidPropertyTypeError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, expectedType, receivedType) {
-        const message = `Invalid type for property '${propertyName}': expected ${expectedType}, but received ${receivedType}.`;
-        super(message);
+        const technicalMessage = `Invalid type for property '${propertyName}': expected ${expectedType}, but received ${receivedType}.`;
+        const context = {
+            propertyName,
+            expectedType,
+            receivedType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure '${propertyName}' is of type ${expectedType}`,
+            `Convert the value from ${receivedType} to ${expectedType}`,
+            'Check the data type conversion in your request payload',
+            'Verify the API documentation for correct field types',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PROPERTY_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidPropertyTypeError';
     }
     static create(propertyName, expectedType, receivedType) {
         return new InvalidPropertyTypeError(propertyName, expectedType, receivedType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPropertyTypeError = InvalidPropertyTypeError;