@carbonbox/domain 0.29.0 → 0.29.2

package/build/carbonbox/purchase-management-system/purchase-contracts/domain/exceptions/InvalidContractStatusError.js

@@ -1,19 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidContractStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidContractStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * Exception thrown when an invalid contract status is provided
+ * This error occurs when the contract status doesn't match allowed values
+ *
+ * Error code: CBX-PMS-002
+ * @since 1.0.0
+ */
+class InvalidContractStatusError extends CodedRootError_1.CodedRootError {
     constructor(contractStatus, validStatuses) {
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_CONTRACT_STATUS;
         const validStatusesText = validStatuses.join(', ');
-        const message = `Invalid contract status '${contractStatus}'. Valid contract statuses are: ${validStatusesText}`;
-        super(message);
+        const technicalMessage = `Invalid contract status '${contractStatus}'. Valid contract statuses are: ${validStatusesText}`;
+        const context = {
+            providedStatus: contractStatus,
+            validStatuses,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid contract statuses: ${validStatusesText}`,
+            'Common statuses include: DRAFT, ACTIVE, SUSPENDED, TERMINATED, EXPIRED',
+            'Check the contract lifecycle for valid status transitions',
+            'Contact contract administration for status change requests',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
         this.name = 'InvalidContractStatusError';
     }
     static create(contractStatus, validStatuses) {
         return new InvalidContractStatusError(contractStatus, validStatuses);
     }
-    logError() {
-        return `${this.name}: ${this.message}`;
-    }
 }
 exports.InvalidContractStatusError = InvalidContractStatusError;

package/build/carbonbox/purchase-management-system/purchase-contracts/domain/exceptions/InvalidPaymentTermsError.js

@@ -1,19 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPaymentTermsError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPaymentTermsError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * Exception thrown when invalid payment terms are provided for a contract
+ * This error occurs when the payment terms don't match allowed values
+ *
+ * Error code: CBX-PMS-003
+ * @since 1.0.0
+ */
+class InvalidPaymentTermsError extends CodedRootError_1.CodedRootError {
     constructor(paymentTerms, validTerms) {
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_PAYMENT_TERMS;
         const validTermsText = validTerms.join(', ');
-        const message = `Invalid payment terms '${paymentTerms}'. Valid payment terms are: ${validTermsText}`;
-        super(message);
+        const technicalMessage = `Invalid payment terms '${paymentTerms}'. Valid payment terms are: ${validTermsText}`;
+        const context = {
+            providedTerms: paymentTerms,
+            validTerms,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid payment terms: ${validTermsText}`,
+            'Common payment terms include: NET30, NET60, NET90, IMMEDIATE',
+            'Check contract requirements for specific payment terms',
+            'Contact the finance team for special payment term requests',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
         this.name = 'InvalidPaymentTermsError';
     }
     static create(paymentTerms, validTerms) {
         return new InvalidPaymentTermsError(paymentTerms, validTerms);
     }
-    logError() {
-        return `${this.name}: ${this.message}`;
-    }
 }
 exports.InvalidPaymentTermsError = InvalidPaymentTermsError;

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

@@ -52,12 +52,12 @@ class CodedRootError extends RootError_1.RootError {
      * 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');
+        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

@@ -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/MissingCredentialsError.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingCredentialsError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * Exception thrown when required authentication credentials are missing
+ * This error occurs when email, password, or both are not provided
+ *
+ * Error code: CBX-AUTH-004
+ * @since 1.0.0
+ */
+class MissingCredentialsError extends CodedRootError_1.CodedRootError {
+    constructor(missingFields) {
+        const errorCode = ErrorCode_1.ErrorCode.MISSING_CREDENTIALS;
+        const fieldsList = missingFields.join(', ');
+        const technicalMessage = `Missing required authentication credentials: ${fieldsList}`;
+        const context = {
+            missingFields,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide all required credentials (email and password)',
+            'Ensure no fields are left empty',
+            'Check that your request includes all required authentication data',
+            'If using an API, verify the request payload structure',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
+        this.name = 'MissingCredentialsError';
+    }
+    static create(missingFields) {
+        return new MissingCredentialsError(missingFields);
+    }
+    /**
+     * Creates a MissingCredentialsError for missing email
+     */
+    static missingEmail() {
+        return new MissingCredentialsError(['email']);
+    }
+    /**
+     * Creates a MissingCredentialsError for missing password
+     */
+    static missingPassword() {
+        return new MissingCredentialsError(['password']);
+    }
+    /**
+     * Creates a MissingCredentialsError for both missing email and password
+     */
+    static missingBoth() {
+        return new MissingCredentialsError(['email', 'password']);
+    }
+}
+exports.MissingCredentialsError = MissingCredentialsError;