@carbonbox/domain 0.4.9 → 0.4.11

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidUserIdFormatError = void 0;
+const RootError_1 = require("./RootError");
+class InvalidUserIdFormatError extends RootError_1.RootError {
+    constructor(userId, reason) {
+        const message = `The UserId "${userId}" has invalid format or prefix: ${reason}. ${InvalidUserIdFormatError.INVALID_USER_ID_FORMAT_ERROR_MESSAGE}`;
+        super(message);
+        this.name = 'InvalidUserIdFormatError';
+    }
+    static create(userId, reason) {
+        return new InvalidUserIdFormatError(userId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidUserIdFormatError = InvalidUserIdFormatError;
+InvalidUserIdFormatError.INVALID_USER_ID_FORMAT_ERROR_MESSAGE = 'Invalid UserId format or prefix structure';

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidUserPrefixError = void 0;
+const RootError_1 = require("./RootError");
+class InvalidUserPrefixError extends RootError_1.RootError {
+    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);
+        this.name = 'InvalidUserPrefixError';
+    }
+    static create(userId, prefix, validPrefixes) {
+        return new InvalidUserPrefixError(userId, prefix, validPrefixes);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidUserPrefixError = InvalidUserPrefixError;
+InvalidUserPrefixError.INVALID_USER_PREFIX_ERROR_MESSAGE = 'Invalid user prefix for UserId';

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidUuidFormatError = void 0;
+const RootError_1 = require("./RootError");
+class InvalidUuidFormatError extends RootError_1.RootError {
+    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);
+        this.name = 'InvalidUuidFormatError';
+    }
+    static create(uuid, semanticUuid) {
+        return new InvalidUuidFormatError(uuid, semanticUuid);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidUuidFormatError = InvalidUuidFormatError;
+InvalidUuidFormatError.INVALID_UUID_FORMAT_ERROR_MESSAGE = 'Invalid UUID v4 format';

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownBoundedContextCodeError = void 0;
+const RootError_1 = require("./RootError");
+class UnknownBoundedContextCodeError extends RootError_1.RootError {
+    constructor(contextCode, semanticUuid) {
+        const message = `The bounded context code "${contextCode}" is not recognized in semantic UUID "${semanticUuid}". ${UnknownBoundedContextCodeError.UNKNOWN_BOUNDED_CONTEXT_CODE_ERROR_MESSAGE}`;
+        super(message);
+        this.name = 'UnknownBoundedContextCodeError';
+    }
+    static create(contextCode, semanticUuid) {
+        return new UnknownBoundedContextCodeError(contextCode, semanticUuid);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.UnknownBoundedContextCodeError = UnknownBoundedContextCodeError;
+UnknownBoundedContextCodeError.UNKNOWN_BOUNDED_CONTEXT_CODE_ERROR_MESSAGE = 'Unknown bounded context code in semantic UUID';

package/build/carbonbox/shared/domain/services/contracts/ISemanticUuidDomainService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/shared/domain/services/implementations/SemanticUuidDomainService.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticUuidDomainService = void 0;
+const either_1 = require("../../../either");
+const SemanticUuidPrefix_1 = require("../../enums/SemanticUuidPrefix");
+const InvalidSemanticUuidError_1 = require("../../exceptions/InvalidSemanticUuidError");
+const UnknownBoundedContextCodeError_1 = require("../../exceptions/UnknownBoundedContextCodeError");
+const InvalidSemanticUuidFormatError_1 = require("../../exceptions/InvalidSemanticUuidFormatError");
+const InvalidUuidFormatError_1 = require("../../exceptions/InvalidUuidFormatError");
+/**
+ * Domain Service for semantic UUID parsing, validation and business logic operations.
+ * Provides centralized business logic for semantic UUID handling across the domain.
+ * Refactored to support dependency injection and Either pattern for error handling.
+ *
+ * This service maintains Value Object purity by being used in factories,
+ * application services, and other appropriate contexts.
+ */
+class SemanticUuidDomainService {
+    constructor() {
+        // Semantic UUID format: BC_UUID or BC-SUB1-SUB2-...SUBn_UUID
+        this.SEMANTIC_UUID_REGEX = /^[A-Z]{3}(-[A-Z]{3})*_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        // Standard UUID v4 regex
+        this.UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        // Private constructor to enforce factory pattern
+    }
+    static create() {
+        return new SemanticUuidDomainService();
+    }
+    /**
+     * Validates if a string is a valid semantic UUID prefix
+     */
+    isValidPrefix(prefix) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            if (typeof prefix !== 'string') {
+                return false;
+            }
+            return Object.values(SemanticUuidPrefix_1.SemanticUuidPrefix).includes(prefix);
+        }, (error) => {
+            if (error instanceof InvalidSemanticUuidError_1.InvalidSemanticUuidError) {
+                return error;
+            }
+            return InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(prefix, 'Failed to validate prefix');
+        });
+    }
+    /**
+     * Gets the bounded context name from a semantic UUID prefix
+     */
+    getBoundedContext(prefix) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const contextCode = prefix.split('-')[0];
+            const contextMap = {
+                ADC: 'ActivityDataCollection',
+                CFC: 'CarbonFootprintConfigurations',
+                CPR: 'CompanyResources',
+                ECF: 'EmissionCalculationFormulas',
+                ECP: 'EmissionCalculationProcess',
+                ECR: 'EmissionCalculationResults',
+                USR: 'Users',
+                SHR: 'Shared',
+                STC: 'SystemTechnicalConfiguration',
+            };
+            const result = contextMap[contextCode];
+            if (!result) {
+                throw UnknownBoundedContextCodeError_1.UnknownBoundedContextCodeError.create(contextCode, prefix);
+            }
+            return result;
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(prefix, `Failed to get bounded context: ${error}`));
+    }
+    /**
+     * Gets the subdomain from a semantic UUID prefix
+     */
+    getSubdomain(prefix) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const parts = prefix.split('-');
+            if (parts.length === 1) {
+                return ''; // BC-level entity has no subdomain
+            }
+            return parts.slice(1).join('-'); // Join all subdomain parts
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(prefix, `Failed to get subdomain: ${error}`));
+    }
+    /**
+     * Gets all available prefixes as an array
+     */
+    getAllPrefixes() {
+        return either_1.EitherFactory.fromTryCatch(() => Object.values(SemanticUuidPrefix_1.SemanticUuidPrefix).sort(), (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create('', `Failed to get all prefixes: ${error}`));
+    }
+    /**
+     * Gets prefixes by bounded context
+     */
+    getPrefixesByBoundedContext(boundedContext) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const contextMap = {
+                ActivityDataCollection: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_SUBMISSIONS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_FIELDS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_LOGIC,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_LABELS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_FORMS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_ADAPTATIONS,
+                ],
+                CarbonFootprintConfigurations: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.CFC_CORPORATE,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.CFC_EVENT,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.CFC_PRODUCT,
+                ],
+                CompanyResources: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.CPR_EVENTS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.CPR_FACILITIES,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.CPR_PRODUCTS,
+                ],
+                EmissionCalculationFormulas: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECF_VARIABLES,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECF_FACTORS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECF_GWP,
+                ],
+                EmissionCalculationProcess: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECP_JOBS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECP_PROCESSES,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECP_WORKFLOWS,
+                ],
+                EmissionCalculationResults: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECR_AGGREGATIONS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECR_CALCULATIONS,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.ECR_GHG_RESULTS,
+                ],
+                Users: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.USR,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.USR_STH_CLIENT,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.USR_STH_COORDINATOR,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.USR_STH_HOST,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.USR_STH_MANAGER,
+                ],
+                Shared: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.SHR_DOMAIN,
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.SHR_EITHER,
+                ],
+                SystemTechnicalConfiguration: [
+                    SemanticUuidPrefix_1.SemanticUuidPrefix.STC,
+                ],
+            };
+            return contextMap[boundedContext] || [];
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(boundedContext, `Failed to get prefixes for bounded context: ${error}`));
+    }
+    /**
+     * Validates a complete semantic UUID format
+     */
+    validateSemanticUuidFormat(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            if (typeof semanticUuid !== 'string') {
+                return false;
+            }
+            return this.SEMANTIC_UUID_REGEX.test(semanticUuid);
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to validate semantic UUID format: ${error}`));
+    }
+    /**
+     * Extracts and validates the prefix from a semantic UUID
+     */
+    extractPrefix(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const parts = semanticUuid.split('_');
+            if (parts.length !== 2) {
+                throw InvalidSemanticUuidFormatError_1.InvalidSemanticUuidFormatError.create(semanticUuid, 'must contain exactly one underscore');
+            }
+            return parts[0];
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to extract prefix: ${error}`));
+    }
+    /**
+     * Extracts and validates the UUID from a semantic UUID
+     */
+    extractUuid(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const parts = semanticUuid.split('_');
+            if (parts.length !== 2) {
+                throw InvalidSemanticUuidFormatError_1.InvalidSemanticUuidFormatError.create(semanticUuid, 'must contain exactly one underscore');
+            }
+            const uuid = parts[1];
+            if (!this.UUID_REGEX.test(uuid)) {
+                throw InvalidUuidFormatError_1.InvalidUuidFormatError.create(uuid, semanticUuid);
+            }
+            return uuid;
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to extract UUID: ${error}`));
+    }
+    /**
+     * Extracts the bounded context code (first 3 letters) from a semantic UUID
+     */
+    extractBoundedContextCode(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const prefixResult = this.extractPrefix(semanticUuid);
+            const prefix = prefixResult.fold((error) => { throw error; }, (p) => p);
+            return prefix.substring(0, 3);
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to extract bounded context code: ${error}`));
+    }
+    /**
+     * Extracts all subdomain parts from a semantic UUID
+     */
+    extractSubdomains(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const prefixResult = this.extractPrefix(semanticUuid);
+            const prefix = prefixResult.fold((error) => { throw error; }, (p) => p);
+            const parts = prefix.split('-');
+            // Remove the first part (BC) and return the rest (SUB1, SUB2, ...)
+            return parts.slice(1);
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to extract subdomains: ${error}`));
+    }
+    /**
+     * Checks if a semantic UUID has subdomains or is BC-level only
+     */
+    hasSubdomains(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const subdomainsResult = this.extractSubdomains(semanticUuid);
+            const subdomains = subdomainsResult.fold((error) => { throw error; }, (subs) => subs);
+            return subdomains.length > 0;
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to check subdomains: ${error}`));
+    }
+    /**
+     * Creates a human-readable log representation of a semantic UUID
+     */
+    toLogString(semanticUuid) {
+        return either_1.EitherFactory.fromTryCatch(() => {
+            const uuidResult = this.extractUuid(semanticUuid);
+            const uuid = uuidResult.fold((error) => { throw error; }, (u) => u);
+            const boundedContextResult = this.extractBoundedContextCode(semanticUuid);
+            const boundedContextCode = boundedContextResult.fold((error) => { throw error; }, (bc) => bc);
+            const subdomainsResult = this.extractSubdomains(semanticUuid);
+            const subdomains = subdomainsResult.fold((error) => { throw error; }, (subs) => subs);
+            if (subdomains.length === 0) {
+                // BC-level entity (e.g., STC_uuid)
+                return `[${boundedContextCode}] (${uuid.substring(0, 8)}...)`;
+            }
+            // Subdomain entity (e.g., USR-STH-CHO_uuid)
+            return `[${boundedContextCode}:${subdomains.join(':')}] (${uuid.substring(0, 8)}...)`;
+        }, (error) => InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticUuid, `Failed to create log string: ${error}`));
+    }
+}
+exports.SemanticUuidDomainService = SemanticUuidDomainService;

