@defra/forms-engine-plugin 1.0.0 → 1.0.2

package/src/server/plugins/engine/routes/file-upload.ts

@@ -0,0 +1,54 @@
+import { getErrorMessage } from '@defra/forms-model'
+import { type ResponseToolkit, type ServerRoute } from '@hapi/hapi'
+import Joi from 'joi'
+
+import { getUploadStatus } from '~/src/server/plugins/engine/services/uploadService.js'
+import {
+  type FormRequest,
+  type FormRequestRefs
+} from '~/src/server/routes/types.js'
+
+export async function getHandler(
+  request: FormRequest,
+  h: Pick<ResponseToolkit, 'response'>
+) {
+  const { uploadId } = request.params as unknown as {
+    uploadId: string
+  }
+  try {
+    const status = await getUploadStatus(uploadId)
+
+    if (!status) {
+      return h.response({ error: 'Status check failed' }).code(400)
+    }
+
+    return h.response(status)
+  } catch (error) {
+    const errMsg = getErrorMessage(error)
+    request.logger.error(
+      errMsg,
+      `[uploadStatusFailed] Upload status check failed for uploadId: ${uploadId} - ${errMsg}`
+    )
+    return h.response({ error: 'Status check error' }).code(500)
+  }
+}
+
+export function getRoutes(): ServerRoute<FormRequestRefs>[] {
+  return [
+    {
+      method: 'get',
+      path: '/upload-status/{uploadId}',
+      handler: getHandler,
+      options: {
+        plugins: {
+          crumb: false
+        },
+        validate: {
+          params: Joi.object().keys({
+            uploadId: Joi.string().guid().required()
+          })
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,187 @@
+import Boom from '@hapi/boom'
+import {
+  type ResponseObject,
+  type ResponseToolkit,
+  type Server
+} from '@hapi/hapi'
+import { isEqual } from 'date-fns'
+
+import { PREVIEW_PATH_PREFIX } from '~/src/server/constants.js'
+import {
+  checkEmailAddressForLiveFormSubmission,
+  checkFormStatus,
+  findPage,
+  getCacheService,
+  getPage,
+  getStartPath,
+  proceed
+} from '~/src/server/plugins/engine/helpers.js'
+import { FormModel } from '~/src/server/plugins/engine/models/index.js'
+import { type PageControllerClass } from '~/src/server/plugins/engine/pageControllers/helpers.js'
+import { generateUniqueReference } from '~/src/server/plugins/engine/referenceNumbers.js'
+import * as defaultServices from '~/src/server/plugins/engine/services/index.js'
+import {
+  type FormContext,
+  type PluginOptions
+} from '~/src/server/plugins/engine/types.js'
+import {
+  type FormRequest,
+  type FormRequestPayload
+} from '~/src/server/routes/types.js'
+
+export async function redirectOrMakeHandler(
+  request: FormRequest | FormRequestPayload,
+  h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+  makeHandler: (
+    page: PageControllerClass,
+    context: FormContext
+  ) => ResponseObject | Promise<ResponseObject>
+) {
+  const { app, params } = request
+  const { model } = app
+
+  if (!model) {
+    throw Boom.notFound(`No model found for /${params.path}`)
+  }
+
+  const cacheService = getCacheService(request.server)
+  const page = getPage(model, request)
+  let state = await page.getState(request)
+
+  if (!state.$$__referenceNumber) {
+    const prefix = model.def.metadata?.referenceNumberPrefix ?? ''
+
+    if (typeof prefix !== 'string') {
+      throw Boom.badImplementation(
+        'Reference number prefix must be a string or undefined'
+      )
+    }
+
+    const referenceNumber = generateUniqueReference(prefix)
+    state = await page.mergeState(request, state, {
+      $$__referenceNumber: referenceNumber
+    })
+  }
+
+  const flash = cacheService.getFlash(request)
+  const context = model.getFormContext(request, state, flash?.errors)
+  const relevantPath = page.getRelevantPath(request, context)
+  const summaryPath = page.getSummaryPath()
+
+  // Return handler for relevant pages or preview URL direct access
+  if (relevantPath.startsWith(page.path) || context.isForceAccess) {
+    return makeHandler(page, context)
+  }
+
+  // Redirect back to last relevant page
+  const redirectTo = findPage(model, relevantPath)
+
+  // Set the return URL unless an exit page
+  if (redirectTo?.next.length) {
+    request.query.returnUrl = page.getHref(summaryPath)
+  }
+
+  return proceed(request, h, page.getHref(relevantPath))
+}
+
+export function makeLoadFormPreHandler(server: Server, options: PluginOptions) {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- hapi types are wrong
+  const prefix = server.realm.modifiers.route.prefix ?? ''
+
+  const { services = defaultServices, controllers } = options
+
+  const { formsService } = services
+
+  async function handler(
+    request: FormRequest | FormRequestPayload,
+    h: ResponseToolkit
+  ) {
+    if (server.app.model) {
+      request.app.model = server.app.model
+
+      return h.continue
+    }
+
+    const { params } = request
+    const { slug } = params
+    const { isPreview, state: formState } = checkFormStatus(params)
+
+    // Get the form metadata using the `slug` param
+    const metadata = await formsService.getFormMetadata(slug)
+
+    const { id, [formState]: state } = metadata
+
+    // Check the metadata supports the requested state
+    if (!state) {
+      throw Boom.notFound(`No '${formState}' state for form metadata ${id}`)
+    }
+
+    // Cache the models based on id, state and whether
+    // it's a preview or not. There could be up to 3 models
+    // cached for a single form:
+    // "{id}_live_false" (live/live)
+    // "{id}_live_true" (live/preview)
+    // "{id}_draft_true" (draft/preview)
+    const key = `${id}_${formState}_${isPreview}`
+    let item = server.app.models.get(key)
+
+    if (!item || !isEqual(item.updatedAt, state.updatedAt)) {
+      server.logger.info(`Getting form definition ${id} (${slug}) ${formState}`)
+
+      // Get the form definition using the `id` from the metadata
+      const definition = await formsService.getFormDefinition(id, formState)
+
+      if (!definition) {
+        throw Boom.notFound(
+          `No definition found for form metadata ${id} (${slug}) ${formState}`
+        )
+      }
+
+      const emailAddress = metadata.notificationEmail ?? definition.outputEmail
+
+      checkEmailAddressForLiveFormSubmission(emailAddress, isPreview)
+
+      // Build the form model
+      server.logger.info(
+        `Building model for form definition ${id} (${slug}) ${formState}`
+      )
+
+      // Set up the basePath for the model
+      const basePath = (
+        isPreview
+          ? `${prefix}${PREVIEW_PATH_PREFIX}/${formState}/${slug}`
+          : `${prefix}/${slug}`
+      ).substring(1)
+
+      // Construct the form model
+      const model = new FormModel(
+        definition,
+        { basePath },
+        services,
+        controllers
+      )
+
+      // Create new item and add it to the item cache
+      item = { model, updatedAt: state.updatedAt }
+      server.app.models.set(key, item)
+    }
+
+    // Assign the model to the request data
+    // for use in the downstream handler
+    request.app.model = item.model
+
+    return h.continue
+  }
+
+  return handler
+}
+
+export function dispatchHandler(
+  request: FormRequest,
+  h: Pick<ResponseToolkit, 'redirect' | 'view'>
+) {
+  const { model } = request.app
+
+  const servicePath = model ? `/${model.basePath}` : ''
+  return proceed(request, h, `${servicePath}${getStartPath(model)}`)
+}

package/src/server/plugins/engine/routes/questions.ts

@@ -0,0 +1,208 @@
+import { hasFormComponents, slugSchema } from '@defra/forms-model'
+import Boom from '@hapi/boom'
+import {
+  type ResponseToolkit,
+  type RouteOptions,
+  type ServerRoute
+} from '@hapi/hapi'
+import Joi from 'joi'
+
+import {
+  normalisePath,
+  proceed,
+  redirectPath
+} from '~/src/server/plugins/engine/helpers.js'
+import { SummaryViewModel } from '~/src/server/plugins/engine/models/index.js'
+import { format } from '~/src/server/plugins/engine/outputFormatters/machine/v1.js'
+import { getFormSubmissionData } from '~/src/server/plugins/engine/pageControllers/SummaryPageController.js'
+import {
+  dispatchHandler,
+  redirectOrMakeHandler
+} from '~/src/server/plugins/engine/routes/index.js'
+import {
+  type FormRequest,
+  type FormRequestPayload,
+  type FormRequestPayloadRefs,
+  type FormRequestRefs
+} from '~/src/server/routes/types.js'
+import {
+  actionSchema,
+  crumbSchema,
+  itemIdSchema,
+  pathSchema,
+  stateSchema
+} from '~/src/server/schemas/index.js'
+import * as httpService from '~/src/server/services/httpService.js'
+
+function getHandler(
+  request: FormRequest,
+  h: Pick<ResponseToolkit, 'redirect' | 'view'>
+) {
+  const { params } = request
+
+  if (normalisePath(params.path) === '') {
+    return dispatchHandler(request, h)
+  }
+
+  return redirectOrMakeHandler(request, h, async (page, context) => {
+    // Check for a page onLoad HTTP event and if one exists,
+    // call it and assign the response to the context data
+    const { events } = page
+    const { model } = request.app
+
+    if (!model) {
+      throw Boom.notFound(`No model found for /${params.path}`)
+    }
+
+    if (events?.onLoad && events.onLoad.type === 'http') {
+      const { options } = events.onLoad
+      const { url } = options
+
+      // TODO: Update structured data POST payload with when helper
+      // is updated to removing the dependency on `SummaryViewModel` etc.
+      const viewModel = new SummaryViewModel(request, page, context)
+      const items = getFormSubmissionData(viewModel.context, viewModel.details)
+
+      // @ts-expect-error - function signature will be refactored in the next iteration of the formatter
+      const payload = format(items, model, undefined, undefined)
+
+      const { payload: response } = await httpService.postJson(url, {
+        payload
+      })
+
+      Object.assign(context.data, response)
+    }
+
+    return page.makeGetRouteHandler()(request, context, h)
+  })
+}
+
+function postHandler(
+  request: FormRequestPayload,
+  h: Pick<ResponseToolkit, 'redirect' | 'view'>
+) {
+  const { query } = request
+
+  return redirectOrMakeHandler(request, h, (page, context) => {
+    const { pageDef } = page
+    const { isForceAccess } = context
+
+    // Redirect to GET for preview URL direct access
+    if (isForceAccess && !hasFormComponents(pageDef)) {
+      return proceed(request, h, redirectPath(page.href, query))
+    }
+
+    return page.makePostRouteHandler()(request, context, h)
+  })
+}
+
+export function getRoutes(
+  getRouteOptions: RouteOptions<FormRequestRefs>,
+  postRouteOptions: RouteOptions<FormRequestPayloadRefs>
+): (ServerRoute<FormRequestRefs> | ServerRoute<FormRequestPayloadRefs>)[] {
+  return [
+    {
+      method: 'get',
+      path: '/{slug}',
+      handler: getHandler,
+      options: {
+        ...getRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            slug: slugSchema
+          })
+        }
+      }
+    },
+    {
+      method: 'get',
+      path: '/preview/{state}/{slug}',
+      handler: dispatchHandler,
+      options: {
+        ...getRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            state: stateSchema,
+            slug: slugSchema
+          })
+        }
+      }
+    },
+    {
+      method: 'get',
+      path: '/{slug}/{path}/{itemId?}',
+      handler: getHandler,
+      options: {
+        ...getRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema.optional()
+          })
+        }
+      }
+    },
+    {
+      method: 'get',
+      path: '/preview/{state}/{slug}/{path}/{itemId?}',
+      handler: getHandler,
+      options: {
+        ...getRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            state: stateSchema,
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema.optional()
+          })
+        }
+      }
+    },
+    {
+      method: 'post',
+      path: '/{slug}/{path}/{itemId?}',
+      handler: postHandler,
+      options: {
+        ...postRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema.optional()
+          }),
+          payload: Joi.object()
+            .keys({
+              crumb: crumbSchema,
+              action: actionSchema
+            })
+            .unknown(true)
+            .required()
+        }
+      }
+    },
+    {
+      method: 'post',
+      path: '/preview/{state}/{slug}/{path}/{itemId?}',
+      handler: postHandler,
+      options: {
+        ...postRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            state: stateSchema,
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema.optional()
+          }),
+          payload: Joi.object()
+            .keys({
+              crumb: crumbSchema,
+              action: actionSchema
+            })
+            .unknown(true)
+            .required()
+        }
+      }
+    }
+  ]
+}

