@defra/forms-model 3.0.431 → 3.0.433

package/schemas/sorting-options-schema.json

@@ -0,0 +1,28 @@
+{
+  "type": "object",
+  "properties": {
+    "sortBy": {
+      "type": "string",
+      "description": "Field to sort results by",
+      "enum": [
+        "updatedAt",
+        "title"
+      ],
+      "title": "Sort By"
+    },
+    "order": {
+      "type": "string",
+      "description": "Sort order (ascending or descending)",
+      "enum": [
+        "asc",
+        "desc"
+      ],
+      "title": "Order"
+    }
+  },
+  "additionalProperties": false,
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Sorting Options Schema",
+  "description": "JSON Schema for validating Sorting Options Schema in Defra forms",
+  "$id": "@defra/forms-model/schemas/sorting-options-schema.json"
+}

package/schemas/written-answer-sub-schema.json

@@ -0,0 +1,12 @@
+{
+  "type": "string",
+  "description": "Subtype for written answer questions",
+  "enum": [
+    "TextField",
+    "MultilineTextField",
+    "NumberField"
+  ],
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Written Answer Sub Schema",
+  "$id": "@defra/forms-model/schemas/written-answer-sub-schema.json"
+}

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

@@ -479,7 +479,11 @@ const baseListItemSchema = Joi.object<Item>()
     condition: Joi.string()
       .allow('')
       .optional()
-      .description('Condition that determines if this item is shown')
+      .description('Condition that determines if this item is shown'),
+    hint: Joi.string()
+      .allow('')
+      .optional()
+      .description('Optional hint text to be shown on list item')
   })
 
 const stringListItemSchema = baseListItemSchema

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

