@carbonbox/domain 0.28.2 → 0.29.1

package/build/carbonbox/reporting/text-banks/domain/value-objects/TextBankId.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextBankId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidAggregatePrefixError_1 = require("../../../../shared/domain/exceptions/InvalidAggregatePrefixError");
+class TextBankId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, TextBankId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, TextBankId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, TextBankId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, TextBankId.PROPERTY_NAME);
+        // Validate that the prefix is valid for TextBank
+        TextBankId.guardAgainstInvalidPrefix(value);
+        return new TextBankId(value, false);
+    }
+    /**
+     * Validates that the UUID has a valid TextBank prefix
+     */
+    static guardAgainstInvalidPrefix(value) {
+        try {
+            const tempInstance = new TextBankId(value, true);
+            const prefix = tempInstance.extractPrefix();
+            if (TextBankId.VALID_PREFIXES.includes(prefix) === false) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'TextBank', prefix, TextBankId.VALID_PREFIXES, TextBankId.PROPERTY_NAME);
+            }
+        }
+        catch (error) {
+            if (error instanceof InvalidAggregatePrefixError_1.InvalidAggregatePrefixError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'TextBank', 'UNKNOWN', TextBankId.VALID_PREFIXES, TextBankId.PROPERTY_NAME);
+            }
+            throw error;
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new TextBankId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.TextBankId = TextBankId;
+TextBankId.PROPERTY_NAME = 'id';
+TextBankId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.RPT_TEXT_BANK,
+];