package/build/carbonbox/shared/domain/value-objects/ActivityDataSubmissionReference.js

@@ -88,7 +88,7 @@ class ActivityDataSubmissionReference extends ObjectValueObject_1.ObjectValueObj
      */
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código del formulario dinámico.

package/build/carbonbox/shared/domain/value-objects/AggregateId.js

@@ -3,11 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateId = void 0;
 const String_1 = require("./String");
 const InvalidAggregateIdError_1 = require("../exceptions/InvalidAggregateIdError");
+const InvalidSemanticUuidError_1 = require("../exceptions/InvalidSemanticUuidError");
+/**
+ * Pure AggregateId Value Object with semantic UUID format
+ *
+ * Format: {BC}_{UUID} or {BC}-{SUB1}-{SUB2}-...{SUBn}_{UUID}
+ * Examples:
+ * - STC_550e8400-e29b-41d4-a716-446655440000 (BC-level entity)
+ * - USR-STH-CHO_550e8400-e29b-41d4-a716-446655440000 (subdomain entity)
+ * - ADC-SUB-FLD_123e4567-e89b-12d3-a456-426614174000 (future N-level expansion)
+ *
+ * This is a PURE Value Object - no external dependencies or business logic.
+ * For semantic parsing and business logic, use SemanticUuidDomainService.
+ *
+ * Benefits:
+ * - Immutable and pure value object design
+ * - Basic validation and extraction methods
+ * - Flexible N-level subdomain support
+ * - Clean separation of concerns
+ */
 class AggregateId extends String_1.String {
     constructor(value, skipDomainValidation, propertyName = AggregateId.DEFAULT_PROPERTY_NAME) {
         super(value, skipDomainValidation, propertyName);
         if (skipDomainValidation === false) {
-            AggregateId.guardAgainstInvalidId(value, propertyName);
+            AggregateId.guardAgainstInvalidSemanticId(value, propertyName);
         }
     }
     static create(id) {
@@ -16,19 +35,91 @@ class AggregateId extends String_1.String {
     static fromPrimitives(id) {
         return new AggregateId(id, true);
     }
-    static guardAgainstInvalidId(id, propertyName = AggregateId.DEFAULT_PROPERTY_NAME) {
-        if (this.isInvalid(id)) {
-            throw InvalidAggregateIdError_1.InvalidAggregateIdError.create(id, propertyName);
+    /**
+     * Extracts the raw UUID from the semantic UUID
+     */
+    extractUuid() {
+        const parts = this.value.split('_');
+        if (parts.length !== 2) {
+            throw InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(this.value, 'Invalid semantic UUID format');
         }
+        return parts[1];
     }
-    static isInvalid(id) {
-        return !this.isValid(id);
+    /**
+     * Extracts the full prefix from the semantic UUID (BC-SUB1-SUB2-...SUBn)
+     */
+    extractPrefix() {
+        const parts = this.value.split('_');
+        if (parts.length !== 2) {
+            throw InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(this.value, 'Invalid semantic UUID format');
+        }
+        return parts[0];
+    }
+    /**
+     * Extracts the bounded context (first 3 letters) from the prefix
+     */
+    extractBoundedContext() {
+        const prefix = this.extractPrefix();
+        return prefix.substring(0, 3);
+    }
+    /**
+     * Extracts all subdomain parts from the prefix
+     * Returns empty array if BC has no subdomains (e.g., STC_uuid)
+     */
+    extractSubdomains() {
+        const prefix = this.extractPrefix();
+        const parts = prefix.split('-');
+        // Remove the first part (BC) and return the rest (SUB1, SUB2, ...)
+        // Returns empty array if no subdomains exist
+        return parts.slice(1);
+    }
+    /**
+     * Extracts the primary subdomain (first subdomain after BC)
+     * Returns empty string if BC has no subdomains
+     */
+    extractPrimarySubdomain() {
+        const subdomains = this.extractSubdomains();
+        return subdomains.length > 0 ? subdomains[0] : '';
+    }
+    /**
+     * Checks if this UUID has subdomains or is BC-level only
+     */
+    hasSubdomains() {
+        return this.extractSubdomains().length > 0;
+    }
+    /**
+     * Validation methods
+     */
+    static guardAgainstInvalidSemanticId(semanticId, propertyName = AggregateId.DEFAULT_PROPERTY_NAME) {
+        if (this.isInvalidSemanticId(semanticId)) {
+            throw InvalidSemanticUuidError_1.InvalidSemanticUuidError.create(semanticId, propertyName);
+        }
     }
-    static isValid(id) {
-        return AggregateId.UUID_REGEX.test(id);
+    static guardAgainstInvalidUuid(uuid, propertyName = 'uuid') {
+        if (this.isInvalidUuid(uuid)) {
+            throw InvalidAggregateIdError_1.InvalidAggregateIdError.create(uuid, `Invalid UUID format for ${propertyName}`);
+        }
+    }
+    static isInvalidSemanticId(semanticId) {
+        return this.isValidSemanticId(semanticId) === false;
+    }
+    static isInvalidUuid(uuid) {
+        return this.isValidUuid(uuid) === false;
+    }
+    static isValidSemanticId(semanticId) {
+        return AggregateId.SEMANTIC_UUID_REGEX.test(semanticId);
+    }
+    static isValidUuid(uuid) {
+        return AggregateId.UUID_REGEX.test(uuid);
     }
     static isValidId(id) {
-        return this.isValid(id);
+        return this.isValidSemanticId(id);
+    }
+    static isValidSemanticIdValue(semanticId) {
+        return this.isValidSemanticId(semanticId);
+    }
+    static isValidUuidValue(uuid) {
+        return this.isValidUuid(uuid);
     }
     toPrimitives() {
         return this.value;
@@ -36,4 +127,8 @@ class AggregateId extends String_1.String {
 }
 exports.AggregateId = AggregateId;
 AggregateId.DEFAULT_PROPERTY_NAME = 'id';
-AggregateId.UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+// Standard UUID v4 regex
+AggregateId.UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+// Semantic UUID format: BC_UUID or BC-SUB1-SUB2-...SUBn_UUID (flexible N-level subdomain support)
+// Pattern: [A-Z]{3}(-[A-Z]{3})*_[UUID] - BC alone OR BC with unlimited SUBn levels
+AggregateId.SEMANTIC_UUID_REGEX = /^[A-Z]{3}(-[A-Z]{3})*_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

package/build/carbonbox/shared/domain/value-objects/AggregateIdList.js

@@ -31,7 +31,7 @@ class AggregateIdList extends StringList_1.StringList {
         return this.value.includes(id);
     }
     addId(id) {
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id);
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id);
         if (this.hasId(id)) {
             return this.value;
         }

package/build/carbonbox/shared/domain/value-objects/CalculationProcessReference.js

@@ -59,15 +59,15 @@ class CalculationProcessReference extends ObjectValueObject_1.ObjectValueObject
     }
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     static guardAgainstInvalidCarbonClient(carbonClient) {
         String_1.String.guardAgainstEmptyValue(carbonClient, 'carbonClient');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(carbonClient, 'carbonClient');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(carbonClient, 'carbonClient');
     }
     static guardAgainstInvalidFootprintConfiguration(footprintConfiguration) {
         String_1.String.guardAgainstEmptyValue(footprintConfiguration, 'footprintConfiguration');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(footprintConfiguration, 'footprintConfiguration');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(footprintConfiguration, 'footprintConfiguration');
     }
     get id() {
         return __classPrivateFieldGet(this, _CalculationProcessReference_id, "f");

package/build/carbonbox/shared/domain/value-objects/CalculationVariableReferences.js

@@ -108,7 +108,7 @@ class CalculationVariableReferences extends ValueObject_1.ValueObject {
         }
         // Validar usando las reglas de dominio
         String_1.String.guardAgainstEmptyValue(reference.id, `${propertyName}.id`);
-        AggregateId_1.AggregateId.guardAgainstInvalidId(reference.id, `${propertyName}.id`);
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(reference.id, `${propertyName}.id`);
         String_1.String.guardAgainstEmptyValue(reference.code, `${propertyName}.code`);
         Code_1.Code.guardAgainstInvalidCode(reference.code);
         String_1.String.guardAgainstEmptyValue(reference.symbol, `${propertyName}.symbol`);

package/build/carbonbox/shared/domain/value-objects/CarbonClientReference.js

@@ -94,7 +94,7 @@ class CarbonClientReference extends ObjectValueObject_1.ObjectValueObject {
      */
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el nombre para mostrar.

package/build/carbonbox/shared/domain/value-objects/CarbonFootprintConfigurationReference.js

@@ -57,7 +57,7 @@ class CarbonFootprintConfigurationReference extends ObjectValueObject_1.ObjectVa
     }
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el tipo de huella de carbono.

package/build/carbonbox/shared/domain/value-objects/CarbonFootprintIntensityIndicatorReference.js

@@ -83,7 +83,7 @@ class CarbonFootprintIntensityIndicatorReference extends ObjectValueObject_1.Obj
     }
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código del indicador de intensidad usando las validaciones de DomainCode.

package/build/carbonbox/shared/domain/value-objects/CarbonFootprintSegmentReferences.js

@@ -104,7 +104,7 @@ class CarbonFootprintSegmentReferences extends ValueObject_1.ValueObject {
      */
     static guardAgainstInvalidSegmentId(id, propertyName) {
         String_1.String.guardAgainstEmptyValue(id, propertyName);
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, propertyName);
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, propertyName);
     }
     /**
      * Valida el código de segmento usando las validaciones de Code.

package/build/carbonbox/shared/domain/value-objects/CollectionFieldReference.js

@@ -77,7 +77,7 @@ class CollectionFieldReference extends ObjectValueObject_1.ObjectValueObject {
     }
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código del campo de recolección usando las validaciones de Code.

package/build/carbonbox/shared/domain/value-objects/CorporateCarbonFootprintSegmentConfigurationReferences.js

@@ -109,7 +109,7 @@ class CorporateCarbonFootprintSegmentConfigurationReferences extends ValueObject
      */
     static guardAgainstInvalidConfigurationId(id, propertyName) {
         String_1.String.guardAgainstEmptyValue(id, propertyName);
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, propertyName);
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, propertyName);
     }
     /**
      * Valida la referencia de segmento corporativo.
@@ -161,7 +161,7 @@ class CorporateCarbonFootprintSegmentConfigurationReferences extends ValueObject
             throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.name`, 'string', typeof reference.name);
         }
         String_1.String.guardAgainstEmptyValue(reference.id, `${propertyName}.id`);
-        AggregateId_1.AggregateId.guardAgainstInvalidId(reference.id, `${propertyName}.id`);
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(reference.id, `${propertyName}.id`);
         String_1.String.guardAgainstEmptyValue(reference.code, `${propertyName}.code`);
         Code_1.Code.guardAgainstInvalidCode(reference.code);
         String_1.String.guardAgainstEmptyValue(reference.name, `${propertyName}.name`);

package/build/carbonbox/shared/domain/value-objects/CorporateConfigurationCarbonFootprintSegmentReference.js

@@ -73,7 +73,7 @@ class CorporateConfigurationCarbonFootprintSegmentReference extends ObjectValueO
      */
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código del segmento corporativo.

package/build/carbonbox/shared/domain/value-objects/CorporateConfigurationCarbonFootprintSubsegmentReference.js

@@ -73,7 +73,7 @@ class CorporateConfigurationCarbonFootprintSubsegmentReference extends ObjectVal
      */
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código del subsegmento corporativo.

package/build/carbonbox/shared/domain/value-objects/EmissionCalculationFormulaReference.js

@@ -64,7 +64,7 @@ class EmissionCalculationFormulaReference extends ObjectValueObject_1.ObjectValu
     }
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código de la fórmula de cálculo de emisiones usando las validaciones de Code.

package/build/carbonbox/shared/domain/value-objects/EmissionCalculationReference.js

@@ -82,7 +82,7 @@ class EmissionCalculationReference extends ObjectValueObject_1.ObjectValueObject
     }
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida la referencia de activity data submission.

package/build/carbonbox/shared/domain/value-objects/EmissionFactorReference.js

@@ -67,7 +67,7 @@ class EmissionFactorReference extends ObjectValueObject_1.ObjectValueObject {
      */
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código del factor de emisión.

package/build/carbonbox/shared/domain/value-objects/EventEditionConfigurationCarbonFootprintSubsegmentReference.js

@@ -67,7 +67,7 @@ class EventEditionConfigurationCarbonFootprintSubsegmentReference extends Object
      */
     static guardAgainstInvalidId(id) {
         String_1.String.guardAgainstEmptyValue(id, 'id');
-        AggregateId_1.AggregateId.guardAgainstInvalidId(id, 'id');
+        AggregateId_1.AggregateId.guardAgainstInvalidSemanticId(id, 'id');
     }
     /**
      * Valida el código de subsegmento usando las validaciones de Code.