@defra/forms-engine-plugin 4.3.0 → 4.5.0

package/src/server/plugins/engine/components/helpers/geospatial.test.js

@@ -0,0 +1,55 @@
+import { validState } from '~/src/server/plugins/engine/components/helpers/__stubs__/geospatial.js'
+import { geospatialSchema } from '~/src/server/plugins/engine/components/helpers/geospatial.js'
+
+describe('Geospatial validation helpers', () => {
+  test('it should not have errors for valid geojson object', () => {
+    const result = geospatialSchema.validate(validState)
+
+    expect(result.error).toBeUndefined()
+    expect(result.value).toBeDefined()
+    expect(result.value).toHaveLength(4)
+  })
+
+  test('it should not have errors for valid geojson string', () => {
+    const result = geospatialSchema.validate(JSON.stringify(validState))
+
+    expect(result.error).toBeUndefined()
+    expect(result.value).toBeDefined()
+    expect(result.value).toHaveLength(4)
+  })
+
+  test('it should have errors for invalid json string', () => {
+    const result = geospatialSchema.validate('{')
+
+    expect(result.error).toBeDefined()
+    expect(result.value).toBe('{')
+  })
+
+  test('it should have errors for invalid geojson string', () => {
+    const result = geospatialSchema.validate('[')
+
+    expect(result.error).toBeDefined()
+    expect(result.value).toBe('[')
+  })
+
+  test('it should validate an empty array', () => {
+    const result = geospatialSchema.validate('[]')
+
+    expect(result.error).toBeUndefined()
+    expect(result.value).toEqual([])
+  })
+
+  test('it should not validate an empty object', () => {
+    const result = geospatialSchema.validate('{}')
+
+    expect(result.error).toBeDefined()
+    expect(result.value).toBeUndefined()
+  })
+
+  test('it should validate an empty string', () => {
+    const result = geospatialSchema.validate('')
+
+    expect(result.error).toBeDefined()
+    expect(result.value).toBeUndefined()
+  })
+})

package/src/server/plugins/engine/components/helpers/geospatial.ts

@@ -0,0 +1,93 @@
+import Bourne from '@hapi/bourne'
+import JoiBase from 'joi'
+
+import {
+  type Coordinates,
+  type Feature,
+  type FeatureProperties,
+  type Geometry
+} from '~/src/server/plugins/engine/types.js'
+
+const Joi = JoiBase.extend({
+  type: 'array',
+  base: JoiBase.array(),
+  messages: {
+    'object.invalidjson': '{{#label}} must be a valid json array string'
+  },
+  coerce: {
+    from: 'string',
+    method(value, helpers) {
+      if (typeof value === 'string') {
+        if (value.trim() === '') {
+          return {
+            value: undefined
+          }
+        }
+
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          return { value: Bourne.parse(value) }
+        } catch {
+          const result = {
+            value,
+            errors: [helpers.error('object.invalidjson')]
+          }
+
+          return result
+        }
+      } else {
+        return {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          value
+        }
+      }
+    }
+  }
+}) as JoiBase.Root
+
+const coordinatesSchema = Joi.array<Coordinates[]>()
+  .items(Joi.number().required(), Joi.number().required())
+  .required()
+
+const featurePropertiesSchema = Joi.object<FeatureProperties>()
+  .keys({
+    description: Joi.string().required(),
+    coordinateGridReference: Joi.string().required(),
+    centroidGridReference: Joi.string().required()
+  })
+  .required()
+
+const featureGeometrySchema = Joi.object<Geometry>().keys({
+  type: Joi.string().valid('Point', 'LineString', 'Polygon').required(),
+  coordinates: Joi.array()
+    .when('type', {
+      switch: [
+        { is: 'Point', then: coordinatesSchema },
+        {
+          is: 'LineString',
+          then: Joi.array().items(coordinatesSchema).min(2)
+        },
+        {
+          is: 'Polygon',
+          then: Joi.array().items(Joi.array().items(coordinatesSchema).min(3))
+        }
+      ]
+    })
+    .required()
+})
+
+const featureSchema = Joi.object<Feature>().keys({
+  id: Joi.string().required(),
+  type: Joi.string().valid('Feature').required(),
+  properties: featurePropertiesSchema,
+  geometry: featureGeometrySchema
+})
+
+export const geospatialSchema = Joi.array<Feature[]>()
+  .items(featureSchema)
+  .unique('id')
+  .required()
+
+/**
+ * @import { CustomHelpers } from 'joi'
+ */

