@aehrc/smart-forms-renderer 0.21.2 → 0.22.0

package/src/utils/debounce.ts

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 
-export const DEBOUNCE_DURATION = 200;
+export const DEBOUNCE_DURATION = 150;
 
 export const AUTOCOMPLETE_DEBOUNCE_DURATION = 300;

package/src/utils/itemControl.ts

@@ -312,17 +312,30 @@ export function getTextDisplayFlyover(qItem: QuestionnaireItem): string {
 }
 
 /**
- * Get entry format if its extension is present
- * i.e. DD-MM-YYYY for dates, HH:MM for times etc.
+ * Get regex validation for items with regex extensions
  *
  * @author Sean Fong
  */
-export function getRegexValidation(qItem: QuestionnaireItem): RegexValidation | null {
+export function getRegexValidation(qItem: QuestionnaireItem): RegexValidation | undefined {
+  // Get regex expression from extension
+  const regexString = getRegexString(qItem);
+  if (regexString) {
+    return { expression: new RegExp(regexString), feedback: null };
+  }
+
+  // Get regex expression from item types if regex extensions not present
+  if (qItem.type === 'url') {
+    return { expression: new RegExp(/^\S*$/), feedback: 'URLs should not contain any whitespaces' };
+  }
+
+  return undefined;
+}
+
+export function getRegexString(qItem: QuestionnaireItem): string | null {
   const itemControl = qItem.extension?.find(
     (extension: Extension) => extension.url === 'http://hl7.org/fhir/StructureDefinition/regex'
   );
 
-  // Get regex expression from extension
   if (itemControl) {
     const extensionString = itemControl.valueString;
     if (extensionString) {
@@ -336,14 +349,9 @@ export function getRegexValidation(qItem: QuestionnaireItem): RegexValidation |
         regexString = extensionString;
       }
 
-      return { expression: new RegExp(regexString), feedback: null };
+      return regexString;
     }
   }
 
-  // Get regex expression from item types if regex extensions not present
-  if (qItem.type === 'url') {
-    return { expression: new RegExp(/^\S*$/), feedback: 'URLs should not contain any whitespaces' };
-  }
-
   return null;
 }

package/src/utils/validateQuestionnaire.ts

