@defra/forms-model 3.0.479 → 3.0.480

package/src/conditions/migration.ts

@@ -4,17 +4,14 @@ import {
 } from '~/src/components/types.js'
 import { ConditionType, type Coordinator } from '~/src/conditions/enums.js'
 import {
-  type ConditionBooleanValueDataV2,
   type ConditionData,
   type ConditionDataV2,
-  type ConditionDateValueDataV2,
   type ConditionListItemRefValueDataV2,
-  type ConditionNumberValueDataV2,
   type ConditionRefData,
   type ConditionRefDataV2,
-  type ConditionStringValueDataV2,
   type ConditionValueData,
-  type ConditionValueDataV2
+  type RelativeDateValueData,
+  type RelativeDateValueDataV2
 } from '~/src/conditions/types.js'
 import {
   type ConditionWrapper,
@@ -22,34 +19,28 @@ import {
   type List
 } from '~/src/form/form-definition/types.js'
 
-export function isConditionListItemRefValueDataV2(
-  value: ConditionValueDataV2
-): value is ConditionListItemRefValueDataV2 {
-  return value.type === ConditionType.ListItemRef
+export function isConditionListItemRefValueDataV2(condition: ConditionDataV2) {
+  return condition.type === ConditionType.ListItemRef
 }
 
-export function isConditionStringValueDataV2(
-  value: ConditionValueDataV2
-): value is ConditionStringValueDataV2 {
-  return value.type === ConditionType.StringValue
+export function isConditionStringValueDataV2(condition: ConditionDataV2) {
+  return condition.type === ConditionType.StringValue
 }
 
-export function isConditionBooleanValueDataV2(
-  value: ConditionValueDataV2
-): value is ConditionBooleanValueDataV2 {
-  return value.type === ConditionType.BooleanValue
+export function isConditionBooleanValueDataV2(condition: ConditionDataV2) {
+  return condition.type === ConditionType.BooleanValue
 }
 
-export function isConditionNumberValueDataV2(
-  value: ConditionValueDataV2
-): value is ConditionNumberValueDataV2 {
-  return value.type === ConditionType.NumberValue
+export function isConditionNumberValueDataV2(condition: ConditionDataV2) {
+  return condition.type === ConditionType.NumberValue
 }
 
-export function isConditionDateValueDataV2(
-  value: ConditionValueDataV2
-): value is ConditionDateValueDataV2 {
-  return value.type === ConditionType.DateValue
+export function isConditionDateValueDataV2(condition: ConditionDataV2) {
+  return condition.type === ConditionType.DateValue
+}
+
+export function isConditionRelativeDateValueDataV2(condition: ConditionDataV2) {
+  return condition.type === ConditionType.RelativeDate
 }
 
 function getListItem(model: RuntimeFormModel, listId: string, itemId: string) {
@@ -69,9 +60,10 @@ function getListItem(model: RuntimeFormModel, listId: string, itemId: string) {
 }
 
 function createConditionValueDataFromListItemRefV2(
-  value: ConditionListItemRefValueDataV2,
+  condition: ConditionDataV2,
   model: RuntimeFormModel
 ): ConditionValueData {
+  const value = condition.value as ConditionListItemRefValueDataV2
   const refValue = getListItem(model, value.listId, value.itemId)
 
   return {
@@ -82,44 +74,56 @@ function createConditionValueDataFromListItemRefV2(
 }
 
 function createConditionValueDataFromStringOrDateValueDataV2(
-  value: ConditionStringValueDataV2 | ConditionDateValueDataV2
+  condition: ConditionDataV2
 ): ConditionValueData {
   return {
     type: ConditionType.Value,
-    value: value.value,
-    display: value.value
+    value: condition.value as string,
+    display: condition.value as string
   }
 }
 
 function createConditionValueDataFromStringValueDataV2(
-  value: ConditionStringValueDataV2
+  condition: ConditionDataV2
 ): ConditionValueData {
-  return createConditionValueDataFromStringOrDateValueDataV2(value)
+  return createConditionValueDataFromStringOrDateValueDataV2(condition)
 }
 
 function createConditionValueDataFromDateValueDataV2(
-  value: ConditionDateValueDataV2
+  condition: ConditionDataV2
 ): ConditionValueData {
-  return createConditionValueDataFromStringOrDateValueDataV2(value)
+  return createConditionValueDataFromStringOrDateValueDataV2(condition)
+}
+
+function createConditionValueDataFromRelativeDateValueDataV2(
+  condition: ConditionDataV2
+): RelativeDateValueData {
+  const value = condition.value as RelativeDateValueDataV2
+  return {
+    type: ConditionType.RelativeDate,
+    period: value.period.toString(),
+    unit: value.unit,
+    direction: value.direction
+  }
 }
 
 function createConditionValueDataFromNumberValueDataV2(
-  value: ConditionNumberValueDataV2
+  condition: ConditionDataV2
 ): ConditionValueData {
   return {
     type: ConditionType.Value,
-    value: value.value.toString(),
-    display: value.value.toString()
+    value: (condition.value as number).toString(),
+    display: (condition.value as number).toString()
   }
 }
 
 function createConditionValueDataFromBooleanValueDataV2(
-  value: ConditionBooleanValueDataV2
+  condition: ConditionDataV2
 ): ConditionValueData {
   return {
     type: ConditionType.Value,
-    value: value.value.toString(),
-    display: value.value ? 'Yes' : 'No'
+    value: (condition.value as boolean).toString(),
+    display: (condition.value as boolean) ? 'Yes' : 'No'
   }
 }
 
@@ -141,18 +145,20 @@ function convertConditionDataV2(
   }
 
   let newValue
-  if (isConditionListItemRefValueDataV2(condition.value)) {
-    newValue = createConditionValueDataFromListItemRefV2(condition.value, model)
-  } else if (isConditionStringValueDataV2(condition.value)) {
-    newValue = createConditionValueDataFromStringValueDataV2(condition.value)
-  } else if (isConditionBooleanValueDataV2(condition.value)) {
-    newValue = createConditionValueDataFromBooleanValueDataV2(condition.value)
-  } else if (isConditionNumberValueDataV2(condition.value)) {
-    newValue = createConditionValueDataFromNumberValueDataV2(condition.value)
-  } else if (isConditionDateValueDataV2(condition.value)) {
-    newValue = createConditionValueDataFromDateValueDataV2(condition.value)
+  if (isConditionListItemRefValueDataV2(condition)) {
+    newValue = createConditionValueDataFromListItemRefV2(condition, model)
+  } else if (isConditionStringValueDataV2(condition)) {
+    newValue = createConditionValueDataFromStringValueDataV2(condition)
+  } else if (isConditionBooleanValueDataV2(condition)) {
+    newValue = createConditionValueDataFromBooleanValueDataV2(condition)
+  } else if (isConditionNumberValueDataV2(condition)) {
+    newValue = createConditionValueDataFromNumberValueDataV2(condition)
+  } else if (isConditionDateValueDataV2(condition)) {
+    newValue = createConditionValueDataFromDateValueDataV2(condition)
+  } else if (isConditionRelativeDateValueDataV2(condition)) {
+    newValue = createConditionValueDataFromRelativeDateValueDataV2(condition)
   } else {
-    newValue = condition.value
+    throw Error('Unsupported condition type')
   }
 
   return {

package/src/conditions/types.ts

@@ -17,35 +17,20 @@ export interface ConditionValueData {
   display: string
 }
 
-export interface ConditionStringValueDataV2 {
-  type: ConditionType.StringValue
-  value: string
-}
-
-export interface ConditionBooleanValueDataV2 {
-  type: ConditionType.BooleanValue
-  value: boolean
-}
-
-export interface ConditionNumberValueDataV2 {
-  type: ConditionType.NumberValue
-  value: number
-}
-
-export interface ConditionDateValueDataV2 {
-  type: ConditionType.DateValue
-  value: string
+export interface RelativeDateValueData {
+  type: ConditionType.RelativeDate
+  period: string
+  unit: DateUnits
+  direction: DateDirections
 }
 
 export interface ConditionListItemRefValueDataV2 {
-  type: ConditionType.ListItemRef
   listId: string
   itemId: string
 }
 
-export interface RelativeDateValueData {
-  type: ConditionType.RelativeDate
-  period: string
+export interface RelativeDateValueDataV2 {
+  period: number
   unit: DateUnits
   direction: DateDirections
 }
@@ -65,16 +50,16 @@ export interface ConditionData {
 
 export type ConditionValueDataV2 =
   | ConditionListItemRefValueDataV2
-  | ConditionStringValueDataV2
-  | ConditionBooleanValueDataV2
-  | ConditionNumberValueDataV2
-  | ConditionDateValueDataV2
-  | RelativeDateValueData
+  | RelativeDateValueDataV2
+  | string
+  | boolean
+  | number
 
 export interface ConditionDataV2 {
   id: string
   componentId: string
   operator: OperatorName
+  type: ConditionType
   value: ConditionValueDataV2
 }
 

package/src/form/form-definition/index.ts

@@ -8,22 +8,20 @@ import {
   type ContentComponentsDef,
   type FileUploadFieldComponent
 } from '~/src/components/types.js'
+import { ConditionType, OperatorName } from '~/src/conditions/enums.js'
 import {
-  type ConditionBooleanValueDataV2,
   type ConditionData,
   type ConditionDataV2,
-  type ConditionDateValueDataV2,
   type ConditionFieldData,
   type ConditionGroupData,
   type ConditionGroupDataV2,
   type ConditionListItemRefValueDataV2,
-  type ConditionNumberValueDataV2,
   type ConditionRefData,
   type ConditionRefDataV2,
-  type ConditionStringValueDataV2,
   type ConditionValueData,
   type ConditionsModelData,
-  type RelativeDateValueData
+  type RelativeDateValueData,
+  type RelativeDateValueDataV2
 } from '~/src/conditions/types.js'
 import {
   SchemaVersion,
@@ -139,73 +137,10 @@ const conditionValueSchema = Joi.object<ConditionValueData>()
       .description('Human-readable version of the value for display purposes')
   })
 
-const conditionStringValueDataSchemaV2 =
-  Joi.object<ConditionStringValueDataV2>()
-    .description('String value specification for a condition')
-    .keys({
-      type: Joi.string()
-        .trim()
-        .valid('StringValue')
-        .required()
-        .description('Type of the condition value, should be "StringValue"'),
-      value: Joi.string()
-        .trim()
-        .required()
-        .description('The actual value to compare against')
-    })
-
-const conditionBooleanValueDataSchemaV2 =
-  Joi.object<ConditionBooleanValueDataV2>()
-    .description('Boolean value specification for a condition')
-    .keys({
-      type: Joi.string()
-        .trim()
-        .valid('BooleanValue')
-        .required()
-        .description('Type of the condition value, should be "BooleanValue"'),
-      value: Joi.boolean()
-        .required()
-        .description('The actual value to compare against')
-    })
-
-const conditionNumberValueDataSchemaV2 =
-  Joi.object<ConditionNumberValueDataV2>()
-    .description('Number value specification for a condition')
-    .keys({
-      type: Joi.string()
-        .trim()
-        .valid('NumberValue')
-        .required()
-        .description('Type of the condition value, should be "NumberValue"'),
-      value: Joi.number()
-        .required()
-        .description('The actual value to compare against')
-    })
-
-const conditionDateValueDataSchemaV2 = Joi.object<ConditionDateValueDataV2>()
-  .description('Date value specification for a condition')
-  .keys({
-    type: Joi.string()
-      .trim()
-      .valid('DateValue')
-      .required()
-      .description('Type of the condition value, should be "DateValue"'),
-    value: Joi.date()
-      .format('YYYY-MM-DD')
-      .raw()
-      .required()
-      .description('The actual value to compare against')
-  })
-
 const conditionListItemRefDataSchemaV2 =
   Joi.object<ConditionListItemRefValueDataV2>()
     .description('List item ref specification for a condition')
     .keys({
-      type: Joi.string()
-        .trim()
-        .valid('ListItemRef')
-        .required()
-        .description('Type of the condition value, should be "ListItemRef"'),
       listId: Joi.string()
         .trim()
         .required()
@@ -224,14 +159,27 @@ const conditionListItemRefDataSchemaV2 =
         .description('The id of the list item')
     })
 
-const relativeDateValueDataSchema = Joi.object<RelativeDateValueData>()
+const relativeDateValueDataSchemaV2 = Joi.object<RelativeDateValueDataV2>()
   .description('Relative date specification for date-based conditions')
   .keys({
-    type: Joi.string()
+    period: Joi.number()
+      .integer()
+      .positive()
+      .required()
+      .description('Numeric amount of the time period, as a string'),
+    unit: Joi.string()
+      .trim()
+      .required()
+      .description('Time unit (e.g. days, weeks, months, years)'),
+    direction: Joi.string()
       .trim()
-      .valid('RelativeDate')
       .required()
-      .description('Type of the condition value, should be "RelativeDate"'),
+      .description('Temporal direction, either "past" or "future"')
+  })
+
+const relativeDateValueDataSchema = Joi.object<RelativeDateValueData>()
+  .description('Relative date specification for date-based conditions')
+  .keys({
     period: Joi.string()
       .trim()
       .required()
@@ -320,18 +268,36 @@ export const conditionDataSchemaV2 = Joi.object<ConditionDataV2>()
       ),
     operator: Joi.string()
       .trim()
+      .valid(...Object.values(OperatorName))
       .required()
       .description('Comparison operator (equals, greaterThan, contains, etc.)'),
-    value: Joi.alternatives()
-      .try(
-        conditionStringValueDataSchemaV2,
-        conditionBooleanValueDataSchemaV2,
-        conditionNumberValueDataSchemaV2,
-        conditionDateValueDataSchemaV2,
-        conditionListItemRefDataSchemaV2,
-        relativeDateValueDataSchema
-      )
+    type: Joi.string()
+      .trim()
+      .valid(...Object.values(ConditionType))
       .required()
+      .description('Type of the condition value'),
+    value: Joi.any()
+      .required()
+      .description('The actual value to compare against')
+      .when('type', {
+        switch: [
+          { is: ConditionType.BooleanValue, then: Joi.boolean() },
+          { is: ConditionType.StringValue, then: Joi.string() },
+          { is: ConditionType.NumberValue, then: Joi.number() },
+          {
+            is: ConditionType.DateValue,
+            then: Joi.date().format('YYYY-MM-DD').raw()
+          },
+          {
+            is: ConditionType.ListItemRef,
+            then: conditionListItemRefDataSchemaV2
+          },
+          {
+            is: ConditionType.RelativeDate,
+            then: relativeDateValueDataSchemaV2
+          }
+        ]
+      })
       .description(
         'Value to compare the field against, either fixed or relative date'
       )