package/build/carbonbox/shared/domain/enums/ErrorCode.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = void 0;
+/**
+ * Centralized error codes enum for the CarbonBox domain
+ * Format: CBX-[CONTEXT]-[NUMBER]
+ *
+ * Context Abbreviations:
+ * - AUTH: Authentication
+ * - PMS: Purchase Management System
+ * - STK: Stakeholders
+ * - CFC: Carbon Footprint Configurations
+ * - ADC: Activity Data Collection
+ * - EMC: Emission Calculations
+ * - SHR: Shared/Common
+ *
+ * @since 1.0.0
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    // Authentication Errors (CBX-AUTH-XXX)
+    ErrorCode["INVALID_CREDENTIALS"] = "CBX-AUTH-001";
+    ErrorCode["TOKEN_EXPIRED"] = "CBX-AUTH-002";
+    ErrorCode["TOKEN_INVALID"] = "CBX-AUTH-003";
+    ErrorCode["MISSING_CREDENTIALS"] = "CBX-AUTH-004";
+    ErrorCode["ACCOUNT_LOCKED"] = "CBX-AUTH-005";
+    ErrorCode["EMAIL_NOT_VERIFIED"] = "CBX-AUTH-006";
+    ErrorCode["PASSWORD_RESET_EXPIRED"] = "CBX-AUTH-007";
+    // Purchase Management System Errors (CBX-PMS-XXX)
+    ErrorCode["CONTRACT_NOT_FOUND"] = "CBX-PMS-001";
+    ErrorCode["INVALID_CONTRACT_STATUS"] = "CBX-PMS-002";
+    ErrorCode["INVALID_PAYMENT_TERMS"] = "CBX-PMS-003";
+    ErrorCode["ORDER_EXCEEDS_BUDGET"] = "CBX-PMS-004";
+    ErrorCode["DUPLICATE_ORDER"] = "CBX-PMS-005";
+    ErrorCode["INVALID_CURRENCY"] = "CBX-PMS-006";
+    ErrorCode["SERVICE_CATALOG_NOT_FOUND"] = "CBX-PMS-007";
+    // Stakeholder Errors (CBX-STK-XXX)
+    ErrorCode["STAKEHOLDER_EXISTS"] = "CBX-STK-001";
+    ErrorCode["INVALID_ROLE"] = "CBX-STK-002";
+    ErrorCode["STAKEHOLDER_NOT_FOUND"] = "CBX-STK-003";
+    ErrorCode["INSUFFICIENT_PERMISSIONS"] = "CBX-STK-004";
+    ErrorCode["INVALID_BUSINESS_STATUS"] = "CBX-STK-005";
+    ErrorCode["MANAGER_REQUIRED"] = "CBX-STK-006";
+    // Carbon Footprint Configuration Errors (CBX-CFC-XXX)
+    ErrorCode["CONFIGURATION_NOT_FOUND"] = "CBX-CFC-001";
+    ErrorCode["INVALID_REPORTING_STANDARD"] = "CBX-CFC-002";
+    ErrorCode["INVALID_COLLECTION_PERIOD"] = "CBX-CFC-003";
+    ErrorCode["CONFIGURATION_LOCKED"] = "CBX-CFC-004";
+    ErrorCode["DUPLICATE_CONFIGURATION"] = "CBX-CFC-005";
+    // Activity Data Collection Errors (CBX-ADC-XXX)
+    ErrorCode["FORM_NOT_FOUND"] = "CBX-ADC-001";
+    ErrorCode["INVALID_SUBMISSION"] = "CBX-ADC-002";
+    ErrorCode["SUBMISSION_LOCKED"] = "CBX-ADC-003";
+    ErrorCode["MISSING_REQUIRED_FIELDS"] = "CBX-ADC-004";
+    ErrorCode["INVALID_FIELD_TYPE"] = "CBX-ADC-005";
+    // Emission Calculation Errors (CBX-EMC-XXX)
+    ErrorCode["CALCULATION_FAILED"] = "CBX-EMC-001";
+    ErrorCode["MISSING_EMISSION_FACTOR"] = "CBX-EMC-002";
+    ErrorCode["INVALID_FORMULA"] = "CBX-EMC-003";
+    ErrorCode["JOB_NOT_FOUND"] = "CBX-EMC-004";
+    ErrorCode["JOB_ALREADY_RUNNING"] = "CBX-EMC-005";
+    // Shared/Common Errors (CBX-SHR-XXX)
+    ErrorCode["INVALID_EMAIL"] = "CBX-SHR-001";
+    ErrorCode["INVALID_DATE_FORMAT"] = "CBX-SHR-002";
+    ErrorCode["INVALID_COORDINATES"] = "CBX-SHR-003";
+    ErrorCode["INVALID_CURRENCY_CODE"] = "CBX-SHR-004";
+    ErrorCode["DATABASE_CONNECTION"] = "CBX-SHR-005";
+    ErrorCode["EXTERNAL_SERVICE"] = "CBX-SHR-006";
+    ErrorCode["INVALID_GENDER"] = "CBX-SHR-007";
+    ErrorCode["INVALID_PHONE_NUMBER"] = "CBX-SHR-008";
+    ErrorCode["INVALID_TAX_ID"] = "CBX-SHR-009";
+    ErrorCode["NULL_VALUE"] = "CBX-SHR-010";
+    ErrorCode["UNDEFINED_VALUE"] = "CBX-SHR-011";
+    ErrorCode["EMPTY_VALUE"] = "CBX-SHR-012";
+    ErrorCode["INVALID_PROPERTY_TYPE"] = "CBX-SHR-013";
+    ErrorCode["INVALID_PROPERTY_VALUE"] = "CBX-SHR-014";
+    ErrorCode["MINIMUM_VALUE_VIOLATION"] = "CBX-SHR-015";
+    ErrorCode["MAXIMUM_VALUE_VIOLATION"] = "CBX-SHR-016";
+    ErrorCode["INVALID_DATE_RANGE"] = "CBX-SHR-017";
+    ErrorCode["PASSWORD_POLICY_VIOLATION"] = "CBX-SHR-018";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/build/carbonbox/shared/domain/enums/SemanticUuidPrefix.js

@@ -77,6 +77,12 @@ var SemanticUuidPrefix;
     // Shared Domain
     SemanticUuidPrefix["SHR_DOMAIN"] = "SHR-DOM";
     SemanticUuidPrefix["SHR_EITHER"] = "SHR-ETH";
+    // Reporting Module
+    SemanticUuidPrefix["RPT_TEMPLATE"] = "RPT-TPL";
+    SemanticUuidPrefix["RPT_INSTANCE"] = "RPT-INS";
+    SemanticUuidPrefix["RPT_TEXT_BANK"] = "RPT-TXB";
+    SemanticUuidPrefix["RPT_SECTION"] = "RPT-SEC";
+    SemanticUuidPrefix["RPT_BLOCK"] = "RPT-BLK";
     // Future expansion examples (when system grows):
     // ADC_SUB_FIELDS = 'ADC-SUB-FLD', // Activity Data Collection -> Submissions -> Fields
     // USR_STH_CHO_MGT = 'USR-STH-CHO-MGT', // Users -> Stakeholders -> Carbon Host -> Management

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountLockedError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Exception thrown when a user account is locked
+ * This error occurs when too many failed login attempts or security violations
+ *
+ * Error code: CBX-AUTH-005
+ * @since 1.0.0
+ */
+class AccountLockedError extends CodedRootError_1.CodedRootError {
+    constructor(email, reason, lockedUntil, attemptCount) {
+        const errorCode = ErrorCode_1.ErrorCode.ACCOUNT_LOCKED;
+        const lockedInfo = lockedUntil ? ` until ${lockedUntil.toISOString()}` : '';
+        const attemptInfo = attemptCount ? ` after ${attemptCount} failed attempts` : '';
+        const technicalMessage = `Account locked for ${email}: ${reason}${attemptInfo}${lockedInfo}`;
+        const context = {
+            email,
+            reason,
+            ...(lockedUntil && { lockedUntil: lockedUntil.toISOString() }),
+            ...(attemptCount !== undefined && { attemptCount }),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Wait for the lockout period to expire',
+            'Contact support to unlock your account',
+            'Use the password reset option if available',
+            'Verify you are using the correct email address',
+            'Check with your administrator for account status',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
+        this.name = 'AccountLockedError';
+    }
+    static create(email, reason, lockedUntil, attemptCount) {
+        return new AccountLockedError(email, reason, lockedUntil, attemptCount);
+    }
+    /**
+     * Creates an AccountLockedError for too many failed attempts
+     */
+    static tooManyAttempts(email, attemptCount, lockedUntil) {
+        return new AccountLockedError(email, 'Too many failed login attempts', lockedUntil, attemptCount);
+    }
+    /**
+     * Creates an AccountLockedError for security violation
+     */
+    static securityViolation(email, lockedUntil) {
+        return new AccountLockedError(email, 'Security violation detected', lockedUntil);
+    }
+    /**
+     * Creates an AccountLockedError for administrative lock
+     */
+    static administrativeLock(email, reason) {
+        return new AccountLockedError(email, `Administrative lock: ${reason}`);
+    }
+}
+exports.AccountLockedError = AccountLockedError;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodedRootError = void 0;
+const RootError_1 = require("./RootError");
+/**
+ * Enhanced base class for all domain errors with error code support
+ * This extends the existing RootError to add error code functionality
+ * while maintaining backward compatibility
+ *
+ * @since 1.0.0
+ */
+class CodedRootError extends RootError_1.RootError {
+    /**
+     * Creates a new CodedRootError instance
+     *
+     * @param errorCode - Unique error code (CBX-XXX-NNN)
+     * @param technicalMessage - Detailed technical message for debugging
+     * @param context - Optional context data safe to expose
+     * @param suggestions - Optional user action suggestions
+     */
+    constructor(errorCode, technicalMessage, context, suggestions) {
+        // Call parent constructor with technical message
+        super(technicalMessage);
+        this.errorCode = errorCode;
+        this.technicalMessage = technicalMessage;
+        this.context = context;
+        this.suggestions = suggestions;
+        // Set the name to the constructor name for better logging
+        this.name = this.constructor.name;
+    }
+    /**
+     * Returns a log-friendly representation of the error
+     * Includes error code, name, technical message and context
+     */
+    logError() {
+        const contextStr = this.context ? ` | Context: ${JSON.stringify(this.context)}` : '';
+        return `[${this.errorCode}] ${this.name}: ${this.technicalMessage}${contextStr}`;
+    }
+    /**
+     * Returns a safe representation of the error for external clients
+     * This excludes the technical message but includes code, context and suggestions
+     */
+    toPublicError() {
+        return {
+            code: this.errorCode,
+            name: this.name,
+            ...(this.context && { context: this.context }),
+            ...(this.suggestions && { suggestions: this.suggestions }),
+        };
+    }
+    /**
+     * Checks if an error implements the ICodedError interface
+     */
+    static isCodedError(error) {
+        return (typeof error === 'object' &&
+            error !== null &&
+            'errorCode' in error &&
+            'technicalMessage' in error &&
+            typeof error.errorCode === 'string' &&
+            typeof error.technicalMessage === 'string');
+    }
+}
+exports.CodedRootError = CodedRootError;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationNotFoundError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Exception thrown when a carbon footprint configuration is not found
+ * This error occurs when searching for configurations by ID, type, or other criteria
+ *
+ * Error code: CBX-CFC-001
+ * @since 1.0.0
+ */
+class ConfigurationNotFoundError extends CodedRootError_1.CodedRootError {
+    constructor(configurationType, searchCriteria, searchValue, clientId) {
+        const errorCode = ErrorCode_1.ErrorCode.CONFIGURATION_NOT_FOUND;
+        const clientInfo = clientId ? ` for client ${clientId}` : '';
+        const technicalMessage = `${configurationType} configuration not found: ${searchCriteria}='${searchValue}'${clientInfo}`;
+        const context = {
+            configurationType,
+            searchCriteria,
+            searchValue,
+            ...(clientId && { clientId }),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Verify the ${configurationType} configuration ID is correct`,
+            'Check if the configuration has been properly initialized',
+            'Ensure the configuration period is active',
+            'Contact an administrator to set up the required configuration',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
+        this.name = 'ConfigurationNotFoundError';
+    }
+    static create(configurationType, searchCriteria, searchValue, clientId) {
+        return new ConfigurationNotFoundError(configurationType, searchCriteria, searchValue, clientId);
+    }
+    /**
+     * Creates an error for missing corporate configuration
+     */
+    static corporate(id, clientId) {
+        return new ConfigurationNotFoundError('Corporate', 'id', id, clientId);
+    }
+    /**
+     * Creates an error for missing product configuration
+     */
+    static product(id, clientId) {
+        return new ConfigurationNotFoundError('Product', 'id', id, clientId);
+    }
+    /**
+     * Creates an error for missing event configuration
+     */
+    static event(id, clientId) {
+        return new ConfigurationNotFoundError('Event', 'id', id, clientId);
+    }
+    /**
+     * Creates an error for missing configuration by period
+     */
+    static byPeriod(configurationType, period, clientId) {
+        return new ConfigurationNotFoundError(configurationType, 'period', period, clientId);
+    }
+}
+exports.ConfigurationNotFoundError = ConfigurationNotFoundError;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractNotFoundError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Exception thrown when a purchase contract is not found in the system
+ * This error occurs when searching for contracts by ID, client, or other criteria
+ *
+ * Error code: CBX-PMS-001
+ * @since 1.0.0
+ */
+class ContractNotFoundError extends CodedRootError_1.CodedRootError {
+    constructor(searchCriteria, searchValue, clientId, contractType) {
+        const errorCode = ErrorCode_1.ErrorCode.CONTRACT_NOT_FOUND;
+        const clientInfo = clientId ? ` for client ${clientId}` : '';
+        const typeInfo = contractType ? ` (type: ${contractType})` : '';
+        const technicalMessage = `Purchase contract not found: ${searchCriteria}='${searchValue}'${clientInfo}${typeInfo}`;
+        const context = {
+            searchCriteria,
+            searchValue,
+            ...(clientId && { clientId }),
+            ...(contractType && { contractType }),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the contract ID is correct',
+            'Check if the contract has been properly created',
+            'Ensure the contract has not been deleted or archived',
+            'Verify you have permission to access this contract',
+            'Contact the contract administrator for assistance',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
+        this.name = 'ContractNotFoundError';
+    }
+    static create(searchCriteria, searchValue, clientId, contractType) {
+        return new ContractNotFoundError(searchCriteria, searchValue, clientId, contractType);
+    }
+    /**
+     * Creates a ContractNotFoundError specifically for ID searches
+     */
+    static byId(id, clientId) {
+        return new ContractNotFoundError('id', id, clientId);
+    }
+    /**
+     * Creates a ContractNotFoundError specifically for contract number searches
+     */
+    static byContractNumber(contractNumber, clientId) {
+        return new ContractNotFoundError('contractNumber', contractNumber, clientId);
+    }
+    /**
+     * Creates a ContractNotFoundError for active contracts
+     */
+    static noActiveContract(clientId) {
+        return new ContractNotFoundError('status', 'ACTIVE', clientId);
+    }
+}
+exports.ContractNotFoundError = ContractNotFoundError;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailNotVerifiedError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Error thrown when a user tries to perform an action that requires
+ * a verified email address, but their email has not been verified yet.
+ *
+ * @since 1.0.0
+ */
+class EmailNotVerifiedError extends CodedRootError_1.CodedRootError {
+    constructor(email, actionAttempted) {
+        const technicalMessage = actionAttempted
+            ? `User with email ${email} attempted to ${actionAttempted} without verifying their email address`
+            : `User with email ${email} has not verified their email address`;
+        const context = {
+            email,
+            timestamp: new Date().toISOString(),
+        };
+        if (actionAttempted) {
+            context.actionAttempted = actionAttempted;
+        }
+        const suggestions = [
+            'Check your email inbox for a verification link',
+            'Request a new verification email if the previous one expired',
+            'Ensure you are checking the correct email account',
+            'Check your spam/junk folder for the verification email',
+        ];
+        super(ErrorCode_1.ErrorCode.EMAIL_NOT_VERIFIED, technicalMessage, context, suggestions);
+        this.name = 'EmailNotVerifiedError';
+    }
+    /**
+     * Factory method to create a new EmailNotVerifiedError instance
+     *
+     * @param email - The unverified email address
+     * @param actionAttempted - Optional description of the action the user attempted
+     * @returns A new EmailNotVerifiedError instance
+     */
+    static create(email, actionAttempted) {
+        return new EmailNotVerifiedError(email, actionAttempted);
+    }
+    /**
+     * Returns whether the error is related to accessing restricted features
+     */
+    isAccessRestriction() {
+        return this.context?.actionAttempted !== undefined;
+    }
+    /**
+     * Returns a user-friendly message based on the locale
+     */
+    getUserMessage(locale = 'en') {
+        const messages = {
+            en: 'Please verify your email address to continue',
+            es: 'Por favor, verifica tu dirección de correo electrónico para continuar',
+            pt: 'Por favor, verifique seu endereço de e-mail para continuar',
+        };
+        return messages[locale] || messages.en;
+    }
+}
+exports.EmailNotVerifiedError = EmailNotVerifiedError;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidBusinessStatusError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Exception thrown when a business status transition is invalid
+ * This error occurs when attempting to change a stakeholder or entity status to an invalid state
+ *
+ * Error code: CBX-STK-005
+ * @since 1.0.0
+ */
+class InvalidBusinessStatusError extends CodedRootError_1.CodedRootError {
+    constructor(currentStatus, attemptedStatus, entityType, entityId) {
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_BUSINESS_STATUS;
+        const entityInfo = entityId ? ` (ID: ${entityId})` : '';
+        const technicalMessage = `Invalid business status transition for ${entityType}${entityInfo}: Cannot change from '${currentStatus}' to '${attemptedStatus}'`;
+        const context = {
+            currentStatus,
+            attemptedStatus,
+            entityType,
+            ...(entityId && { entityId }),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Current status '${currentStatus}' does not allow transition to '${attemptedStatus}'`,
+            'Review the allowed status transitions for this entity type',
+            'Ensure all required conditions are met for the status change',
+            'Contact an administrator if you believe this transition should be allowed',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
+        this.name = 'InvalidBusinessStatusError';
+    }
+    static create(currentStatus, attemptedStatus, entityType, entityId) {
+        return new InvalidBusinessStatusError(currentStatus, attemptedStatus, entityType, entityId);
+    }
+    /**
+     * Creates an error for invalid activation attempts
+     */
+    static cannotActivate(currentStatus, entityType, entityId) {
+        return new InvalidBusinessStatusError(currentStatus, 'ACTIVE', entityType, entityId);
+    }
+    /**
+     * Creates an error for invalid deactivation attempts
+     */
+    static cannotDeactivate(currentStatus, entityType, entityId) {
+        return new InvalidBusinessStatusError(currentStatus, 'INACTIVE', entityType, entityId);
+    }
+    /**
+     * Creates an error for invalid deletion attempts
+     */
+    static cannotDelete(currentStatus, entityType, entityId) {
+        return new InvalidBusinessStatusError(currentStatus, 'DELETED', entityType, entityId);
+    }
+}
+exports.InvalidBusinessStatusError = InvalidBusinessStatusError;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidCredentialsError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Exception thrown when authentication credentials are invalid
+ * This error is used when the email/password combination is incorrect
+ *
+ * Error code: CBX-AUTH-001
+ * @since 1.0.0
+ */
+class InvalidCredentialsError extends CodedRootError_1.CodedRootError {
+    constructor(email, attemptNumber) {
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_CREDENTIALS;
+        const technicalMessage = `Invalid credentials for user: ${email}${attemptNumber ? ` (attempt ${attemptNumber})` : ''}`;
+        const context = {
+            email,
+            ...(attemptNumber !== undefined && { attemptNumber }),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify your email and password are correct',
+            'Check if Caps Lock is enabled',
+            'Use "Forgot Password" if you cannot remember your credentials',
+            'Contact support if you continue having issues',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
+        this.name = 'InvalidCredentialsError';
+    }
+    static create(email, attemptNumber) {
+        return new InvalidCredentialsError(email, attemptNumber);
+    }
+}
+exports.InvalidCredentialsError = InvalidCredentialsError;

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

@@ -1,19 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCurrencyError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidCurrencyError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Error thrown when an invalid currency code is provided
+ * that does not match the accepted currency standards.
+ *
+ * @since 1.0.0
+ */
+class InvalidCurrencyError extends CodedRootError_1.CodedRootError {
     constructor(currency, validCurrencies) {
         const validCurrenciesText = validCurrencies.join(', ');
-        const message = `Invalid currency '${currency}'. Valid currencies are: ${validCurrenciesText}`;
-        super(message);
+        const technicalMessage = `Invalid currency '${currency}'. Valid currencies are: ${validCurrenciesText}`;
+        const context = {
+            providedCurrency: currency,
+            validCurrencies,
+            totalValidCurrencies: validCurrencies.length,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the supported currency codes: ${validCurrencies.slice(0, 5).join(', ')}${validCurrencies.length > 5 ? '...' : ''}`,
+            'Currency codes should be in ISO 4217 format (e.g., USD, EUR, GBP)',
+            'Check for typos in the currency code',
+            'Ensure the currency code is in uppercase',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CURRENCY, technicalMessage, context, suggestions);
         this.name = 'InvalidCurrencyError';
     }
+    /**
+     * Factory method to create a new InvalidCurrencyError instance
+     *
+     * @param currency - The invalid currency code provided
+     * @param validCurrencies - List of valid currency codes
+     * @returns A new InvalidCurrencyError instance
+     */
     static create(currency, validCurrencies) {
         return new InvalidCurrencyError(currency, validCurrencies);
     }
-    logError() {
-        return `${this.name}: ${this.message}`;
+    /**
+     * Checks if the provided currency might be a common typo
+     */
+    isPossibleTypo() {
+        const currency = this.context?.providedCurrency;
+        const validCurrencies = this.context?.validCurrencies;
+        if (!currency || !validCurrencies)
+            return false;
+        // Check if it's just a case issue
+        return validCurrencies.some(valid => valid.toLowerCase() === currency.toLowerCase());
+    }
+    /**
+     * Returns a user-friendly message based on the locale
+     */
+    getUserMessage(locale = 'en') {
+        const messages = {
+            en: 'The currency code provided is not supported',
+            es: 'El código de moneda proporcionado no está soportado',
+            pt: 'O código de moeda fornecido não é suportado',
+        };
+        return messages[locale] || messages.en;
     }
 }
 exports.InvalidCurrencyError = InvalidCurrencyError;

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

@@ -1,18 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidDateFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidDateFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidDateFormatError extends CodedRootError_1.CodedRootError {
     constructor(value, expectedFormat) {
-        const message = `Invalid date format: '${value}' does not match the required format '${expectedFormat}'.`;
-        super(message);
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_DATE_FORMAT;
+        const technicalMessage = `Invalid date format: '${value}' does not match the required format '${expectedFormat}'.`;
+        const context = {
+            value,
+            expectedFormat,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use the format: ${expectedFormat}`,
+            `Example: ${InvalidDateFormatError.getFormatExample(expectedFormat)}`,
+            'Check the date separator characters',
+            'Verify the date components are in the correct order',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
         this.name = 'InvalidDateFormatError';
     }
     static create(value, expectedFormat) {
         return new InvalidDateFormatError(value, expectedFormat);
     }
-    logError() {
-        return `${this.name}: ${this.message}`;
+    static getFormatExample(format) {
+        const examples = {
+            'YYYY-MM-DD': '2024-03-15',
+            'DD/MM/YYYY': '15/03/2024',
+            'MM/DD/YYYY': '03/15/2024',
+            'ISO8601': '2024-03-15T10:30:00Z',
+            'YYYY-MM-DDTHH:mm:ss': '2024-03-15T10:30:00',
+        };
+        return examples[format] || '2024-03-15';
     }
 }
 exports.InvalidDateFormatError = InvalidDateFormatError;