package/src/server/plugins/engine/routes/repeaters/item-delete.ts

@@ -0,0 +1,157 @@
+import { slugSchema } from '@defra/forms-model'
+import Boom from '@hapi/boom'
+import {
+  type ResponseToolkit,
+  type RouteOptions,
+  type ServerRoute
+} from '@hapi/hapi'
+import Joi from 'joi'
+
+import { FileUploadPageController } from '~/src/server/plugins/engine/pageControllers/FileUploadPageController.js'
+import { RepeatPageController } from '~/src/server/plugins/engine/pageControllers/RepeatPageController.js'
+import { redirectOrMakeHandler } from '~/src/server/plugins/engine/routes/index.js'
+import {
+  type FormRequest,
+  type FormRequestPayload,
+  type FormRequestPayloadRefs,
+  type FormRequestRefs
+} from '~/src/server/routes/types.js'
+import {
+  actionSchema,
+  confirmSchema,
+  crumbSchema,
+  itemIdSchema,
+  pathSchema,
+  stateSchema
+} from '~/src/server/schemas/index.js'
+
+// Item delete GET route
+function getHandler(
+  request: FormRequest,
+  h: Pick<ResponseToolkit, 'redirect' | 'view'>
+) {
+  const { params } = request
+
+  return redirectOrMakeHandler(request, h, (page, context) => {
+    if (
+      !(
+        page instanceof RepeatPageController ||
+        page instanceof FileUploadPageController
+      )
+    ) {
+      throw Boom.notFound(`No page found for /${params.path}`)
+    }
+
+    return page.makeGetItemDeleteRouteHandler()(request, context, h)
+  })
+}
+
+function postHandler(
+  request: FormRequestPayload,
+  h: Pick<ResponseToolkit, 'redirect' | 'view'>
+) {
+  const { params } = request
+
+  return redirectOrMakeHandler(request, h, (page, context) => {
+    const { isForceAccess } = context
+
+    if (
+      isForceAccess ||
+      !(
+        page instanceof RepeatPageController ||
+        page instanceof FileUploadPageController
+      )
+    ) {
+      throw Boom.notFound(`No page found for /${params.path}`)
+    }
+
+    return page.makePostItemDeleteRouteHandler()(request, context, h)
+  })
+}
+
+export function getRoutes(
+  getRouteOptions: RouteOptions<FormRequestRefs>,
+  postRouteOptions: RouteOptions<FormRequestPayloadRefs>
+): (ServerRoute<FormRequestRefs> | ServerRoute<FormRequestPayloadRefs>)[] {
+  return [
+    {
+      method: 'get',
+      path: '/{slug}/{path}/{itemId}/confirm-delete',
+      handler: getHandler,
+      options: {
+        ...getRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema
+          })
+        }
+      }
+    },
+
+    {
+      method: 'get',
+      path: '/preview/{state}/{slug}/{path}/{itemId}/confirm-delete',
+      handler: getHandler,
+      options: {
+        ...getRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            state: stateSchema,
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema
+          })
+        }
+      }
+    },
+
+    {
+      method: 'post',
+      path: '/{slug}/{path}/{itemId}/confirm-delete',
+      handler: postHandler,
+      options: {
+        ...postRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema
+          }),
+          payload: Joi.object()
+            .keys({
+              crumb: crumbSchema,
+              action: actionSchema,
+              confirm: confirmSchema
+            })
+            .required()
+        }
+      }
+    },
+
+    {
+      method: 'post',
+      path: '/preview/{state}/{slug}/{path}/{itemId}/confirm-delete',
+      handler: postHandler,
+      options: {
+        ...postRouteOptions,
+        validate: {
+          params: Joi.object().keys({
+            state: stateSchema,
+            slug: slugSchema,
+            path: pathSchema,
+            itemId: itemIdSchema
+          }),
+          payload: Joi.object()
+            .keys({
+              crumb: crumbSchema,
+              action: actionSchema,
+              confirm: confirmSchema
+            })
+            .required()
+        }
+      }
+    }
+  ]
+}