@@ -16,6 +16,8 @@
  */
 
 import type {
+  OperationOutcome,
+  OperationOutcomeIssue,
   Questionnaire,
   QuestionnaireItem,
   QuestionnaireResponse,
@@ -25,16 +27,55 @@ import type {
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 import type { EnableWhenExpressions, EnableWhenItems } from '../interfaces';
 import { isHiddenByEnableWhen } from './qItem';
-import { getRegexValidation } from './itemControl';
+import { getRegexString, getRegexValidation, getShortText } from './itemControl';
 import { structuredDataCapture } from 'fhir-sdc-helpers';
 import type { RegexValidation } from '../interfaces/regex.interface';
 
-export type InvalidType = 'regex' | 'minLength' | 'maxLength' | 'required';
+export enum ValidationResult {
+  unknown = 'unknown', // Unknown validation result
+  questionnaireNotFound = 'questionnaireNotFound', // The Questionnaire referenced by the QR was not found
+  questionnaireInactive = 'questionnaireInactive', // The QuestionnaireResponse.authored is outside the defined Questionnaire.effectivePeriod
+  questionnaireDraft = 'questionnaireDraft', // The Questionnaire.status was not active (draft)
+  questionnaireRetired = 'questionnaireRetired', // The Questionnaire.status was not active (retired)
+  invalidLinkId = 'invalidLinkId', // LinkId was not found in the questionnaire
+  invalidType = 'invalidType', // The Question Type should not be included in Response (or Definition) data
+  invalidAnswerType = 'invalidAnswerType', // The Answer does not conform to the Item.Type value required (also taking into consideration the fhir-type extension)
+  invalidAnswerOption = 'invalidAnswerOption', // A set of valid AnswerOptions were provided in the definition, but the value entered was not in the set
+  exclusiveAnswerOption = 'exclusiveAnswerOption', // The selected answer cannot be used in conjunction with other answers in this multi-select choice option
+  invalidUrlValue = 'invalidUrlValue', // URL value not formatted correctly as a UUID, or relative/absolute URL
+  groupShouldNotHaveAnswers = 'groupShouldNotHaveAnswers', // A Group Item should not use the `answer` child, it should use the `item` child
+  required = 'required', // There was no answer provided for a mandatory field
+  invariant = 'invariant', // A FHIRPATH validation expression did not pass
+  invariantExecution = 'invariantExecution', // A FHIRPATH validation expression failed to execute
+  repeats = 'repeats', // There was more than one answer provided for an item with repeats = false (which is the default)
+  minCount = 'minCount', // Minimum number of answers required for the item was not provided
+  maxCount = 'maxCount', // Number of answers provided exceeded the maximum permitted
+  minValue = 'minValue', // Minimum value constraint violated
+  maxValue = 'maxValue', // Maximum value constraint violated
+  maxDecimalPlaces = 'maxDecimalPlaces', // Maximum decimal places constraint violated
+  minLength = 'minLength', // Minimum length constraint violated
+  maxLength = 'maxLength', // Maximum length constraint violated
+  invalidNewLine = 'invalidNewLine', // 'string' type items cannot include newline characters, use a 'text' type for these
+  invalidCoding = 'invalidCoding', // Coding value not valid in the ValueSet
+  tsError = 'tsError', // Error accessing the Terminology Server
+  maxAttachmentSize = 'maxAttachmentSize', // Maximum attachment size constraint violated
+  attachmentSizeInconsistent = 'attachmentSizeInconsistent', // The Size of the attachment data and the reported size are different
+  invalidAttachmentType = 'invalidAttachmentType', // Attachment type constraint violated
+  displayAnswer = 'displayAnswer', // Display Items should not have an answer provided
+  regex = 'regex', // The answer does not match the provided regex expression
+  regexTimeout = 'regexTimeout', // Evaluating the regex expression timed out
+  invalidRefValue = 'invalidRefValue', // The Reference value was not a valid URL value (relative or absolute)
+  invalidRefResourceType = 'invalidRefResourceType', // The Reference value did not refer to a valid FHIR resource type
+  invalidRefResourceTypeRestriction = 'invalidRefResourceTypeRestriction', // The Reference value was not
+  minValueIncompatUnits = 'minValueIncompatUnits', // The units provided in the Quantity cannot be converted to the min Quantity units
+  maxValueIncompatUnits = 'maxValueIncompatUnits', // The units provided in the Quantity cannot be converted to the max Quantity units
+  invalidUnit = 'invalidUnit', // The unit provided was not among the list selected (or did not have all the properties defined in the unit coding)
+  invalidUnitValueSet = 'invalidUnitValueSet' // The unit provided was not in the provided valueset
+}
 
 interface ValidateQuestionnaireParams {
   questionnaire: Questionnaire;
   questionnaireResponse: QuestionnaireResponse;
-  invalidItems: Record<string, InvalidType>;
   enableWhenIsActivated: boolean;
   enableWhenItems: EnableWhenItems;
   enableWhenExpressions: EnableWhenExpressions;
@@ -48,11 +89,10 @@ interface ValidateQuestionnaireParams {
  */
 export function validateQuestionnaire(
   params: ValidateQuestionnaireParams
-): Record<string, InvalidType> {
+): Record<string, OperationOutcome> {
   const {
     questionnaire,
     questionnaireResponse,
-    invalidItems,
     enableWhenIsActivated,
     enableWhenItems,
     enableWhenExpressions
@@ -64,7 +104,7 @@ export function validateQuestionnaire(
     !questionnaireResponse.item ||
     questionnaireResponse.item.length === 0
   ) {
-    return invalidItems;
+    return {};
   }
 
   const qItemsIndexMap = mapQItemsIndex(questionnaire);
@@ -74,13 +114,19 @@ export function validateQuestionnaire(
     qItemsIndexMap
   );
 
+  const invalidItems: Record<string, OperationOutcome> = {};
+  let qrItemIndex = 0;
   for (const [index, topLevelQItem] of questionnaire.item.entries()) {
+    let repeatGroupInstances: number | null = null;
     let topLevelQRItem = topLevelQRItemsByIndex[index] ?? {
       linkId: topLevelQItem.linkId,
       text: topLevelQItem.text
     };
 
+    // topLevelQRItem being an array means this item is a repeat group
+    const isRepeatGroup = Array.isArray(topLevelQRItem);
     if (Array.isArray(topLevelQRItem)) {
+      repeatGroupInstances = topLevelQRItem.length;
       topLevelQRItem = {
         linkId: topLevelQItem.linkId,
         text: topLevelQItem.text,
@@ -88,14 +134,26 @@ export function validateQuestionnaire(
       };
     }
 
+    const locationExpression = `QuestionnaireResponse.item`;
     validateItemRecursive({
       qItem: topLevelQItem,
       qrItem: topLevelQRItem,
-      invalidItems: invalidItems,
+      qrItemIndex,
+      locationExpression,
+      invalidItems,
       enableWhenIsActivated,
       enableWhenItems,
-      enableWhenExpressions
+      enableWhenExpressions,
+      isRepeatGroupInstance: false
     });
+
+    // Increment qrItemIndex
+    // If its a repeat group, increment by the number of instances so qrItemIndex is correct once we reach the next item
+    if (isRepeatGroup && typeof repeatGroupInstances === 'number') {
+      qrItemIndex += repeatGroupInstances;
+    } else {
+      qrItemIndex++;
+    }
   }
 
   return invalidItems;
@@ -104,22 +162,29 @@ export function validateQuestionnaire(
 interface ValidateItemRecursiveParams {
   qItem: QuestionnaireItem;
   qrItem: QuestionnaireResponseItem;
-  invalidItems: Record<string, InvalidType>;
+  qrItemIndex: number;
+  locationExpression: string;
+  invalidItems: Record<string, OperationOutcome>;
   enableWhenIsActivated: boolean;
   enableWhenItems: EnableWhenItems;
   enableWhenExpressions: EnableWhenExpressions;
+  isRepeatGroupInstance: boolean;
 }
 
 function validateItemRecursive(params: ValidateItemRecursiveParams) {
   const {
     qItem,
     qrItem,
+    qrItemIndex,
     invalidItems,
     enableWhenIsActivated,
     enableWhenItems,
-    enableWhenExpressions
+    enableWhenExpressions,
+    isRepeatGroupInstance
   } = params;
+  let { locationExpression } = params;
 
+  // If item is hidden by enableWhen, skip validation
   if (
     isHiddenByEnableWhen({
       linkId: qItem.linkId,
@@ -131,11 +196,27 @@ function validateItemRecursive(params: ValidateItemRecursiveParams) {
     return;
   }
 
-  // FIXME repeat groups not working
+  // Validate repeat groups
   if (qItem.type === 'group' && qItem.repeats) {
-    return;
+    if (!isRepeatGroupInstance) {
+      validateRepeatGroupRecursive({
+        qItem,
+        qrItem,
+        qrItemIndex,
+        locationExpression,
+        invalidItems,
+        enableWhenIsActivated,
+        enableWhenItems,
+        enableWhenExpressions,
+        isRepeatGroupInstance: false
+      });
+      return;
+    }
   }
 
+  locationExpression = `${locationExpression}[${qrItemIndex}]`;
+
+  // Recursively validate groups with child items
   const childQItems = qItem.item;
   if (childQItems && childQItems.length > 0) {
     const childQrItems = qrItem?.item ?? [];
@@ -143,13 +224,23 @@ function validateItemRecursive(params: ValidateItemRecursiveParams) {
     const indexMap = mapQItemsIndex(qItem);
     const qrItemsByIndex = getQrItemsIndex(childQItems, childQrItems, indexMap);
 
+    // Check if group is required and has no answers
     if (qItem.type === 'group' && qItem.required) {
       if (!qrItem || qrItemsByIndex.length === 0) {
-        invalidItems[qItem.linkId] = 'required';
+        invalidItems[qItem.linkId] = createValidationOperationOutcome(
+          ValidationResult.required,
+          qItem,
+          qrItem,
+          null,
+          locationExpression,
+          invalidItems[qItem.linkId]?.issue
+        );
       }
     }
 
+    // Loop through child items
     for (const [index, childQItem] of childQItems.entries()) {
+      const childLocationExpression = `${locationExpression}.item`;
       let childQRItem = qrItemsByIndex[index] ?? {
         linkId: childQItem.linkId,
         text: childQItem.text
@@ -166,72 +257,114 @@ function validateItemRecursive(params: ValidateItemRecursiveParams) {
       validateItemRecursive({
         qItem: childQItem,
         qrItem: childQRItem,
+        qrItemIndex: index,
+        locationExpression: childLocationExpression,
         invalidItems: invalidItems,
         enableWhenIsActivated,
         enableWhenItems,
-        enableWhenExpressions
+        enableWhenExpressions,
+        isRepeatGroupInstance: false
       });
     }
   }
 
-  validateSingleItem(qItem, qrItem, invalidItems);
+  // Validate the item, note that this can be either a group or a non-group
+  validateSingleItem(qItem, qrItem, invalidItems, locationExpression);
+}
+
+function validateRepeatGroupRecursive(params: ValidateItemRecursiveParams) {
+  const {
+    qItem,
+    qrItem,
+    qrItemIndex,
+    locationExpression,
+    invalidItems,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  } = params;
+
+  if (!qItem.item || qItem.item.length === 0 || !qrItem.item || qrItem.item.length === 0) {
+    return;
+  }
+
+  // Get repeat group answers
+  const repeatGroupAnswers = qrItem.item ?? [];
+  for (const [index, repeatGroupAnswer] of repeatGroupAnswers.entries()) {
+    // Because the item is a repeat group and might have multiple answer instances, we need to increment the qItemIndex by the instanceIndex
+    const updatedQrItemIndex = qrItemIndex + index;
+
+    validateItemRecursive({
+      qItem: qItem,
+      qrItem: repeatGroupAnswer,
+      qrItemIndex: updatedQrItemIndex,
+      locationExpression: locationExpression,
+      invalidItems: invalidItems,
+      enableWhenIsActivated,
+      enableWhenItems,
+      enableWhenExpressions,
+      isRepeatGroupInstance: true
+    });
+  }
 }
 
 function validateSingleItem(
   qItem: QuestionnaireItem,
   qrItem: QuestionnaireResponseItem,
-  invalidItems: Record<string, InvalidType>
+  invalidItems: Record<string, OperationOutcome>,
+  locationExpression: string
 ) {
-  // Validate item.required
+  // Validate item.required first before every other validation check
   if (qItem.type !== 'display') {
     if (qItem.required && !qrItem.answer) {
-      invalidItems[qItem.linkId] = 'required';
+      invalidItems[qItem.linkId] = createValidationOperationOutcome(
+        ValidationResult.required,
+        qItem,
+        qrItem,
+        null,
+        locationExpression,
+        invalidItems[qItem.linkId]?.issue
+      );
+
       return invalidItems;
     }
   }
 
   // Validate regex, maxLength and minLength
   if (qrItem.answer) {
-    for (const answer of qrItem.answer) {
+    for (const [i, answer] of qrItem.answer.entries()) {
+      // Your code here, you can use 'index' and 'answer' as needed
       if (answer.valueString || answer.valueInteger || answer.valueDecimal || answer.valueUri) {
         const invalidInputType = getInputInvalidType(
           getInputInString(answer),
           getRegexValidation(qItem),
-          structuredDataCapture.getMinLength(qItem) ?? null,
-          qItem.maxLength ?? null
+          structuredDataCapture.getMinLength(qItem),
+          qItem.maxLength,
+          structuredDataCapture.getMaxDecimalPlaces(qItem)
         );
 
-        if (!invalidInputType) {
-          continue;
-        }
-
-        // Assign invalid type and break - stop checking other answers if is a repeat item
-        switch (invalidInputType) {
-          case 'regex':
-            invalidItems[qItem.linkId] = 'regex';
-            break;
-          case 'minLength':
-            invalidItems[qItem.linkId] = 'minLength';
-            break;
-          case 'maxLength':
-            invalidItems[qItem.linkId] = 'maxLength';
-            break;
+        if (invalidInputType) {
+          invalidItems[qItem.linkId] = createValidationOperationOutcome(
+            invalidInputType,
+            qItem,
+            qrItem,
+            i,
+            locationExpression,
+            invalidItems[qItem.linkId]?.issue
+          );
         }
-        break;
       }
     }
-
-    // Reached the end of the loop and no invalid input type found
-    // If a required item is filled, remove the required invalid type
-    if (qItem.required && invalidItems[qItem.linkId] && invalidItems[qItem.linkId] === 'required') {
-      delete invalidItems[qItem.linkId];
-    }
   }
 
   return invalidItems;
 }
 
-function getInputInString(answer: QuestionnaireResponseItemAnswer) {
+function getInputInString(answer?: QuestionnaireResponseItemAnswer) {
+  if (!answer) {
+    return '';
+  }
+
   if (answer.valueString) {
     return answer.valueString;
   } else if (answer.valueInteger) {
@@ -247,23 +380,191 @@ function getInputInString(answer: QuestionnaireResponseItemAnswer) {
 
 export function getInputInvalidType(
   input: string,
-  regexValidation: RegexValidation | null,
-  minLength: number | null,
-  maxLength: number | null
-): InvalidType | null {
+  regexValidation?: RegexValidation,
+  minLength?: number,
+  maxLength?: number,
+  maxDecimalPlaces?: number
+): ValidationResult | null {
   if (input) {
     if (regexValidation && !regexValidation.expression.test(input)) {
-      return 'regex';
+      return ValidationResult.regex;
     }
 
     if (minLength && input.length < minLength) {
-      return 'minLength';
+      return ValidationResult.minLength;
     }
 
     if (maxLength && input.length > maxLength) {
-      return 'maxLength';
+      return ValidationResult.maxLength;
+    }
+
+    if (maxDecimalPlaces) {
+      const decimalPlaces = input.split('.')[1]?.length ?? 0;
+      if (decimalPlaces > maxDecimalPlaces) {
+        return ValidationResult.maxDecimalPlaces;
+      }
     }
   }
 
   return null;
 }
+
+function createValidationOperationOutcome(
+  error: ValidationResult,
+  qItem: QuestionnaireItem,
+  qrItem: QuestionnaireResponseItem,
+  answerIndex: number | null,
+  locationExpression: string,
+  existingOperationOutcomeIssues: OperationOutcomeIssue[] = []
+): OperationOutcome {
+  return {
+    resourceType: 'OperationOutcome',
+    issue: existingOperationOutcomeIssues.concat(
+      createValidationOperationOutcomeIssue(error, qItem, qrItem, answerIndex, locationExpression)
+    )
+  };
+}
+
+function createValidationOperationOutcomeIssue(
+  error: ValidationResult,
+  qItem: QuestionnaireItem,
+  qrItem: QuestionnaireResponseItem,
+  answerIndex: number | null,
+  locationExpression: string
+): OperationOutcomeIssue {
+  const errorCodeSystem = 'http://fhir.forms-lab.com/CodeSystem/errors';
+  let detailsText = '';
+  let fieldDisplayText =
+    qrItem?.text ?? getShortText(qItem) ?? qItem?.text ?? qItem.linkId ?? qrItem.linkId;
+  if (!fieldDisplayText && fieldDisplayText.endsWith(':')) {
+    fieldDisplayText = fieldDisplayText.substring(0, fieldDisplayText.length - 1);
+  }
+
+  answerIndex = answerIndex ?? 0;
+
+  // create operationOutcomeIssue based on error
+  switch (error) {
+    case ValidationResult.required: {
+      if (qItem.type === 'group') {
+        detailsText = `${fieldDisplayText}: Mandatory group does not have answer(s)`;
+      } else {
+        detailsText = `${fieldDisplayText}: Mandatory field does not have an answer`;
+      }
+
+      return {
+        severity: 'error',
+        code: 'required',
+        expression: [locationExpression],
+        details: {
+          coding: [
+            {
+              system: errorCodeSystem,
+              code: error,
+              display: 'Required'
+            }
+          ],
+          text: detailsText
+        }
+      };
+    }
+
+    case ValidationResult.regex: {
+      detailsText = `${fieldDisplayText}: The value '${getInputInString(qrItem.answer?.[answerIndex])}' does not match the defined format.`;
+      if (structuredDataCapture.getEntryFormat(qItem)) {
+        detailsText += ` ${structuredDataCapture.getEntryFormat(qItem)}`;
+      }
+
+      return {
+        severity: 'error',
+        code: 'invalid',
+        expression: [locationExpression],
+        details: {
+          coding: [
+            {
+              system: errorCodeSystem,
+              code: error,
+              display: 'Invalid format'
+            }
+          ],
+          text: detailsText
+        },
+        diagnostics: getRegexString(qItem) ?? undefined
+      };
+    }
+
+    case ValidationResult.minLength: {
+      detailsText = `${fieldDisplayText}: Expected the minimum value ${structuredDataCapture.getMinLength(qItem)} characters, received '${getInputInString(qrItem.answer?.[answerIndex])}'`;
+      return {
+        severity: 'error',
+        code: 'business-rule',
+        expression: [locationExpression],
+        details: {
+          coding: [
+            {
+              system: errorCodeSystem,
+              code: error,
+              display: 'Too short'
+            }
+          ],
+          text: detailsText
+        }
+      };
+    }
+
+    case ValidationResult.maxLength: {
+      detailsText = `${fieldDisplayText}: Exceeded maximum of  ${qItem.maxLength} characters, received '${getInputInString(qrItem.answer?.[answerIndex])}'`;
+      return {
+        severity: 'error',
+        code: 'business-rule',
+        expression: [locationExpression],
+        details: {
+          coding: [
+            {
+              system: errorCodeSystem,
+              code: error,
+              display: 'Too long'
+            }
+          ],
+          text: detailsText
+        }
+      };
+    }
+
+    case ValidationResult.maxDecimalPlaces: {
+      detailsText = `${fieldDisplayText}: Exceeded maximum decimal places ${structuredDataCapture.getMaxDecimalPlaces(qItem)}, received '${getInputInString(qrItem.answer?.[answerIndex])}'`;
+      return {
+        severity: 'error',
+        code: 'business-rule',
+        expression: [locationExpression],
+        details: {
+          coding: [
+            {
+              system: errorCodeSystem,
+              code: error,
+              display: 'Too precise'
+            }
+          ],
+          text: detailsText
+        }
+      };
+    }
+
+    // mark unknown issues as fatal
+    default: {
+      return {
+        severity: 'error',
+        code: 'unknown',
+        expression: [locationExpression],
+        details: {
+          coding: [
+            {
+              system: errorCodeSystem,
+              code: 'unknown',
+              display: 'Unknown'
+            }
+          ]
+        }
+      };
+    }
+  }
+}