package/src/server/plugins/engine/components/index.ts

@@ -30,3 +30,4 @@ export { NationalGridFieldNumberField } from '~/src/server/plugins/engine/compon
 export { LatLongField } from '~/src/server/plugins/engine/components/LatLongField.js'
 export { HiddenField } from '~/src/server/plugins/engine/components/HiddenField.js'
 export { PaymentField } from '~/src/server/plugins/engine/components/PaymentField.js'
+export { GeospatialField } from '~/src/server/plugins/engine/components/GeospatialField.js'

package/src/server/plugins/engine/pageControllers/FileUploadPageController.test.ts

@@ -795,6 +795,83 @@ describe('FileUploadPageController', () => {
           })
         })
 
+        it('collects all file errors into a single flash when multiple files fail', async () => {
+          const state = {
+            upload: {
+              [controller.path]: {
+                upload: {
+                  uploadId: 'some-id',
+                  uploadUrl: 'some-url',
+                  statusUrl: 'some-status-url'
+                },
+                files: []
+              }
+            }
+          } as unknown as FormSubmissionState
+
+          const errorStatus = {
+            uploadStatus: UploadStatus.ready,
+            form: {
+              file: [
+                {
+                  fileStatus: FileStatus.rejected,
+                  errorMessage: 'File too large'
+                },
+                {
+                  fileStatus: FileStatus.rejected,
+                  errorMessage: 'Invalid file type'
+                }
+              ]
+            }
+          }
+
+          jest
+            .spyOn(uploadService, 'getUploadStatus')
+            .mockResolvedValue(errorStatus as unknown as UploadStatusResponse)
+
+          jest.spyOn(tempItemSchema, 'validate').mockReturnValue({
+            value: {
+              status: errorStatus,
+              uploadId: 'some-id'
+            },
+            error: undefined
+          } as ValidationResult)
+
+          const testController = controller as TestableFileUploadPageController
+
+          const initiateSpy = jest.spyOn(
+            testController,
+            'initiateAndStoreNewUpload'
+          ) as jest.SpyInstance<
+            Promise<FormSubmissionState>,
+            [FormRequest, FormSubmissionState]
+          >
+
+          initiateSpy.mockResolvedValue(state)
+
+          const cacheService = getCacheService(request.server)
+
+          await controller['checkUploadStatus'](request, state, 1)
+
+          expect(cacheService.setFlash).toHaveBeenCalledTimes(1)
+          expect(cacheService.setFlash).toHaveBeenCalledWith(request, {
+            errors: [
+              {
+                path: ['fileUpload'],
+                href: '#fileUpload',
+                name: 'fileUpload',
+                text: 'File too large'
+              },
+              {
+                path: ['fileUpload'],
+                href: '#fileUpload',
+                name: 'fileUpload',
+                text: 'Invalid file type'
+              }
+            ]
+          })
+        })
+
         it('sets default error message when none provided', async () => {
           const state = {
             upload: {
@@ -859,7 +936,16 @@ describe('FileUploadPageController', () => {
 
     describe('file removal', () => {
       it('returns early when no file is removed', async () => {
-        const files = [{ uploadId: 'file1' }, { uploadId: 'file2' }]
+        const files = [
+          {
+            uploadId: 'upload1',
+            status: { form: { file: { fileId: 'file1' } } }
+          },
+          {
+            uploadId: 'upload2',
+            status: { form: { file: { fileId: 'file2' } } }
+          }
+        ]
 
         Object.defineProperty(request, 'params', {
           value: { itemId: 'nonexistent-file' },
@@ -892,7 +978,16 @@ describe('FileUploadPageController', () => {
       })
 
       it('merges state when file is removed', async () => {
-        const files = [{ uploadId: 'file1' }, { uploadId: 'file2' }]
+        const files = [
+          {
+            uploadId: 'upload1',
+            status: { form: { file: { fileId: 'file1' } } }
+          },
+          {
+            uploadId: 'upload2',
+            status: { form: { file: { fileId: 'file2' } } }
+          }
+        ]
 
         Object.defineProperty(request, 'params', {
           value: { itemId: 'file1' },
@@ -924,7 +1019,12 @@ describe('FileUploadPageController', () => {
         expect(mergeStateSpy).toHaveBeenCalledWith(request, state, {
           upload: {
             [controller.path]: {
-              files: [{ uploadId: 'file2' }],
+              files: [
+                {
+                  uploadId: 'upload2',
+                  status: { form: { file: { fileId: 'file2' } } }
+                }
+              ],
               upload: {
                 uploadId: 'upload-123',
                 uploadUrl: 'some-url',
@@ -1121,11 +1221,15 @@ describe('FileUploadPageController', () => {
             files: [
               {
                 uploadId: 'file-1',
-                status: { form: { file: { filename: 'file-1.pdf' } } }
+                status: {
+                  form: { file: { fileId: 'file-1', filename: 'file-1.pdf' } }
+                }
               },
               {
                 uploadId: 'file-2',
-                status: { form: { file: { filename: 'file-2.pdf' } } }
+                status: {
+                  form: { file: { fileId: 'file-2', filename: 'file-2.pdf' } }
+                }
               }
             ]
           }

package/src/server/plugins/engine/pageControllers/FileUploadPageController.ts

@@ -27,6 +27,7 @@ import {
   type AnyFormRequest,
   type FeaturedFormPageViewModel,
   type FileState,
+  type FileUpload,
   type FormContext,
   type FormContextRequest,
   type FormSubmissionError,
@@ -177,7 +178,7 @@ export class FileUploadPageController extends QuestionPageController {
       const files = this.getFilesFromState(state)
 
       const fileToRemove = files.find(
-        ({ uploadId }) => uploadId === params.itemId
+        ({ status }) => status.form.file.fileId === params.itemId
       )
 
       if (!fileToRemove) {
@@ -385,39 +386,86 @@ export class FileUploadPageController extends QuestionPageController {
 
     // Only add to files state if the file validates.
     // This secures against html tampering of the file input
-    // by adding a 'multiple' attribute or it being
-    // changed to a simple text field or similar.
+    // (e.g. changing it to a simple text field or similar).
     const validationResult = tempItemSchema.validate(
       { uploadId, status: statusResponse },
       { stripUnknown: true }
     )
     const error = validationResult.error
-    const fileState = validationResult.value as FileState
 
     if (error) {
       return this.initiateAndStoreNewUpload(request, state)
     }
 
-    const file = fileState.status.form.file
-    if (file.fileStatus === FileStatus.complete) {
-      files.unshift(prepareFileState(fileState))
+    // CDP returns form.file as a single object for one file,
+    // or an array for multiple files. The Joi schema normalises
+    // both to an array via .single().
+    await this.processUploadedFiles(
+      request,
+      state,
+      validationResult.value,
+      files,
+      upload
+    )
+
+    return this.initiateAndStoreNewUpload(request, state)
+  }
+
+  /**
+   * Processes the uploaded files from a CDP status response.
+   * Complete files are added to state, rejected/pending files
+   * have their error messages flashed.
+   * @param request - the hapi request
+   * @param state - the form state
+   * @param validatedItem - the Joi-validated upload item
+   * @param files - the current files array from state
+   * @param upload - the current upload initiation response
+   */
+  private async processUploadedFiles(
+    request: AnyFormRequest,
+    state: FormSubmissionState,
+    validatedItem: FileState,
+    files: FileState[],
+    upload: UploadInitiateResponse | undefined
+  ) {
+    const { uploadId } = validatedItem
+    const validatedStatus = validatedItem.status
+    const rawFile = validatedStatus.form.file as unknown as
+      | FileUpload
+      | FileUpload[]
+    const uploadedFiles = Array.isArray(rawFile) ? rawFile : [rawFile]
+
+    const allErrors: FormSubmissionError[] = []
+
+    for (const file of uploadedFiles) {
+      if (file.fileStatus === FileStatus.complete) {
+        const perFileState: FileState = {
+          uploadId,
+          status: {
+            ...validatedStatus,
+            form: { file }
+          } as FileState['status']
+        }
+        files.unshift(prepareFileState(perFileState))
+      } else {
+        // Collect the error for rejected/pending files.
+        const { fileUpload } = this
+        const name = fileUpload.name
+        const text = file.errorMessage ?? 'Unknown error'
+        allErrors.push({ path: [name], href: `#${name}`, name, text })
+      }
+    }
+
+    if (allErrors.length) {
+      const cacheService = getCacheService(request.server)
+      cacheService.setFlash(request, { errors: allErrors })
+    }
+
+    if (uploadedFiles.some((f) => f.fileStatus === FileStatus.complete)) {
       await this.mergeState(request, state, {
         upload: { [this.path]: { files, upload } }
       })
-    } else {
-      // Flash the error message.
-      const { fileUpload } = this
-      const cacheService = getCacheService(request.server)
-
-      const name = fileUpload.name
-      const text = file.errorMessage ?? 'Unknown error'
-      const errors: FormSubmissionError[] = [
-        { path: [name], href: `#${name}`, name, text }
-      ]
-      cacheService.setFlash(request, { errors })
     }
-
-    return this.initiateAndStoreNewUpload(request, state)
   }
 
   /**
@@ -438,7 +486,7 @@ export class FileUploadPageController extends QuestionPageController {
     const files = this.getFilesFromState(state)
 
     const filesUpdated = files.filter(
-      ({ uploadId }) => uploadId !== params.itemId
+      ({ status }) => status.form.file.fileId !== params.itemId
     )
 
     if (filesUpdated.length === files.length) {

package/src/server/plugins/engine/pageControllers/PageController.ts

@@ -37,6 +37,7 @@ export class PageController {
   name?: string
   model: FormModel
   pageDef: Page
+  id?: string
   title: string
   section?: Section
   condition?: ExecutableCondition
@@ -52,6 +53,7 @@ export class PageController {
     this.name = def.name
     this.model = model
     this.pageDef = pageDef
+    this.id = pageDef.id
     this.title = pageDef.title
     this.events = pageDef.events
 

package/src/server/plugins/engine/pageControllers/helpers/submission.test.ts

@@ -1,5 +1,7 @@
+import { GeospatialField } from '~/src/server/plugins/engine/components/GeospatialField.js'
 import { PaymentField } from '~/src/server/plugins/engine/components/PaymentField.js'
 import { TextField } from '~/src/server/plugins/engine/components/TextField.js'
+import { validSingleState } from '~/src/server/plugins/engine/components/helpers/__stubs__/geospatial.js'
 import { type DetailItemField } from '~/src/server/plugins/engine/models/types.js'
 import {
   buildMainRecords,
@@ -242,6 +244,34 @@ describe('Submission helpers', () => {
 
       expect(result).toEqual([])
     })
+
+    it('should JSON stringify GeospatialField', () => {
+      const mockGeospatialField = Object.create(GeospatialField.prototype)
+      mockGeospatialField.name = 'geospatial'
+
+      const items = [
+        {
+          name: 'geospatial',
+          label: 'Site features',
+          field: mockGeospatialField,
+          state: {
+            geospatial: validSingleState
+          } as FormSubmissionState
+        }
+      ] as unknown as DetailItemField[]
+
+      const result = buildMainRecords(items)
+
+      expect(result).toHaveLength(1)
+      expect(result).toEqual([
+        {
+          name: 'geospatial',
+          title: 'Site features',
+          value:
+            '[{"type":"Feature","properties":{"description":"My farm house","coordinateGridReference":"ST 00001","centroidGridReference":"ST 00001"},"geometry":{"coordinates":[-2.5723699109417737,53.2380485215034],"type":"Point"},"id":"a"}]'
+        }
+      ])
+    })
   })
 
   describe('buildRepeaterRecords', () => {
@@ -295,5 +325,49 @@ describe('Submission helpers', () => {
       expect(result[0].title).toBe('Addresses')
       expect(result[0].value).toHaveLength(1)
     })
+
+    it('should JSON stringify GeospatialField', () => {
+      const mockGeospatialField = Object.create(GeospatialField.prototype)
+      mockGeospatialField.name = 'geospatial'
+
+      const items = [
+        {
+          name: 'features',
+          label: 'Site features repeater',
+          subItems: [
+            [
+              {
+                name: 'geospatial',
+                label: 'Site features',
+                field: mockGeospatialField,
+                state: {
+                  geospatial: validSingleState
+                } as FormSubmissionState
+              } as unknown as DetailItemField[]
+            ]
+          ]
+        }
+      ] as unknown as DetailItemField[]
+
+      const result = buildRepeaterRecords(items)
+
+      expect(result).toHaveLength(1)
+      expect(result).toEqual([
+        {
+          name: 'features',
+          title: 'Site features repeater',
+          value: [
+            [
+              {
+                name: 'geospatial',
+                title: 'Site features',
+                value:
+                  '[{"type":"Feature","properties":{"description":"My farm house","coordinateGridReference":"ST 00001","centroidGridReference":"ST 00001"},"geometry":{"coordinates":[-2.5723699109417737,53.2380485215034],"type":"Point"},"id":"a"}]'
+              }
+            ]
+          ]
+        }
+      ])
+    })
   })
 })

package/src/server/plugins/engine/pageControllers/helpers/submission.ts

@@ -1,5 +1,6 @@
 import { type SubmitPayload } from '@defra/forms-model'
 
+import { GeospatialField } from '~/src/server/plugins/engine/components/GeospatialField.js'
 import { PaymentField } from '~/src/server/plugins/engine/components/PaymentField.js'
 import { getAnswer } from '~/src/server/plugins/engine/components/helpers/components.js'
 import {
@@ -32,6 +33,14 @@ export function buildMainRecords(items: DetailItem[]): SubmitRecord[] {
   for (const item of fieldItems) {
     if (item.field instanceof PaymentField) {
       records.push(...buildPaymentRecords(item))
+    } else if (item.field instanceof GeospatialField) {
+      // Stringify of GeoJSON is done here rather than inside `getContextValueFromState`
+      // so we don't incur the overhead of JSON.stringify on every request when building context
+      records.push({
+        name: item.name,
+        title: item.label,
+        value: JSON.stringify(item.field.getFormValueFromState(item.state))
+      })
     } else {
       records.push({
         name: item.name,
@@ -103,7 +112,14 @@ export function buildRepeaterRecords(
         detailItems.map((subItem) => ({
           name: subItem.name,
           title: subItem.label,
-          value: getAnswer(subItem.field, subItem.state, { format: 'data' })
+          value:
+            // Stringify of GeoJSON is done here rather than inside `getContextValueFromState`
+            // so we don't incur the overhead of JSON.stringify on every request when building context
+            subItem.field instanceof GeospatialField
+              ? JSON.stringify(
+                  subItem.field.getFormValueFromState(subItem.state)
+                )
+              : getAnswer(subItem.field, subItem.state, { format: 'data' })
         }))
       )
     }))

package/src/server/plugins/engine/pageControllers/validationOptions.ts

@@ -89,7 +89,9 @@ export const messages: LanguageMessagesExt = {
   'date.base': messageTemplate.dateFormat,
   'date.format': messageTemplate.dateFormat,
   'date.min': messageTemplate.dateMin,
-  'date.max': messageTemplate.dateMax
+  'date.max': messageTemplate.dateMax,
+
+  'object.invalidjson': messageTemplate.format
 }
 
 export const messagesPre: LanguageMessages =