fix: allow empty values for conditionally required fields

Author: g-saracca

src/datasets/domain/useCases/validators/BaseMetadataFieldValidator.ts

@@ -9,6 +9,7 @@ export interface DatasetMetadataFieldAndValueInfo {
   metadataBlockName: string
   metadataParentFieldKey?: string
   metadataFieldPosition?: number
+  allowEmptyForConditionallyRequiredField?: boolean
 }
 
 export abstract class BaseMetadataFieldValidator {

src/datasets/domain/useCases/validators/MetadataFieldValidator.ts

@@ -23,7 +23,10 @@ export class MetadataFieldValidator extends BaseMetadataFieldValidator {
       this.isEmptyString(metadataFieldValue) ||
       this.isEmptyArray(metadataFieldValue)
     ) {
-      if (metadataFieldInfo.isRequired) {
+      if (
+        metadataFieldInfo.isRequired &&
+        !datasetMetadataFieldAndValueInfo.allowEmptyForConditionallyRequiredField
+      ) {
         throw new EmptyFieldError(
           datasetMetadataFieldAndValueInfo.metadataFieldKey,
           datasetMetadataFieldAndValueInfo.metadataBlockName,

src/datasets/domain/useCases/validators/SingleMetadataFieldValidator.ts

@@ -136,6 +136,12 @@ export class SingleMetadataFieldValidator extends BaseMetadataFieldValidator {
         metadataFieldInfo.childMetadataFields as Record<string, MetadataFieldInfo>
       )[childMetadataFieldKey]
 
+      const allowEmptyForConditionallyRequiredField: boolean =
+        this.allowEmptyValueForConditionallyRequiredField(
+          datasetMetadataFieldAndValueInfo,
+          childMetadataFieldKey
+        )
+
       metadataFieldValidator.validate({
         metadataFieldInfo: childMetadataFieldInfo,
         metadataFieldKey: childMetadataFieldKey,
@@ -144,8 +150,58 @@ export class SingleMetadataFieldValidator extends BaseMetadataFieldValidator {
         )[childMetadataFieldKey],
         metadataBlockName: datasetMetadataFieldAndValueInfo.metadataBlockName,
         metadataParentFieldKey: datasetMetadataFieldAndValueInfo.metadataFieldKey,
-        metadataFieldPosition: datasetMetadataFieldAndValueInfo.metadataFieldPosition
+        metadataFieldPosition: datasetMetadataFieldAndValueInfo.metadataFieldPosition,
+        allowEmptyForConditionallyRequiredField
       })
     }
   }
+
+  /**
+   * This method allows setting empty values for conditionally required child fields.
+   * A child field is conditionally required if it is required and its parent field is not required.
+   * The childfield should be required only if any of its sibling fields has a value, otherwise it should be optional.
+   */
+
+  private allowEmptyValueForConditionallyRequiredField(
+    datasetMetadataFieldAndValueInfo: DatasetMetadataFieldAndValueInfo,
+    childMetadataFieldKey: string
+  ): boolean {
+    let result = false
+    const metadataFieldInfo = datasetMetadataFieldAndValueInfo.metadataFieldInfo
+
+    const childMetadataFieldKeys = Object.keys(
+      metadataFieldInfo.childMetadataFields as Record<string, MetadataFieldInfo>
+    )
+
+    const conditionallyRequiredChildFields: false | string[] =
+      !datasetMetadataFieldAndValueInfo.metadataFieldInfo.isRequired &&
+      childMetadataFieldKeys.filter(
+        (childMetadataFieldKey) =>
+          (metadataFieldInfo.childMetadataFields as Record<string, MetadataFieldInfo>)[
+            childMetadataFieldKey
+          ].isRequired
+      )
+    const hasConditionallyRequiredChildFields = Boolean(conditionallyRequiredChildFields)
+
+    if (
+      hasConditionallyRequiredChildFields &&
+      Object.values(conditionallyRequiredChildFields as string[]).includes(childMetadataFieldKey)
+    ) {
+      // At this point we know we are standing on a child field that is required and the parent field is not required
+
+      // Get the sibling fields and check if any of them has a value
+      const { [childMetadataFieldKey as keyof Record<string, string>]: _, ...siblingFields } =
+        datasetMetadataFieldAndValueInfo.metadataFieldValue as Record<string, string>
+
+      const siblingsValues = Object.values(siblingFields) as string[]
+
+      const isAnySiblingValuePresent = siblingsValues.some(
+        ([, value]) => value !== undefined && value !== ''
+      )
+
+      result = !isAnySiblingValuePresent
+    }
+
+    return result
+  }
 }

test/testHelpers/datasets/datasetHelper.ts

@@ -402,7 +402,8 @@ export const createDatasetDTO = (
   timePeriodCoveredStartValue?: DatasetMetadataFieldValueDTO,
   contributorTypeValue?: DatasetMetadataFieldValueDTO,
   license?: DatasetLicense,
-  dateOfCreationValue?: DatasetMetadataFieldValueDTO
+  dateOfCreationValue?: DatasetMetadataFieldValueDTO,
+  contributorNameValue?: string
 ): DatasetDTO => {
   const validTitle = 'test dataset'
   const validAuthorFieldValue = [
@@ -434,14 +435,15 @@ export const createDatasetDTO = (
           ...(dateOfCreationValue && {
             dateOfCreation: dateOfCreationValue
           }),
-          ...(contributorTypeValue && {
-            contributor: [
-              {
-                contributorName: 'Admin, Dataverse',
-                contributorType: contributorTypeValue as string
-              }
-            ]
-          })
+          ...(contributorTypeValue !== undefined &&
+            contributorNameValue !== undefined && {
+              contributor: [
+                {
+                  contributorName: contributorNameValue ?? 'Admin, Dataverse',
+                  contributorType: (contributorTypeValue as string | undefined) ?? 'Project Member'
+                }
+              ]
+            })
         }
       }
     ]

test/unit/datasets/DatasetResourceValidator.test.ts

@@ -213,7 +213,16 @@ describe('validate', () => {
   })
 
   test('should raise a controlled vocabulary error when a controlled vocabulary field has an invalid format', () => {
-    const testDataset = createDatasetDTO(undefined, undefined, undefined, undefined, 'Wrong Value')
+    const testDataset = createDatasetDTO(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      'Wrong Value',
+      undefined,
+      undefined,
+      'Some Value'
+    )
 
     expect.assertions(6)
     runValidateExpectingFieldValidationError(
@@ -235,4 +244,53 @@ describe('validate', () => {
     )
     expect(() => sut.validate(testDataset, testMetadataBlocks)).not.toThrow()
   })
+
+  test("should not raise an error when there is a compound field not required with a required childfield that has no value but siblings don't have value either", () => {
+    const testDataset = createDatasetDTO(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      '',
+      undefined,
+      undefined,
+      ''
+    )
+    expect(() => sut.validate(testDataset, testMetadataBlocks)).not.toThrow()
+  })
+
+  test('should not raise an error when there is a compound field not required with a required childfield that has value and some of the siblings has value', () => {
+    const testDataset = createDatasetDTO(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      'Project Member',
+      undefined,
+      undefined,
+      'Foo'
+    )
+    expect(() => sut.validate(testDataset, testMetadataBlocks)).not.toThrow()
+  })
+
+  test('should raise an error when there is a compound field not required with a required childfield that has no value but some of the siblings have', () => {
+    const testDataset = createDatasetDTO(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      'Project Member',
+      undefined,
+      undefined,
+      ''
+    )
+    expect.assertions(6)
+    runValidateExpectingFieldValidationError(
+      testDataset,
+      'contributorName',
+      'There was an error when validating the field contributorName from metadata block citation with parent field contributor in position 0. Reason was: The field should not be empty.',
+      'contributor',
+      0
+    )
+  })
 })