@defra/forms-model 3.0.247 → 3.0.248

package/src/conditions/condition-values.ts

@@ -1,15 +1,12 @@
 import { ConditionValueAbstract } from '~/src/conditions/condition-value-abstract.js'
 import { ConditionType, DateDirections } from '~/src/conditions/enums.js'
+import { type DateUnits } from '~/src/conditions/enums.js'
 import {
-  type DateTimeUnitValues,
-  type DateUnits,
-  type TimeUnits
+  type ConditionValueData,
+  type RelativeDateValueData
 } from '~/src/conditions/types.js'
 
-export class ConditionValue
-  extends ConditionValueAbstract
-  implements ConditionValueFrom
-{
+export class ConditionValue extends ConditionValueAbstract {
   type: ConditionType.Value
   value: string
   display: string
@@ -38,7 +35,7 @@ export class ConditionValue
     return this.value
   }
 
-  static from(obj: ConditionValue | ConditionValueFrom) {
+  static from(obj: ConditionValue | ConditionValueData) {
     return new ConditionValue(obj.value, obj.display)
   }
 
@@ -47,120 +44,65 @@ export class ConditionValue
   }
 }
 
-export interface ConditionValueFrom {
-  value: string
-  display?: string
-}
+export class RelativeDateValue extends ConditionValueAbstract {
+  type: ConditionType.RelativeDate
+  period
+  unit
+  direction
 
-export const dateUnits: DateUnits = {
-  YEARS: { display: 'year(s)', value: 'years' },
-  MONTHS: { display: 'month(s)', value: 'months' },
-  DAYS: { display: 'day(s)', value: 'days' }
-} as const
-
-export const timeUnits: TimeUnits = {
-  HOURS: { display: 'hour(s)', value: 'hours' },
-  MINUTES: { display: 'minute(s)', value: 'minutes' },
-  SECONDS: { display: 'second(s)', value: 'seconds' }
-} as const
-
-export const dateTimeUnits: DateUnits & TimeUnits = {
-  ...dateUnits,
-  ...timeUnits
-} as const
-
-export class RelativeTimeValue
-  extends ConditionValueAbstract
-  implements RelativeTimeValueFrom
-{
-  type: ConditionType.RelativeTime
-  timePeriod: string
-  timeUnit: DateTimeUnitValues
-  direction: DateDirections
-  timeOnly: boolean
-
-  constructor(
-    timePeriod: string,
-    timeUnit: DateTimeUnitValues,
-    direction: DateDirections,
-    timeOnly = false
-  ) {
-    if (typeof timePeriod !== 'string') {
-      throw new Error("RelativeTimeValue param 'timePeriod' must be a string")
-    }
-
-    if (
-      !Object.values(dateTimeUnits)
-        .map((unit) => unit.value)
-        .includes(timeUnit)
-    ) {
-      throw new Error(
-        "RelativeTimeValue param 'dateTimeUnits' must only include DateTimeUnitValues keys"
-      )
+  constructor(period: string, unit: DateUnits, direction: DateDirections) {
+    if (typeof period !== 'string') {
+      throw new Error("RelativeDateValue param 'period' must be a string")
     }
 
     if (!Object.values(DateDirections).includes(direction)) {
       throw new Error(
-        "RelativeTimeValue param 'direction' must be from enum DateDirections"
+        "RelativeDateValue param 'direction' must be from enum DateDirections"
       )
     }
 
     super()
 
-    this.type = ConditionType.RelativeTime
-    this.timePeriod = timePeriod
-    this.timeUnit = timeUnit
+    this.type = ConditionType.RelativeDate
+    this.period = period
+    this.unit = unit
     this.direction = direction
-    this.timeOnly = timeOnly
   }
 
   toPresentationString() {
-    return `${this.timePeriod} ${this.timeUnit} ${this.direction}`
+    return `${this.period} ${this.unit} ${this.direction}`
   }
 
   toExpression(): string {
-    const timePeriod =
+    const period =
       this.direction === DateDirections.PAST
-        ? 0 - Number(this.timePeriod)
-        : this.timePeriod
-    return this.timeOnly
-      ? `timeForComparison(${timePeriod}, '${this.timeUnit}')`
-      : `dateForComparison(${timePeriod}, '${this.timeUnit}')`
+        ? 0 - Number(this.period)
+        : this.period
+
+    return `dateForComparison(${period}, '${this.unit}')`
   }
 
-  static from(obj: RelativeTimeValue | RelativeTimeValueFrom) {
-    return new RelativeTimeValue(
-      obj.timePeriod,
-      obj.timeUnit,
-      obj.direction,
-      obj.timeOnly
-    )
+  static from(obj: RelativeDateValue | RelativeDateValueData) {
+    return new RelativeDateValue(obj.period, obj.unit, obj.direction)
   }
 
   clone() {
-    return RelativeTimeValue.from(this)
+    return RelativeDateValue.from(this)
   }
 }
 
-export interface RelativeTimeValueFrom {
-  timePeriod: string
-  timeUnit: DateTimeUnitValues
-  direction: DateDirections
-  timeOnly: boolean
-}
-
 export function conditionValueFrom(
   obj:
     | ConditionValue
-    | RelativeTimeValue
-    | ({ type: ConditionType.Value } & ConditionValueFrom)
-    | ({ type: ConditionType.RelativeTime } & RelativeTimeValueFrom)
+    | ConditionValueData
+    | RelativeDateValue
+    | RelativeDateValueData
 ) {
   switch (obj.type) {
     case ConditionType.Value:
       return ConditionValue.from(obj)
 
-    case ConditionType.RelativeTime:
-      return RelativeTimeValue.from(obj)
+    case ConditionType.RelativeDate:
+      return RelativeDateValue.from(obj)
   }
 }

package/src/conditions/condition.ts

@@ -4,19 +4,19 @@ import { getExpression } from '~/src/conditions/condition-operators.js'
 import { ConditionValueAbstract } from '~/src/conditions/condition-value-abstract.js'
 import {
   type ConditionValue,
-  type RelativeTimeValue
+  type RelativeDateValue
 } from '~/src/conditions/condition-values.js'
 import { type Coordinator, type OperatorName } from '~/src/conditions/enums.js'
 
 export class Condition extends ConditionAbstract {
-  field
-  operator
-  value
+  field: ConditionField
+  operator: OperatorName
+  value: ConditionValue | RelativeDateValue
 
   constructor(
     field?: ConditionField,
     operator?: OperatorName,
-    value?: ConditionValue | RelativeTimeValue,
+    value?: ConditionValue | RelativeDateValue,
     coordinator?: Coordinator
   ) {
     if (!(field instanceof ConditionField)) {

package/src/conditions/enums.ts

@@ -1,6 +1,6 @@
 export enum ConditionType {
   Value = 'Value',
-  RelativeTime = 'RelativeTime'
+  RelativeDate = 'RelativeDate'
 }
 
 export enum Coordinator {
@@ -38,3 +38,9 @@ export enum DateDirections {
   FUTURE = 'in the future',
   PAST = 'in the past'
 }
+
+export enum DateUnits {
+  YEARS = 'years',
+  MONTHS = 'months',
+  DAYS = 'days'
+}

package/src/conditions/helpers.ts

@@ -1,7 +1,15 @@
-export function toPresentationString(condition) {
+import { type ConditionGroup } from '~/src/conditions/condition-group.js'
+import { type ConditionRef } from '~/src/conditions/condition-ref.js'
+import { type Condition } from '~/src/conditions/condition.js'
+
+export function toPresentationString(
+  condition: Condition | ConditionRef | ConditionGroup
+) {
   return `${condition.coordinatorString()}${condition.conditionString()}`
 }
 
-export function toExpression(condition) {
+export function toExpression(
+  condition: Condition | ConditionRef | ConditionGroup
+) {
   return `${condition.coordinatorString()}${condition.conditionExpression()}`
 }

package/src/conditions/index.ts

@@ -2,16 +2,13 @@ export {
   getExpression,
   getOperatorConfig,
   getOperatorNames,
-  absoluteDateOrTimeOperatorNames,
-  relativeDateOrTimeOperatorNames
+  absoluteDateOperatorNames,
+  relativeDateOperatorNames
 } from '~/src/conditions/condition-operators.js'
 
 export {
-  timeUnits,
-  dateUnits,
-  dateTimeUnits,
   ConditionValue,
-  RelativeTimeValue,
+  RelativeDateValue,
   conditionValueFrom
 } from '~/src/conditions/condition-values.js'
 
@@ -27,6 +24,7 @@ export {
   ConditionType,
   Coordinator,
   DateDirections,
+  DateUnits,
   Operator,
   OperatorName
 } from '~/src/conditions/enums.js'

package/src/conditions/types.ts

@@ -1,40 +1,63 @@
-import { type ComponentDef } from '~/src/components/types.js'
-import { type ConditionGroup } from '~/src/conditions/condition-group.js'
-import { type ConditionRef } from '~/src/conditions/condition-ref.js'
+import {
+  type ComponentDef,
+  type ConditionalComponentType
+} from '~/src/components/types.js'
 import {
   type ConditionValue,
-  type RelativeTimeValue
+  type RelativeDateValue
 } from '~/src/conditions/condition-values.js'
-import { type Condition } from '~/src/conditions/condition.js'
-import { type OperatorName } from '~/src/conditions/enums.js'
+import {
+  type ConditionType,
+  type Coordinator,
+  type DateDirections,
+  type DateUnits,
+  type OperatorName
+} from '~/src/conditions/enums.js'
+
+export interface ConditionValueData {
+  type: ConditionType.Value
+  value: string
+  display: string
+}
+
+export interface RelativeDateValueData {
+  type: ConditionType.RelativeDate
+  period: string
+  unit: DateUnits
+  direction: DateDirections
+}
 
-export type ConditionsArray = (Condition | ConditionGroup | ConditionRef)[]
+export interface ConditionFieldData {
+  name: string
+  type: ConditionalComponentType
+  display: string
+}
 
-export type DateTimeUnitValues =
-  | 'years'
-  | 'months'
-  | 'days'
-  | 'hours'
-  | 'minutes'
-  | 'seconds'
+export interface ConditionData {
+  field: ConditionFieldData
+  operator: OperatorName
+  value: ConditionValueData | RelativeDateValueData
+  coordinator?: Coordinator
+}
+
+export interface ConditionRefData {
+  conditionName: string
+  conditionDisplayName: string
+  coordinator?: Coordinator
+}
 
-export interface DateUnits {
-  YEARS: { display: 'year(s)'; value: 'years' }
-  MONTHS: { display: 'month(s)'; value: 'months' }
-  DAYS: { display: 'day(s)'; value: 'days' }
+export interface ConditionGroupData {
+  conditions: (ConditionData | ConditionRefData | ConditionGroupData)[]
 }
 
-export interface TimeUnits {
-  HOURS: { display: 'hour(s)'; value: 'hours' }
-  MINUTES: { display: 'minute(s)'; value: 'minutes' }
-  SECONDS: { display: 'second(s)'; value: 'seconds' }
+export interface ConditionsModelData extends ConditionGroupData {
+  name: string
 }
 
 export interface OperatorDefinition {
-  units?: DateUnits | TimeUnits
   expression: (
     component: Pick<ComponentDef, 'type' | 'name'>,
-    conditionValue: ConditionValue | RelativeTimeValue
+    conditionValue: ConditionValue | RelativeDateValue
   ) => string
 }
 

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

@@ -3,8 +3,16 @@ import Joi from 'joi'
 import { type ComponentType } from '~/src/components/enums.js'
 import { type ComponentDef } from '~/src/components/types.js'
 import {
-  type ConditionRawData,
-  type ConditionWrapperValue,
+  type ConditionData,
+  type ConditionFieldData,
+  type ConditionGroupData,
+  type ConditionRefData,
+  type ConditionsModelData,
+  type ConditionValueData,
+  type RelativeDateValueData
+} from '~/src/conditions/types.js'
+import {
+  type ConditionWrapper,
   type FormDefinition,
   type Item,
   type Link,
@@ -14,95 +22,84 @@ import {
   type Section
 } from '~/src/form/form-definition/types.js'
 
-/**
- * If an optional key is added, CURRENT_VERSION does not need to be incremented.
- * Only breaking changes will require an increment, as well as a migration script.
- */
-export const CURRENT_VERSION = 2
-
 const sectionsSchema = Joi.object<Section>().keys({
   name: Joi.string().required(),
   title: Joi.string().required(),
   hideTitle: Joi.boolean().optional().default(false)
 })
 
-const conditionFieldSchema = Joi.object().keys({
+const conditionFieldSchema = Joi.object<ConditionFieldData>().keys({
   name: Joi.string().required(),
   type: Joi.string().required(),
   display: Joi.string().required()
 })
 
-const conditionValueSchema = Joi.object().keys({
+const conditionValueSchema = Joi.object<ConditionValueData>().keys({
   type: Joi.string().required(),
   value: Joi.string().required(),
   display: Joi.string().required()
 })
 
-const relativeTimeValueSchema = Joi.object().keys({
+const relativeDateValueSchema = Joi.object<RelativeDateValueData>().keys({
   type: Joi.string().required(),
-  timePeriod: Joi.string().required(),
-  timeUnit: Joi.string().required(),
-  direction: Joi.string().required(),
-  timeOnly: Joi.boolean().required()
+  period: Joi.string().required(),
+  unit: Joi.string().required(),
+  direction: Joi.string().required()
 })
 
-const conditionRefSchema = Joi.object().keys({
+const conditionRefSchema = Joi.object<ConditionRefData>().keys({
   conditionName: Joi.string().required(),
   conditionDisplayName: Joi.string().required(),
   coordinator: Joi.string().optional()
 })
 
-const conditionSchema = Joi.object().keys({
+const conditionSchema = Joi.object<ConditionData>().keys({
   field: conditionFieldSchema,
   operator: Joi.string().required(),
-  value: Joi.alternatives().try(conditionValueSchema, relativeTimeValueSchema),
+  value: Joi.alternatives().try(conditionValueSchema, relativeDateValueSchema),
   coordinator: Joi.string().optional()
 })
 
-const conditionGroupSchema = Joi.object().keys({
-  conditions: Joi.array().items(
-    Joi.alternatives().try(
-      conditionSchema,
-      conditionRefSchema,
-      Joi.any() /** Should be a joi.link('#conditionGroupSchema') */
-    )
-  )
-})
-
-const conditionsModelSchema = Joi.alternatives<ConditionWrapperValue>().try(
-  Joi.string(),
-  Joi.object().keys({
-    name: Joi.string().required(),
+const conditionGroupSchema = Joi.object<ConditionGroupData>()
+  .keys({
     conditions: Joi.array().items(
       Joi.alternatives().try(
         conditionSchema,
         conditionRefSchema,
-        conditionGroupSchema
+        Joi.link('#conditionGroupSchema')
       )
     )
   })
-)
+  .id('conditionGroupSchema')
 
-const conditionsSchema = Joi.object<ConditionRawData>().keys({
+const conditionsModelSchema = Joi.object<ConditionsModelData>().keys({
+  name: Joi.string().required(),
+  conditions: Joi.array().items(
+    Joi.alternatives().try(
+      conditionSchema,
+      conditionRefSchema,
+      conditionGroupSchema
+    )
+  )
+})
+
+const conditionWrapperSchema = Joi.object<ConditionWrapper>().keys({
   name: Joi.string().required(),
   displayName: Joi.string(),
   value: conditionsModelSchema.required()
 })
 
-const localisedString = Joi.alternatives().try(
-  Joi.object({ a: Joi.any() }).unknown(),
-  Joi.string().allow('')
-)
-
 export const componentSchema = Joi.object<ComponentDef>()
   .keys({
     type: Joi.string<ComponentType>().required(),
     name: Joi.string(),
-    title: localisedString,
-    hint: localisedString.optional(),
+    title: Joi.string().allow(''),
+    hint: Joi.string().allow('').optional(),
     options: Joi.object({
       rows: Joi.number().empty(''),
       maxWords: Joi.number().empty(''),
+      maxDaysInPast: Joi.number().empty(''),
+      maxDaysInFuture: Joi.number().empty(''),
       customValidationMessage: Joi.string().allow('')
     })
       .default({})
@@ -130,7 +127,7 @@ const nextSchema = Joi.object<Link>().keys({
  */
 const pageSchema = Joi.object<Page>().keys({
   path: Joi.string().required().disallow('/status'),
-  title: localisedString,
+  title: Joi.string().allow(''),
   section: Joi.string(),
   controller: Joi.string().optional(),
   components: Joi.array<ComponentDef>().items(componentSchema),
@@ -138,8 +135,8 @@ const pageSchema = Joi.object<Page>().keys({
 })
 
 const baseListItemSchema = Joi.object<Item>().keys({
-  text: localisedString,
-  description: localisedString.optional(),
+  text: Joi.string().allow(''),
+  description: Joi.string().allow('').optional(),
   conditional: Joi.object<Item['conditional']>()
     .keys({
       components: Joi.array<ComponentDef>()
@@ -147,9 +144,8 @@ const baseListItemSchema = Joi.object<Item>().keys({
         .items(componentSchema.unknown(true))
         .unique('name')
     })
-    .allow(null)
     .optional(),
-  condition: Joi.string().allow(null, '').optional()
+  condition: Joi.string().allow('').optional()
 })
 
 const stringListItemSchema = baseListItemSchema.append({
@@ -162,7 +158,7 @@ const numberListItemSchema = baseListItemSchema.append({
 
 const listSchema = Joi.object<List>().keys({
   name: Joi.string().required(),
-  title: localisedString,
+  title: Joi.string().allow(''),
   type: Joi.string().required().valid('string', 'number'),
   items: Joi.when('type', {
     is: 'string',
@@ -203,7 +199,7 @@ const phaseBannerSchema = Joi.object<PhaseBanner>().keys({
 export const formDefinitionSchema = Joi.object<FormDefinition>()
   .required()
   .keys({
-    name: localisedString.optional(),
+    name: Joi.string().allow('').optional(),
     feedback: feedbackSchema.optional(),
     startPage: Joi.string().optional(),
     pages: Joi.array<Page>().required().items(pageSchema).unique('path'),
@@ -211,8 +207,8 @@ export const formDefinitionSchema = Joi.object<FormDefinition>()
       .items(sectionsSchema)
       .unique('name')
       .required(),
-    conditions: Joi.array<ConditionRawData>()
-      .items(conditionsSchema)
+    conditions: Joi.array<ConditionWrapper>()
+      .items(conditionWrapperSchema)
       .unique('name'),
     lists: Joi.array<List>().items(listSchema).unique('name'),
     metadata: Joi.object({ a: Joi.any() }).unknown().optional(),

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

@@ -1,5 +1,5 @@
 import { type ComponentDef } from '~/src/components/types.js'
-import { type Condition } from '~/src/conditions/condition.js'
+import { type ConditionsModelData } from '~/src/conditions/types.js'
 import { formDefinitionSchema } from '~/src/form/form-definition/index.js'
 
 export interface Link {
@@ -27,8 +27,8 @@ export interface Item {
   text: string
   value: string | number | boolean
   description?: string
-  conditional?: { components: ComponentDef[] } | null
-  condition?: string | null
+  conditional?: { components: ComponentDef[] }
+  condition?: string
 }
 
 export interface List {
@@ -49,17 +49,10 @@ export interface PhaseBanner {
   feedbackUrl?: string
 }
 
-export type ConditionWrapperValue =
-  | string
-  | {
-      name: string
-      conditions: Condition[]
-    }
-
-export interface ConditionRawData {
+export interface ConditionWrapper {
   name: string
   displayName: string
-  value: ConditionWrapperValue
+  value: ConditionsModelData
 }
 
 /**
@@ -68,7 +61,7 @@ export interface ConditionRawData {
  */
 export interface FormDefinition {
   pages: Page[]
-  conditions: ConditionRawData[]
+  conditions: ConditionWrapper[]
   lists: List[]
   sections: Section[]
   startPage?: Page['path']

package/src/form/form-metadata/types.ts

@@ -113,3 +113,9 @@ export type FormMetadataInput = Pick<
   FormMetadata,
   'title' | 'organisation' | 'teamName' | 'teamEmail'
 >
+
+export interface FormResponse {
+  id: FormMetadata['id']
+  slug: FormMetadata['slug']
+  status: string
+}