@carbonbox/domain 0.6.2 → 0.6.3

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidSemanticUuidError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidSemanticUuidError extends RootError_1.RootError {
-    constructor(semanticUuid, propertyName) {
-        const message = `The semantic UUID "${semanticUuid}" violates the domain policy - ${InvalidSemanticUuidError.INVALID_SEMANTIC_UUID_ERROR_MESSAGE}. Property: ${propertyName}`;
-        super(message);
-        this.name = 'InvalidSemanticUuidError';
-    }
-    static create(semanticUuid, propertyName) {
-        return new InvalidSemanticUuidError(semanticUuid, propertyName);
-    }
-    logError() {
-        return `${this.name}: ${this.message}`;
-    }
-}
-exports.InvalidSemanticUuidError = InvalidSemanticUuidError;
-InvalidSemanticUuidError.INVALID_SEMANTIC_UUID_ERROR_MESSAGE = 'Invalid semantic UUID format. Expected: PREFIX_EntityType_UUID (e.g., ADC-SUB_ActivityDataSubmission_550e8400-e29b-41d4-a716-446655440000)';

package/build/carbonbox/shared/domain/services/DateTimeFormattingDomainService.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateTimeFormattingDomainService = void 0;
-const InvalidDateFormatError_1 = require("../exceptions/InvalidDateFormatError");
-const DateString_1 = require("../value-objects/DateString");
-const DateTimeString_1 = require("../value-objects/DateTimeString");
-/**
- * Domain Service for date and datetime formatting and validation operations.
- * Provides centralized business logic for date/datetime handling across the domain.
- */
-class DateTimeFormattingDomainService {
-    /**
-     * Validates if a date string has the correct format (DD/MM/YYYY)
-     * @param dateValue The date string to validate
-     * @returns true if the format is valid, false otherwise
-     */
-    static isValidDateFormat(dateValue) {
-        return this.DATE_REGEX.test(dateValue);
-    }
-    /**
-     * Validates if a datetime string has the correct format (DD/MM/YYYY HH:mm:ss)
-     * @param dateTimeValue The datetime string to validate
-     * @returns true if the format is valid, false otherwise
-     */
-    static isValidDateTimeFormat(dateTimeValue) {
-        return this.DATETIME_REGEX.test(dateTimeValue);
-    }
-    /**
-     * Formats a Date object to a date string (DD/MM/YYYY)
-     * @param date The Date object to format
-     * @returns The formatted date string
-     */
-    static formatDateToString(date) {
-        const day = String(date.getDate()).padStart(2, '0');
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const year = date.getFullYear();
-        return `${day}/${month}/${year}`;
-    }
-    /**
-     * Formats a Date object to a datetime string (DD/MM/YYYY HH:mm:ss)
-     * @param date The Date object to format
-     * @returns The formatted datetime string
-     */
-    static formatDateTimeToString(date) {
-        const day = String(date.getDate()).padStart(2, '0');
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const year = date.getFullYear();
-        const hours = String(date.getHours()).padStart(2, '0');
-        const minutes = String(date.getMinutes()).padStart(2, '0');
-        const seconds = String(date.getSeconds()).padStart(2, '0');
-        return `${day}/${month}/${year} ${hours}:${minutes}:${seconds}`;
-    }
-    /**
-     * Gets the current date formatted as a string (DD/MM/YYYY)
-     * @returns The current date as a formatted string
-     */
-    static getCurrentDateString() {
-        return this.formatDateToString(new Date());
-    }
-    /**
-     * Gets the current datetime formatted as a string (DD/MM/YYYY HH:mm:ss)
-     * @returns The current datetime as a formatted string
-     */
-    static getCurrentDateTimeString() {
-        return this.formatDateTimeToString(new Date());
-    }
-    /**
-     * Parses a date string (DD/MM/YYYY) to a Date object
-     * @param dateString The date string to parse
-     * @returns The parsed Date object
-     * @throws InvalidDateFormatError if the format is invalid
-     */
-    static parseDateString(dateString) {
-        if (!this.isValidDateFormat(dateString)) {
-            throw InvalidDateFormatError_1.InvalidDateFormatError.create(dateString, DateString_1.DateString.getDateFormat());
-        }
-        const [day, month, year] = dateString.split('/').map(Number);
-        return new Date(year, month - 1, day);
-    }
-    /**
-     * Parses a datetime string (DD/MM/YYYY HH:mm:ss) to a Date object
-     * @param dateTimeString The datetime string to parse
-     * @returns The parsed Date object
-     * @throws InvalidDateFormatError if the format is invalid
-     */
-    static parseDateTimeString(dateTimeString) {
-        if (!this.isValidDateTimeFormat(dateTimeString)) {
-            throw InvalidDateFormatError_1.InvalidDateFormatError.create(dateTimeString, DateTimeString_1.DateTimeString.getDateTimeFormat());
-        }
-        const [datePart, timePart] = dateTimeString.split(' ');
-        const [day, month, year] = datePart.split('/').map(Number);
-        const [hours, minutes, seconds] = timePart.split(':').map(Number);
-        return new Date(year, month - 1, day, hours, minutes, seconds);
-    }
-    /**
-     * Validates if a date string represents a valid calendar date
-     * @param dateString The date string to validate
-     * @returns true if the date is valid, false otherwise
-     */
-    static isValidDate(dateString) {
-        if (!this.isValidDateFormat(dateString)) {
-            return false;
-        }
-        try {
-            const date = this.parseDateString(dateString);
-            const reformattedDate = this.formatDateToString(date);
-            return reformattedDate === dateString;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Validates if a datetime string represents a valid calendar datetime
-     * @param dateTimeString The datetime string to validate
-     * @returns true if the datetime is valid, false otherwise
-     */
-    static isValidDateTime(dateTimeString) {
-        if (!this.isValidDateTimeFormat(dateTimeString)) {
-            return false;
-        }
-        try {
-            const date = this.parseDateTimeString(dateTimeString);
-            const reformattedDateTime = this.formatDateTimeToString(date);
-            return reformattedDateTime === dateTimeString;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Compares two date strings
-     * @param dateString1 First date string
-     * @param dateString2 Second date string
-     * @returns negative if first is earlier, positive if later, 0 if equal
-     * @throws InvalidDateFormatError if any format is invalid
-     */
-    static compareDates(dateString1, dateString2) {
-        const date1 = this.parseDateString(dateString1);
-        const date2 = this.parseDateString(dateString2);
-        return date1.getTime() - date2.getTime();
-    }
-    /**
-     * Compares two datetime strings
-     * @param dateTimeString1 First datetime string
-     * @param dateTimeString2 Second datetime string
-     * @returns negative if first is earlier, positive if later, 0 if equal
-     * @throws InvalidDateFormatError if any format is invalid
-     */
-    static compareDateTimes(dateTimeString1, dateTimeString2) {
-        const date1 = this.parseDateTimeString(dateTimeString1);
-        const date2 = this.parseDateTimeString(dateTimeString2);
-        return date1.getTime() - date2.getTime();
-    }
-    /**
-     * Gets the supported date format string
-     * @returns The date format string
-     */
-    static getDateFormat() {
-        return DateString_1.DateString.getDateFormat();
-    }
-    /**
-     * Gets the supported datetime format string
-     * @returns The datetime format string
-     */
-    static getDateTimeFormat() {
-        return DateTimeString_1.DateTimeString.getDateTimeFormat();
-    }
-}
-exports.DateTimeFormattingDomainService = DateTimeFormattingDomainService;
-DateTimeFormattingDomainService.DATE_REGEX = /^([0-2][0-9]|3[0-1])\/(0[1-9]|1[0-2])\/\d{4}$/;
-DateTimeFormattingDomainService.DATETIME_REGEX = /^([0-2][0-9]|3[0-1])\/(0[1-9]|1[0-2])\/\d{4} ([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/;

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

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

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

@@ -1,235 +0,0 @@
-"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/types/AllPermissions.js

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

package/build/carbonbox/shared/domain/types/AllPermissionsPrimitives.js

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

package/build/carbonbox/shared/domain/types/ServiceReference.js

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

package/build/carbonbox/shared/domain/types/ServiceReferencePrimitives.js

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

package/build/carbonbox/shared/domain/types/UserEmailProps.js

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