@@ -124,6 +124,7 @@ export interface Item {
   description?: string
   conditional?: { components: ComponentDef[] }
   condition?: string
+  hint?: string
 }
 
 export interface List {

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

@@ -1,4 +1,4 @@
-import Joi from 'joi'
+import Joi, { type ArraySchema, type GetRuleOptions } from 'joi'
 
 import { ComponentType } from '~/src/components/enums.js'
 import {
@@ -291,7 +291,153 @@ export const classesSchema = Joi.string()
   .allow('')
   .description('Custom CSS classes to apply to the component')
 
+type GenericRuleOptions<K extends string, T> = Omit<GetRuleOptions, 'args'> & {
+  args: Record<K, T>
+}
+
+interface DSLSchema<TSchema = Record<string, unknown>[]>
+  extends ArraySchema<TSchema> {
+  rowSeparator: (rowSep: string | RegExp) => DSLSchema<TSchema>
+  row: (rowSep: string | RegExp) => DSLSchema<TSchema>
+  colSeparator: (colSep: string | RegExp) => DSLSchema<TSchema>
+  col: (colSep: string | RegExp) => DSLSchema<TSchema>
+  keys: (keys: string[]) => DSLSchema<TSchema>
+}
+
+interface CustomValidator extends Joi.Root {
+  dsv<TSchema>(): DSLSchema<TSchema>
+}
+
+export const customValidator = Joi.extend((joi: Joi.Root) => {
+  return {
+    type: 'dsv',
+    base: joi.array(),
+    messages: {
+      'dsv.invalid': 'Invalid parse string'
+    },
+    coerce: {
+      from: 'string',
+      method(value: string, helpers) {
+        try {
+          // Only called when prefs.convert is true
+          // Rules
+          const rowSeparatorRule = helpers.schema.$_getRule('rowSeparator') as
+            | undefined
+            | GenericRuleOptions<'rowSeparator', string | RegExp>
+          const colSeparatorRule = helpers.schema.$_getRule('colSeparator') as
+            | undefined
+            | GenericRuleOptions<'colSeparator', string | RegExp>
+          const keysRule = helpers.schema.$_getRule('keys') as
+            | undefined
+            | GenericRuleOptions<'keys', string[]>
+
+          // Rows
+          const rowSeparator = rowSeparatorRule?.args.rowSeparator ?? /\r?\n/
+          const rows = value
+            .split(rowSeparator)
+            .map((v) => v.trim())
+            .filter(Boolean)
+
+          // Columns
+          const colSeparator = colSeparatorRule?.args.colSeparator ?? ','
+          const keys = keysRule?.args.keys ?? ['key', 'value']
+
+          const coercedValue = rows.map((row) => {
+            return row
+              .split(colSeparator)
+              .reduce<Record<string, string>>((acc, col, idx) => {
+                return {
+                  ...acc,
+                  [keys[idx]]: col.trim()
+                }
+              }, {})
+          })
+          return { value: coercedValue }
+        } catch (_err) {
+          // eslint-disable-next-line no-console
+          console.error(_err)
+          return { value, errors: [helpers.error('dsv.invalid')] }
+        }
+      }
+    },
+    rules: {
+      rowSeparator: {
+        convert: true,
+        alias: 'row',
+        method(rowSeparator: string) {
+          return this.$_addRule({
+            name: 'rowSeparator',
+            args: { rowSeparator }
+          })
+        },
+        args: [
+          {
+            name: 'rowSeparator',
+            ref: true,
+            assert: (value) =>
+              typeof value === 'string' || value instanceof RegExp,
+            message: 'must be a string or regex'
+          }
+        ]
+      },
+      colSeparator: {
+        convert: true,
+        alias: 'col',
+        method(colSeparator: string) {
+          return this.$_addRule({
+            name: 'colSeparator',
+            args: { colSeparator }
+          })
+        },
+        args: [
+          {
+            name: 'colSeparator',
+            ref: true,
+            assert: (value) =>
+              typeof value === 'string' || value instanceof RegExp,
+            message: 'must be a string or regex'
+          }
+        ]
+      },
+      keys: {
+        convert: true,
+        method(keys: string[]) {
+          return this.$_addRule({ name: 'keys', args: { keys } })
+        },
+        args: [
+          {
+            name: 'keys',
+            ref: true,
+            assert: (value) =>
+              Array.isArray(value) && value.every((k) => typeof k === 'string'),
+            message: 'must be an array of strings'
+          }
+        ]
+      }
+    }
+  }
+}) as CustomValidator
+
+export const autoCompleteOptionsSchema = customValidator
+  .dsv<{ text: string; value: string }>()
+  .row(/\r?\n/)
+  .col(':')
+  .keys(['text', 'value'])
+  .items(
+    customValidator.object({
+      text: customValidator.string().min(1).disallow('').required(),
+      value: customValidator
+        .string()
+        .default((parent: { text: string; value?: string }) => parent.text)
+        .min(1)
+        .disallow('')
+    })
+  )
+  .min(1)
+  .required()
+
 export const questionDetailsFullSchema = {
+  autoCompleteOptionsSchema,
   classesSchema,
   documentTypesSchema,
   enhancedActionSchema,

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

@@ -1,4 +1,5 @@
 import { type ComponentDef } from '~/src/components/types.js'
+import { type Item } from '~/src/index.js'
 
 /**
  * Interface for `FormEditor` Joi schema
@@ -203,6 +204,8 @@ export interface FormEditor {
    * The value of the radio item
    */
   radioValue: string
+
+  autoCompleteOptions: Item[]
 }
 
 export type FormEditorInputPage = Pick<
@@ -242,6 +245,7 @@ export type FormEditorInputQuestion = Pick<
   | 'documentTypes'
   | 'imageTypes'
   | 'tabularDataTypes'
+  | 'autoCompleteOptions'
   | 'enhancedAction'
   | 'radioId'
   | 'radioLabel'
@@ -296,9 +300,14 @@ export interface GovukField {
   fieldset?: {
     legend?: { text?: string; isPageHeading?: boolean; classes?: string }
   }
-  value?: string | boolean | number | string[]
+  value?: string | boolean | number | string[] | Item[]
   classes?: string
-  label?: { text?: string; html?: string; classes?: string }
+  label?: {
+    text?: string
+    html?: string
+    classes?: string
+    isPageHeading?: boolean
+  }
   hint?: { text?: string; html?: string; classes?: string }
   items?: { text?: string; value?: string; checked?: boolean }[]
   rows?: number
@@ -316,9 +325,17 @@ export interface FormEditorGovukField {
   imageTypes?: GovukField
   tabularDataTypes?: GovukField
   radiosOrCheckboxes?: GovukField
+  autoCompleteOptions?: GovukField
   errorMessage?: { text: string }
 }
 
+export type FormEditorGovukFieldBase = Omit<
+  FormEditorGovukField,
+  'errorMessage'
+>
+
+export type FormEditorGovukFieldBaseKeys = keyof FormEditorGovukFieldBase
+
 export interface FormEditorCheckbox {
   text?: string
   hint?: {

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

@@ -1,7 +1,7 @@
 import Joi from 'joi'
 
+import { pageSchema } from '~/src/form/form-definition/index.js'
 import { type PatchPageFields } from '~/src/form/form-manager/types.js'
-import { pageSchema } from '~/src/index.js'
 
 export const patchPageSchema = Joi.object<PatchPageFields>()
   .keys({

package/scripts/generate-schemas.js

@@ -1,238 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import parse from 'joi-to-json'
-
-import { schemasDir } from './schema-modules/constants.js'
-import { ensureDirectoryExists, toTitleCase } from './schema-modules/utils.js'
-import { addTitles } from './schema-modules/title-processors.js'
-import { simplifyForDocs } from './schema-modules/schema-simplifiers.js'
-
-/**
- * Cleans the schemas directory by removing all existing JSON files
- * @returns {number} Number of files cleaned
- */
-export function cleanSchemaDirectory() {
-  console.log('Cleaning existing schema files...')
-  const existingFiles = fs
-    .readdirSync(schemasDir)
-    .filter((file) => file.endsWith('.json'))
-
-  for (const file of existingFiles) {
-    fs.unlinkSync(path.join(schemasDir, file))
-  }
-
-  console.log(`Cleaned ${existingFiles.length} existing schema files`)
-  return existingFiles.length
-}
-
-/**
- * Gets the schema map that defines which files should be generated
- * @returns {Record<string, string>} Schema map with filename-to-schema-export mapping
- */
-export function getSchemaMap() {
-  return {
-    // Form definition schemas
-    'form-definition-schema': 'formDefinitionSchema',
-    'form-definition-v2-payload-schema': 'formDefinitionV2PayloadSchema',
-
-    // Component schemas
-    'component-schema': 'componentSchema',
-    'component-schema-v2': 'componentSchemaV2',
-
-    // Page schemas
-    'page-schema': 'pageSchema',
-    'page-schema-v2': 'pageSchemaV2',
-    'page-schema-payload-v2': 'pageSchemaPayloadV2',
-
-    // List schemas
-    'list-schema': 'listSchema',
-    'list-schema-v2': 'listSchemaV2',
-
-    // Form metadata schemas
-    'form-metadata-schema': 'formMetadataSchema',
-    'form-metadata-author-schema': 'formMetadataAuthorSchema',
-    'form-metadata-input-schema': 'formMetadataInputSchema',
-    'form-metadata-state-schema': 'formMetadataStateSchema',
-
-    // Form metadata field schemas
-    'form-metadata-contact-schema': 'contactSchema',
-    'form-metadata-email-schema': 'emailSchema',
-    'form-metadata-online-schema': 'onlineSchema',
-
-    // Form editor schemas
-    'form-editor-input-page-schema': 'formEditorInputPageSchema',
-    'form-editor-input-check-answers-setting-schema':
-      'formEditorInputCheckAnswersSettingSchema',
-    'form-editor-input-question-schema': 'formEditorInputQuestionSchema',
-    'form-editor-input-page-settings-schema':
-      'formEditorInputPageSettingsSchema',
-
-    // Form editor field schemas
-    'page-type-schema': 'pageTypeSchema',
-    'question-type-schema': 'questionTypeSchema',
-    'question-type-full-schema': 'questionTypeFullSchema',
-    'written-answer-sub-schema': 'writtenAnswerSubSchema',
-    'date-sub-schema': 'dateSubSchema',
-
-    // Form submission schemas
-    'form-submit-payload-schema': 'formSubmitPayloadSchema',
-    'form-submit-record-schema': 'formSubmitRecordSchema',
-    'form-submit-recordset-schema': 'formSubmitRecordsetSchema',
-
-    // Form manager schemas
-    'patch-page-schema': 'patchPageSchema',
-
-    // Section schemas
-    'question-schema': 'questionSchema',
-
-    // Validation schemas
-    'min-schema': 'minSchema',
-    'max-schema': 'maxSchema',
-    'min-length-schema': 'minLengthSchema',
-    'max-length-schema': 'maxLengthSchema',
-    'max-future-schema': 'maxFutureSchema',
-    'max-past-schema': 'maxPastSchema',
-
-    // Common schemas
-    'search-options-schema': 'searchOptionsSchema',
-    'query-options-schema': 'queryOptionsSchema',
-    'pagination-options-schema': 'paginationOptionsSchema',
-    'sorting-options-schema': 'sortingOptionsSchema'
-  }
-}
-
-/**
- * Process a single schema and create its JSON Schema file
- * @param {string} fileName - Output file name
- * @param {string} schemaName - Schema export name in the model
- * @param {Record<string, unknown>} model - The loaded model containing schemas
- * @returns {boolean} Whether processing was successful
- */
-export function processSchema(fileName, schemaName, model) {
-  try {
-    /** @type {unknown} */
-    const joiSchema = model[schemaName]
-
-    if (!joiSchema) {
-      return false
-    }
-
-    /** @type {import('./schema-modules/types.js').SchemaObject} */
-    let jsonSchema = parse(
-      /** @type {Schema} */ (joiSchema),
-      'json',
-      {},
-      {
-        includeSchemaDialect: true,
-        includeDescriptions: true
-      }
-    )
-
-    const title = toTitleCase(fileName)
-    if (!jsonSchema.title) {
-      jsonSchema.title = title
-    }
-    if (!jsonSchema.description) {
-      jsonSchema.description = `JSON Schema for validating ${title} in Defra forms`
-    }
-
-    if (!jsonSchema.$id) {
-      jsonSchema.$id = `@defra/forms-model/schemas/${fileName}.json`
-    }
-
-    addTitles(jsonSchema, '')
-
-    jsonSchema = simplifyForDocs(jsonSchema, '')
-
-    const outputPath = path.join(schemasDir, `${fileName}.json`)
-    fs.writeFileSync(outputPath, JSON.stringify(jsonSchema, null, 2))
-    return true
-  } catch (/** @type {unknown} */ err) {
-    const error = err instanceof Error ? err : new Error(String(err))
-    console.error(`✗ Failed to process ${fileName}: ${error.message}`)
-    return false
-  }
-}
-
-/**
- * Loads the model with all schemas
- * @returns {Promise<Record<string, unknown>>} Loaded model
- */
-async function loadModelSchemas() {
-  console.log('Loading model schemas...')
-  return import('../dist/module/index.js')
-}
-
-/**
- * Processes all schemas and generates JSON Schema files
- * @param {Record<string, unknown>} model - The loaded model containing schemas
- * @returns {{ successCount: number, errorCount: number }} Object containing success and error counts
- */
-export function processAllSchemas(model) {
-  const schemaMap = getSchemaMap()
-  let successCount = 0
-  let errorCount = 0
-
-  for (const [fileName, schemaName] of Object.entries(schemaMap)) {
-    const success = processSchema(fileName, schemaName, model)
-
-    if (success) {
-      successCount++
-    } else {
-      errorCount++
-    }
-  }
-
-  return { successCount, errorCount }
-}
-
-/**
- * Generates schema files from Joi schemas
- */
-export async function generateSchemas() {
-  try {
-    const model = await loadModelSchemas()
-
-    ensureDirectoryExists(schemasDir)
-
-    cleanSchemaDirectory()
-
-    const { successCount, errorCount } = processAllSchemas(model)
-
-    console.log('\nSchema generation complete!')
-    console.log(`✓ Successfully generated ${successCount} schemas`)
-    if (errorCount > 0) {
-      console.log(`✗ Failed to generate ${errorCount} schemas`)
-    }
-
-    return { successCount, errorCount }
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err))
-    console.error(`\n✗ Schema generation failed: ${error.message}`)
-    throw error
-  }
-}
-
-// Only run when executed directly, not when imported as a module
-if (import.meta.url === `file://${process.argv[1]}`) {
-  ;(async () => {
-    try {
-      await generateSchemas()
-    } catch (err) {
-      console.error('Schema generation failed:', err)
-      throw err
-    }
-  })().catch((err) => {
-    console.error('Unhandled error:', err)
-    // eslint-disable-next-line no-process-exit
-    process.exit(1)
-  })
-}
-
-/**
- * @import { Schema } from 'joi'
- */
-
-/**
- * @import { SchemaObject } from './schema-modules/types.js'
- */

package/scripts/schema-modules/constants.js

@@ -1,39 +0,0 @@
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-export const currentDirname = path.dirname(fileURLToPath(import.meta.url))
-export const schemasDir = path.resolve(currentDirname, '../../schemas')
-
-/**
- * Condition type constants
- */
-export const CONDITION_TYPES = {
-  DEFINITION: 'Condition Definition',
-  REFERENCE: 'Condition Reference',
-  NESTED_GROUP: 'Nested Condition Group'
-}
-
-/**
- * Value type constants
- */
-export const VALUE_TYPES = {
-  STATIC: 'Static Value',
-  RELATIVE_DATE: 'Relative Date Value'
-}
-
-/**
- * Common description constants
- */
-export const DESCRIPTIONS = {
-  NESTED_CONDITION_GROUP:
-    'A nested group of conditions that allows building complex logical expressions with multiple levels.'
-}
-
-/**
- * Path segment constants
- */
-export const PATH_SEGMENTS = {
-  CONDITIONS: 'conditions',
-  ITEMS: 'items',
-  PROPERTIES: 'properties'
-}

package/scripts/schema-modules/schema-processors.js

@@ -1,109 +0,0 @@
-import { CONDITION_TYPES, DESCRIPTIONS, VALUE_TYPES } from './constants.js'
-
-/**
- * Fixes titles for condition items in anyOfTitles
- * @param {SchemaObject} obj - Schema to process
- * @returns {boolean} True if changes were made
- */
-export function fixConditionItems(obj) {
-  if (!obj.anyOfTitles?.includes('Conditions  Item Variant 3')) {
-    return false
-  }
-
-  const EXPECTED_CONDITION_TYPES_COUNT = 3
-
-  obj.anyOfTitles = [
-    CONDITION_TYPES.DEFINITION,
-    CONDITION_TYPES.REFERENCE,
-    CONDITION_TYPES.NESTED_GROUP
-  ]
-
-  if (obj.anyOf?.length === EXPECTED_CONDITION_TYPES_COUNT) {
-    if (obj.anyOf[0].properties?.field) {
-      obj.anyOf[0].title = CONDITION_TYPES.DEFINITION
-    }
-    if (obj.anyOf[1].properties?.conditionName) {
-      obj.anyOf[1].title = CONDITION_TYPES.REFERENCE
-    }
-    if (obj.anyOf[2].$ref?.includes('conditionGroupSchema')) {
-      obj.anyOf[2].title = CONDITION_TYPES.NESTED_GROUP
-      obj.anyOf[2].description = DESCRIPTIONS.NESTED_CONDITION_GROUP
-    }
-  }
-  return true
-}
-
-/**
- * Fixes titles for value objects in anyOfTitles
- * @param {SchemaObject} obj - Schema to process
- * @returns {boolean} True if changes were made
- */
-export function fixValueObjects(obj) {
-  if (
-    obj.anyOfTitles?.length !== 2 ||
-    obj.anyOfTitles[0] !== 'Value (object)' ||
-    obj.anyOfTitles[1] !== 'Value (object)'
-  ) {
-    return false
-  }
-
-  obj.anyOfTitles = [VALUE_TYPES.STATIC, VALUE_TYPES.RELATIVE_DATE]
-
-  if (obj.anyOf?.length === 2) {
-    if (obj.anyOf[0].properties?.value) {
-      obj.anyOf[0].title = VALUE_TYPES.STATIC
-    }
-    if (obj.anyOf[1].properties?.period) {
-      obj.anyOf[1].title = VALUE_TYPES.RELATIVE_DATE
-    }
-  }
-
-  return true
-}
-
-/**
- * Processes the anyOfTitles array in an object
- * @param {SchemaObject} obj - Schema to process
- */
-export function processAnyOfTitles(obj) {
-  if (!obj || typeof obj !== 'object') {
-    return
-  }
-
-  if (!Array.isArray(obj.anyOfTitles)) {
-    return
-  }
-
-  if (!fixConditionItems(obj)) {
-    fixValueObjects(obj)
-  }
-}
-
-/**
- * Recursively fixes all condition titles and anyOfTitles throughout the schema
- * regardless of their nesting level
- * @param {SchemaObject} obj - The schema or subschema to fix
- */
-export function fixConditionTitles(obj) {
-  if (!obj || typeof obj !== 'object') {
-    return
-  }
-
-  processAnyOfTitles(obj)
-
-  if (obj.title === 'Conditions  Item Variant 3') {
-    obj.title = CONDITION_TYPES.NESTED_GROUP
-    obj.description = DESCRIPTIONS.NESTED_CONDITION_GROUP
-  }
-
-  Object.keys(obj).forEach((key) => {
-    const value = obj[key]
-    if (value && typeof value === 'object') {
-      fixConditionTitles(value)
-    }
-  })
-}
-
-/**
- * @import { SchemaObject } from './types.js'
- */