@carbonbox/domain 0.36.1 → 0.38.0

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/DuplicatePreparationQuestionError.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicatePreparationQuestionError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class DuplicatePreparationQuestionError extends CodedRootError_1.CodedRootError {
+    constructor(questionnaireId, questionId) {
+        const technicalMessage = `Preparation question '${questionId}' already exists in report preparation questionnaire '${questionnaireId}'.`;
+        const context = {
+            questionnaireId,
+            questionId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Question ids must be unique within a questionnaire',
+            'Generate a new semantic id (RPT-PRE-QST) for each custom question',
+            'Template questions are materialized once from the template blocks; do not add them again',
+        ];
+        super(ErrorCode_1.ErrorCode.DUPLICATE_PREPARATION_QUESTION, technicalMessage, context, suggestions);
+        this.name = 'DuplicatePreparationQuestionError';
+    }
+    static create(questionnaireId, questionId) {
+        return new DuplicatePreparationQuestionError(questionnaireId, questionId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.DuplicatePreparationQuestionError = DuplicatePreparationQuestionError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/InvalidPreparationAnswerError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPreparationAnswerError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPreparationAnswerError extends CodedRootError_1.CodedRootError {
+    constructor(questionId, fieldType, receivedAnswer, reason) {
+        const technicalMessage = `Invalid answer for preparation question '${questionId}' (${fieldType}): ${reason}`;
+        const context = {
+            questionId,
+            fieldType,
+            receivedAnswer,
+            receivedLength: receivedAnswer.length,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide an answer compatible with the question field type',
+            'For SINGLE_CHOICE use one of the configured options; for MULTIPLE_CHOICE send a JSON array of options',
+            'For NUMBER send a numeric value; for DATE send an ISO 8601 date',
+            'Respect the minLength / maxLength configured for text questions',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PREPARATION_ANSWER, technicalMessage, context, suggestions);
+        this.name = 'InvalidPreparationAnswerError';
+    }
+    static create(questionId, fieldType, receivedAnswer, reason) {
+        return new InvalidPreparationAnswerError(questionId, fieldType, receivedAnswer, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidPreparationAnswerError = InvalidPreparationAnswerError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/InvalidPreparationQuestionError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPreparationQuestionError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPreparationQuestionError extends CodedRootError_1.CodedRootError {
+    constructor(questionId, reason) {
+        const technicalMessage = `Invalid preparation question '${questionId}': ${reason}`;
+        const context = {
+            questionId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide a non-empty id and questionText',
+            'SINGLE_CHOICE and MULTIPLE_CHOICE questions need at least one option; other field types must not define options',
+            'minLength / maxLength must be non-negative and minLength cannot exceed maxLength',
+            'order must be a non-negative integer',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PREPARATION_QUESTION, technicalMessage, context, suggestions);
+        this.name = 'InvalidPreparationQuestionError';
+    }
+    static create(questionId, reason) {
+        return new InvalidPreparationQuestionError(questionId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidPreparationQuestionError = InvalidPreparationQuestionError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/PreparationQuestionNotFoundError.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparationQuestionNotFoundError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class PreparationQuestionNotFoundError extends CodedRootError_1.CodedRootError {
+    constructor(questionnaireId, questionId) {
+        const technicalMessage = `Preparation question '${questionId}' does not exist in report preparation questionnaire '${questionnaireId}'.`;
+        const context = {
+            questionnaireId,
+            questionId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the question id belongs to this questionnaire (template block id or custom question id)',
+            'Retrieve the questionnaire to list its current questions',
+            'Custom questions may have been removed; refresh the questionnaire before answering',
+        ];
+        super(ErrorCode_1.ErrorCode.PREPARATION_QUESTION_NOT_FOUND, technicalMessage, context, suggestions);
+        this.name = 'PreparationQuestionNotFoundError';
+    }
+    static create(questionnaireId, questionId) {
+        return new PreparationQuestionNotFoundError(questionnaireId, questionId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.PreparationQuestionNotFoundError = PreparationQuestionNotFoundError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/ReportPreparationQuestionnaireCannotBeCompletedError.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireCannotBeCompletedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class ReportPreparationQuestionnaireCannotBeCompletedError extends CodedRootError_1.CodedRootError {
+    constructor(questionnaireId, currentStatus, completion, unansweredRequiredQuestionIds) {
+        const technicalMessage = `Report preparation questionnaire '${questionnaireId}' cannot be completed. Current status: ${currentStatus}. Required questions answered: ${completion.answeredRequired}/${completion.totalRequired}. Missing: ${unansweredRequiredQuestionIds.join(', ') || 'none'}.`;
+        const context = {
+            questionnaireId,
+            currentStatus,
+            completion,
+            unansweredRequiredQuestionIds,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Answer every required question before completing the questionnaire',
+            'Retrieve the questionnaire to see which required questions are still unanswered',
+            'A questionnaire that is already COMPLETED does not need to be completed again',
+        ];
+        super(ErrorCode_1.ErrorCode.REPORT_PREPARATION_QUESTIONNAIRE_CANNOT_BE_COMPLETED, technicalMessage, context, suggestions);
+        this.name = 'ReportPreparationQuestionnaireCannotBeCompletedError';
+    }
+    static create(questionnaireId, currentStatus, completion, unansweredRequiredQuestionIds) {
+        return new ReportPreparationQuestionnaireCannotBeCompletedError(questionnaireId, currentStatus, completion, unansweredRequiredQuestionIds);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ReportPreparationQuestionnaireCannotBeCompletedError = ReportPreparationQuestionnaireCannotBeCompletedError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/ReportPreparationQuestionnaireCannotBeModifiedError.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireCannotBeModifiedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class ReportPreparationQuestionnaireCannotBeModifiedError extends CodedRootError_1.CodedRootError {
+    constructor(questionnaireId, currentStatus, attemptedAction) {
+        const technicalMessage = `Report preparation questionnaire '${questionnaireId}' cannot be modified (${attemptedAction}). Current status: ${currentStatus}.`;
+        const context = {
+            questionnaireId,
+            currentStatus,
+            attemptedAction,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Completed questionnaires are frozen; reopen the questionnaire before answering or changing custom questions',
+            `Review the current status of questionnaire '${questionnaireId}'`,
+        ];
+        super(ErrorCode_1.ErrorCode.REPORT_PREPARATION_QUESTIONNAIRE_CANNOT_BE_MODIFIED, technicalMessage, context, suggestions);
+        this.name = 'ReportPreparationQuestionnaireCannotBeModifiedError';
+    }
+    static create(questionnaireId, currentStatus, attemptedAction) {
+        return new ReportPreparationQuestionnaireCannotBeModifiedError(questionnaireId, currentStatus, attemptedAction);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ReportPreparationQuestionnaireCannotBeModifiedError = ReportPreparationQuestionnaireCannotBeModifiedError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/ReportPreparationQuestionnaireCannotBeReopenedError.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireCannotBeReopenedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class ReportPreparationQuestionnaireCannotBeReopenedError extends CodedRootError_1.CodedRootError {
+    constructor(questionnaireId, currentStatus) {
+        const technicalMessage = `Report preparation questionnaire '${questionnaireId}' cannot be reopened. Current status: ${currentStatus}. Only COMPLETED questionnaires can be reopened.`;
+        const context = {
+            questionnaireId,
+            currentStatus,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Only COMPLETED questionnaires can be reopened',
+            'DRAFT and IN_PROGRESS questionnaires are already editable',
+        ];
+        super(ErrorCode_1.ErrorCode.REPORT_PREPARATION_QUESTIONNAIRE_CANNOT_BE_REOPENED, technicalMessage, context, suggestions);
+        this.name = 'ReportPreparationQuestionnaireCannotBeReopenedError';
+    }
+    static create(questionnaireId, currentStatus) {
+        return new ReportPreparationQuestionnaireCannotBeReopenedError(questionnaireId, currentStatus);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ReportPreparationQuestionnaireCannotBeReopenedError = ReportPreparationQuestionnaireCannotBeReopenedError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/exceptions/TemplateQuestionCannotBeRemovedError.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateQuestionCannotBeRemovedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class TemplateQuestionCannotBeRemovedError extends CodedRootError_1.CodedRootError {
+    constructor(questionnaireId, questionId) {
+        const technicalMessage = `Preparation question '${questionId}' in questionnaire '${questionnaireId}' comes from the report template and cannot be removed. Only CUSTOM questions can be removed.`;
+        const context = {
+            questionnaireId,
+            questionId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Only questions with origin CUSTOM can be removed from a questionnaire',
+            'Template questions are defined by the CLIENT_INPUT blocks of the report template; change the template instead',
+            'If the question is not applicable and it is not required, leave it unanswered',
+        ];
+        super(ErrorCode_1.ErrorCode.TEMPLATE_QUESTION_CANNOT_BE_REMOVED, technicalMessage, context, suggestions);
+        this.name = 'TemplateQuestionCannotBeRemovedError';
+    }
+    static create(questionnaireId, questionId) {
+        return new TemplateQuestionCannotBeRemovedError(questionnaireId, questionId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.TemplateQuestionCannotBeRemovedError = TemplateQuestionCannotBeRemovedError;

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/repository/IReportPreparationQuestionnaireRepository.js

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

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/types/PreparationAnswerPrimitives.js

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

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/types/PreparationQuestionPrimitives.js

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

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/types/ReportPreparationQuestionnaireCompletionPrimitives.js

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

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/types/ReportPreparationQuestionnairePrimitives.js

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

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/types/ReportPreparationQuestionnaireProps.js

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

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/PreparationAnswer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparationAnswer = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const InvalidPreparationAnswerError_1 = require("../exceptions/InvalidPreparationAnswerError");
+class PreparationAnswer extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, PreparationAnswer.PROPERTY_NAME, PreparationAnswer.EXPECTED_TYPE);
+        if (!skipDomainValidation) {
+            this.validatePreparationAnswer(value);
+        }
+    }
+    static create(value) {
+        return new PreparationAnswer(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new PreparationAnswer(primitives, true);
+    }
+    validatePreparationAnswer(value) {
+        if (!value.questionId || value.questionId.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', value.answer, 'questionId cannot be empty');
+        }
+        if (typeof value.answer !== 'string' || value.answer.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', String(value.answer), 'answer cannot be empty');
+        }
+        if (!value.answeredAt || Number.isNaN(Date.parse(value.answeredAt))) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', value.answer, 'answeredAt must be an ISO 8601 timestamp');
+        }
+        if (!value.answeredBy || value.answeredBy.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', value.answer, 'answeredBy cannot be empty');
+        }
+    }
+    getQuestionId() {
+        return this.value.questionId;
+    }
+    getAnswer() {
+        return this.value.answer;
+    }
+    getAnsweredAt() {
+        return this.value.answeredAt;
+    }
+    getAnsweredBy() {
+        return this.value.answeredBy;
+    }
+    toPrimitives() {
+        return {
+            questionId: this.value.questionId,
+            answer: this.value.answer,
+            answeredAt: this.value.answeredAt,
+            answeredBy: this.value.answeredBy,
+        };
+    }
+}
+exports.PreparationAnswer = PreparationAnswer;
+PreparationAnswer.PROPERTY_NAME = 'preparationAnswer';
+PreparationAnswer.EXPECTED_TYPE = 'PreparationAnswerPrimitives';

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/PreparationQuestion.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparationQuestion = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const ClientInputFieldType_1 = require("../../../shared/domain/enums/ClientInputFieldType");
+const QuestionnaireQuestionOrigin_1 = require("../../../shared/domain/enums/QuestionnaireQuestionOrigin");
+const InvalidPreparationQuestionError_1 = require("../exceptions/InvalidPreparationQuestionError");
+const InvalidPreparationAnswerError_1 = require("../exceptions/InvalidPreparationAnswerError");
+class PreparationQuestion extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, PreparationQuestion.PROPERTY_NAME, PreparationQuestion.EXPECTED_TYPE);
+        if (!skipDomainValidation) {
+            this.validatePreparationQuestion(value);
+        }
+    }
+    static create(value) {
+        return new PreparationQuestion(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new PreparationQuestion(primitives, true);
+    }
+    validatePreparationQuestion(value) {
+        if (!value.id || value.id.trim() === '') {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'id cannot be empty');
+        }
+        if (!Object.values(QuestionnaireQuestionOrigin_1.QuestionnaireQuestionOrigin).includes(value.origin)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `origin '${value.origin}' is not supported`);
+        }
+        if (!value.questionText || value.questionText.trim() === '') {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'questionText cannot be empty');
+        }
+        if (!Object.values(ClientInputFieldType_1.ClientInputFieldType).includes(value.fieldType)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `fieldType '${value.fieldType}' is not supported`);
+        }
+        const isChoice = PreparationQuestion.CHOICE_FIELD_TYPES.includes(value.fieldType);
+        if (isChoice && (!Array.isArray(value.options) || value.options.length === 0)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `fieldType '${value.fieldType}' requires at least one option`);
+        }
+        if (!isChoice && Array.isArray(value.options) && value.options.length > 0) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `fieldType '${value.fieldType}' must not define options`);
+        }
+        if (value.minLength !== null && (!Number.isInteger(value.minLength) || value.minLength < 0)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'minLength must be a non-negative integer or null');
+        }
+        if (value.maxLength !== null && (!Number.isInteger(value.maxLength) || value.maxLength <= 0)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'maxLength must be a positive integer or null');
+        }
+        if (value.minLength !== null && value.maxLength !== null && value.minLength > value.maxLength) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'minLength cannot exceed maxLength');
+        }
+        if (!Number.isInteger(value.order) || value.order < 0) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'order must be a non-negative integer');
+        }
+    }
+    /**
+     * Validates a candidate answer against the question field type and constraints.
+     * Throws InvalidPreparationAnswerError when the answer is not acceptable.
+     */
+    validateAnswer(answer) {
+        const questionId = this.value.id;
+        const { fieldType } = this.value;
+        if (typeof answer !== 'string' || answer.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, String(answer), 'answer cannot be empty');
+        }
+        const trimmedAnswer = answer.trim();
+        if (PreparationQuestion.TEXT_FIELD_TYPES.includes(fieldType)) {
+            this.validateTextAnswer(trimmedAnswer);
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.NUMBER) {
+            if (!Number.isFinite(Number(trimmedAnswer))) {
+                throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, trimmedAnswer, 'answer must be a numeric value');
+            }
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.DATE) {
+            if (Number.isNaN(Date.parse(trimmedAnswer))) {
+                throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, trimmedAnswer, 'answer must be an ISO 8601 date');
+            }
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.SINGLE_CHOICE) {
+            if (!this.value.options.includes(trimmedAnswer)) {
+                throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, trimmedAnswer, `answer must be one of: ${this.value.options.join(', ')}`);
+            }
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.MULTIPLE_CHOICE) {
+            this.validateMultipleChoiceAnswer(trimmedAnswer);
+        }
+    }
+    validateTextAnswer(answer) {
+        if (this.value.minLength !== null && answer.length < this.value.minLength) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, `answer must have at least ${this.value.minLength} characters`);
+        }
+        if (this.value.maxLength !== null && answer.length > this.value.maxLength) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, `answer must have at most ${this.value.maxLength} characters`);
+        }
+    }
+    validateMultipleChoiceAnswer(answer) {
+        let selectedOptions;
+        try {
+            selectedOptions = JSON.parse(answer);
+        }
+        catch {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, 'answer must be a JSON array of selected options');
+        }
+        if (!Array.isArray(selectedOptions) || selectedOptions.length === 0) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, 'answer must be a non-empty JSON array of selected options');
+        }
+        const invalidOptions = selectedOptions.filter((option) => typeof option !== 'string' || !this.value.options.includes(option));
+        if (invalidOptions.length > 0) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, `selected options must be among: ${this.value.options.join(', ')}`);
+        }
+    }
+    getId() {
+        return this.value.id;
+    }
+    getOrigin() {
+        return this.value.origin;
+    }
+    getTargetSectionId() {
+        return this.value.targetSectionId;
+    }
+    getQuestionText() {
+        return this.value.questionText;
+    }
+    getFieldType() {
+        return this.value.fieldType;
+    }
+    getAiInstruction() {
+        return this.value.aiInstruction;
+    }
+    getOrder() {
+        return this.value.order;
+    }
+    isRequired() {
+        return this.value.isRequired;
+    }
+    isFromTemplate() {
+        return this.value.origin === QuestionnaireQuestionOrigin_1.QuestionnaireQuestionOrigin.TEMPLATE;
+    }
+    isCustom() {
+        return this.value.origin === QuestionnaireQuestionOrigin_1.QuestionnaireQuestionOrigin.CUSTOM;
+    }
+    toPrimitives() {
+        return {
+            id: this.value.id,
+            origin: this.value.origin,
+            targetSectionId: this.value.targetSectionId,
+            questionText: this.value.questionText,
+            helpText: this.value.helpText,
+            fieldType: this.value.fieldType,
+            options: [...this.value.options],
+            isRequired: this.value.isRequired,
+            aiInstruction: this.value.aiInstruction,
+            minLength: this.value.minLength,
+            maxLength: this.value.maxLength,
+            order: this.value.order,
+        };
+    }
+}
+exports.PreparationQuestion = PreparationQuestion;
+PreparationQuestion.PROPERTY_NAME = 'preparationQuestion';
+PreparationQuestion.EXPECTED_TYPE = 'PreparationQuestionPrimitives';
+PreparationQuestion.CHOICE_FIELD_TYPES = [
+    ClientInputFieldType_1.ClientInputFieldType.SINGLE_CHOICE,
+    ClientInputFieldType_1.ClientInputFieldType.MULTIPLE_CHOICE,
+];
+PreparationQuestion.TEXT_FIELD_TYPES = [
+    ClientInputFieldType_1.ClientInputFieldType.SHORT_TEXT,
+    ClientInputFieldType_1.ClientInputFieldType.LONG_TEXT,
+];

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/ReportPreparationQuestionnaireCompletion.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireCompletion = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+class ReportPreparationQuestionnaireCompletion extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportPreparationQuestionnaireCompletion.PROPERTY_NAME, ReportPreparationQuestionnaireCompletion.EXPECTED_TYPE);
+    }
+    static create(value) {
+        return new ReportPreparationQuestionnaireCompletion(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new ReportPreparationQuestionnaireCompletion(primitives, true);
+    }
+    isComplete() {
+        return this.value.answeredRequired >= this.value.totalRequired;
+    }
+    getAnsweredRequired() {
+        return this.value.answeredRequired;
+    }
+    getTotalRequired() {
+        return this.value.totalRequired;
+    }
+    getAnsweredTotal() {
+        return this.value.answeredTotal;
+    }
+    getTotalQuestions() {
+        return this.value.totalQuestions;
+    }
+    getRequiredCompletionPercentage() {
+        if (this.value.totalRequired === 0) {
+            return 100;
+        }
+        return Math.round((this.value.answeredRequired / this.value.totalRequired) * 100);
+    }
+    toPrimitives() {
+        return {
+            answeredRequired: this.value.answeredRequired,
+            totalRequired: this.value.totalRequired,
+            answeredTotal: this.value.answeredTotal,
+            totalQuestions: this.value.totalQuestions,
+        };
+    }
+}
+exports.ReportPreparationQuestionnaireCompletion = ReportPreparationQuestionnaireCompletion;
+ReportPreparationQuestionnaireCompletion.PROPERTY_NAME = 'completion';
+ReportPreparationQuestionnaireCompletion.EXPECTED_TYPE = 'ReportPreparationQuestionnaireCompletionPrimitives';

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/ReportPreparationQuestionnaireId.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireId = 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 ReportPreparationQuestionnaireId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+        // Validate that the prefix is valid for ReportPreparationQuestionnaire
+        ReportPreparationQuestionnaireId.guardAgainstInvalidPrefix(value);
+        return new ReportPreparationQuestionnaireId(value, false);
+    }
+    /**
+     * Validates that the UUID has a valid ReportPreparationQuestionnaire prefix
+     */
+    static guardAgainstInvalidPrefix(value) {
+        try {
+            const tempInstance = new ReportPreparationQuestionnaireId(value, true);
+            const prefix = tempInstance.extractPrefix();
+            if (ReportPreparationQuestionnaireId.VALID_PREFIXES.includes(prefix) === false) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportPreparationQuestionnaire', prefix, ReportPreparationQuestionnaireId.VALID_PREFIXES, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+            }
+        }
+        catch (error) {
+            if (error instanceof InvalidAggregatePrefixError_1.InvalidAggregatePrefixError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportPreparationQuestionnaire', 'UNKNOWN', ReportPreparationQuestionnaireId.VALID_PREFIXES, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+            }
+            throw error;
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ReportPreparationQuestionnaireId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ReportPreparationQuestionnaireId = ReportPreparationQuestionnaireId;
+ReportPreparationQuestionnaireId.PROPERTY_NAME = 'id';
+ReportPreparationQuestionnaireId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.RPT_PREPARATION_QUESTIONNAIRE,
+];

package/build/carbonbox/reporting/shared/domain/enums/ClientInputFieldType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientInputFieldType = void 0;
+/**
+ * Client input field type enumeration
+ * Defines how a CLIENT_INPUT block (questionnaire question) is captured and validated
+ */
+var ClientInputFieldType;
+(function (ClientInputFieldType) {
+    /**
+     * Short free text (single line)
+     */
+    ClientInputFieldType["SHORT_TEXT"] = "SHORT_TEXT";
+    /**
+     * Long free text (paragraphs). Subject to block minLength/maxLength
+     */
+    ClientInputFieldType["LONG_TEXT"] = "LONG_TEXT";
+    /**
+     * Numeric value (integer or decimal)
+     */
+    ClientInputFieldType["NUMBER"] = "NUMBER";
+    /**
+     * Date value (ISO 8601 string)
+     */
+    ClientInputFieldType["DATE"] = "DATE";
+    /**
+     * Exactly one option from the configured list
+     */
+    ClientInputFieldType["SINGLE_CHOICE"] = "SINGLE_CHOICE";
+    /**
+     * One or more options from the configured list (answer is a JSON array of option strings)
+     */
+    ClientInputFieldType["MULTIPLE_CHOICE"] = "MULTIPLE_CHOICE";
+})(ClientInputFieldType || (exports.ClientInputFieldType = ClientInputFieldType = {}));