@defra/forms-engine-plugin 1.0.1 → 1.0.2

package/src/server/plugins/engine/plugin.ts

@@ -1,132 +1,38 @@
-import { existsSync } from 'fs'
-import { dirname, join } from 'path'
-import { fileURLToPath } from 'url'
-
-import {
-  getErrorMessage,
-  hasFormComponents,
-  slugSchema
-} from '@defra/forms-model'
-import Boom from '@hapi/boom'
 import {
+  type Lifecycle,
   type Plugin,
-  type PluginProperties,
-  type Request,
-  type ResponseObject,
-  type ResponseToolkit,
   type RouteOptions,
-  type Server
+  type Server,
+  type ServerRoute
 } from '@hapi/hapi'
-import vision from '@hapi/vision'
-import { isEqual } from 'date-fns'
-import Joi from 'joi'
-import nunjucks, { type Environment } from 'nunjucks'
-import resolvePkg from 'resolve'
 
-import { PREVIEW_PATH_PREFIX } from '~/src/server/constants.js'
-import {
-  checkEmailAddressForLiveFormSubmission,
-  checkFormStatus,
-  findPage,
-  getCacheService,
-  getPage,
-  getStartPath,
-  normalisePath,
-  proceed,
-  redirectPath
-} from '~/src/server/plugins/engine/helpers.js'
-import {
-  VIEW_PATH,
-  context,
-  prepareNunjucksEnvironment
-} from '~/src/server/plugins/engine/index.js'
+import { type FormModel } from '~/src/server/plugins/engine/models/index.js'
+import { getRoutes as getFileUploadStatusRoutes } from '~/src/server/plugins/engine/routes/file-upload.js'
+import { makeLoadFormPreHandler } from '~/src/server/plugins/engine/routes/index.js'
+import { getRoutes as getQuestionRoutes } from '~/src/server/plugins/engine/routes/questions.js'
+import { getRoutes as getRepeaterItemDeleteRoutes } from '~/src/server/plugins/engine/routes/repeaters/item-delete.js'
+import { getRoutes as getRepeaterSummaryRoutes } from '~/src/server/plugins/engine/routes/repeaters/summary.js'
+import { type PluginOptions } from '~/src/server/plugins/engine/types.js'
+import { registerVision } from '~/src/server/plugins/engine/vision.js'
 import {
-  FormModel,
-  SummaryViewModel
-} from '~/src/server/plugins/engine/models/index.js'
-import { format } from '~/src/server/plugins/engine/outputFormatters/machine/v1.js'
-import { FileUploadPageController } from '~/src/server/plugins/engine/pageControllers/FileUploadPageController.js'
-import { type PageController } from '~/src/server/plugins/engine/pageControllers/PageController.js'
-import { RepeatPageController } from '~/src/server/plugins/engine/pageControllers/RepeatPageController.js'
-import { getFormSubmissionData } from '~/src/server/plugins/engine/pageControllers/SummaryPageController.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 { getUploadStatus } from '~/src/server/plugins/engine/services/uploadService.js'
-import {
-  type FilterFunction,
-  type FormContext,
-  type FormSubmissionState
-} from '~/src/server/plugins/engine/types.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'
-import * as httpService from '~/src/server/services/httpService.js'
 import { CacheService } from '~/src/server/services/index.js'
-import { type Services } from '~/src/server/types.js'
-
-export function findPackageRoot() {
-  const currentFileName = fileURLToPath(import.meta.url)
-  const currentDirectoryName = dirname(currentFileName)
-
-  let dir = currentDirectoryName
-  while (dir !== '/') {
-    if (existsSync(join(dir, 'package.json'))) {
-      return dir
-    }
-    dir = dirname(dir)
-  }
-
-  throw new Error('package.json not found in parent directories')
-}
-export interface PluginOptions {
-  model?: FormModel
-  services?: Services
-  controllers?: Record<string, typeof PageController>
-  cacheName?: string
-  keyGenerator?: (request: Request | FormRequest | FormRequestPayload) => string
-  sessionHydrator?: (
-    request: Request | FormRequest | FormRequestPayload
-  ) => Promise<FormSubmissionState>
-  filters?: Record<string, FilterFunction>
-  pluginPath?: string
-  nunjucks: {
-    baseLayoutPath: string
-    paths: string[]
-  }
-  viewContext: PluginProperties['forms-engine-plugin']['viewContext']
-}
 
 export const plugin = {
   name: '@defra/forms-engine-plugin',
   dependencies: ['@hapi/crumb', '@hapi/yar', 'hapi-pino'],
   multiple: true,
   async register(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 {
       model,
-      services = defaultServices,
-      controllers,
       cacheName,
       keyGenerator,
       sessionHydrator,
-      filters,
       nunjucks: nunjucksOptions,
       viewContext
     } = options
-    const { formsService } = services
     const cacheService = new CacheService({
       server,
       cacheName,
@@ -136,60 +42,7 @@ export const plugin = {
       }
     })
 
-    const packageRoot = findPackageRoot()
-    const govukFrontendPath = dirname(
-      resolvePkg.sync('govuk-frontend/package.json')
-    )
-
-    const viewPathResolved = join(packageRoot, VIEW_PATH)
-
-    const paths = [
-      ...nunjucksOptions.paths,
-      viewPathResolved,
-      join(govukFrontendPath, 'dist')
-    ]
-
-    await server.register({
-      plugin: vision,
-      options: {
-        engines: {
-          html: {
-            compile: (
-              path: string,
-              compileOptions: { environment: Environment }
-            ) => {
-              const template = nunjucks.compile(
-                path,
-                compileOptions.environment
-              )
-
-              return (context: object | undefined) => {
-                return template.render(context)
-              }
-            },
-            prepare: (
-              options: EngineConfigurationObject,
-              next: (err?: Error) => void
-            ) => {
-              // Nunjucks also needs an additional path configuration
-              // to use the templates and macros from `govuk-frontend`
-              const environment = nunjucks.configure(paths)
-
-              // Applies custom filters and globals for nunjucks
-              // that are required by the `forms-engine-plugin`
-              prepareNunjucksEnvironment(environment, filters)
-
-              options.compileOptions.environment = environment
-
-              next()
-            }
-          }
-        },
-        path: paths,
-        // Provides global context used with all templates
-        context
-      }
-    })
+    await registerVision(server, options)
 
     server.expose('baseLayoutPath', nunjucksOptions.baseLayoutPath)
     server.expose('viewContext', viewContext)
@@ -202,634 +55,36 @@ export const plugin = {
     const itemCache = new Map<string, { model: FormModel; updatedAt: Date }>()
     server.app.models = itemCache
 
-    const loadFormPreHandler = async (
-      request: FormRequest | FormRequestPayload,
-      h: Pick<ResponseToolkit, 'continue'>
-    ) => {
-      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 = itemCache.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 }
-        itemCache.set(key, item)
-      }
-
-      // Assign the model to the request data
-      // for use in the downstream handler
-      request.app.model = item.model
-
-      return h.continue
-    }
-
-    const dispatchHandler = (
-      request: FormRequest,
-      h: Pick<ResponseToolkit, 'redirect' | 'view'>
-    ) => {
-      const { model } = request.app
-
-      const servicePath = model ? `/${model.basePath}` : ''
-      return proceed(request, h, `${servicePath}${getStartPath(model)}`)
-    }
-
-    const redirectOrMakeHandler = async (
-      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))
-    }
-
-    const 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)
-      })
-    }
-
-    const 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)
-      })
-    }
-
-    const dispatchRouteOptions: RouteOptions<FormRequestRefs> = {
-      pre: [
-        {
-          method: loadFormPreHandler
-        }
-      ]
-    }
-
-    server.route({
-      method: 'get',
-      path: '/{slug}',
-      handler: dispatchHandler,
-      options: {
-        ...dispatchRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            slug: slugSchema
-          })
-        }
-      }
-    })
-
-    server.route({
-      method: 'get',
-      path: '/preview/{state}/{slug}',
-      handler: dispatchHandler,
-      options: {
-        ...dispatchRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            state: stateSchema,
-            slug: slugSchema
-          })
-        }
-      }
-    })
+    const loadFormPreHandler = makeLoadFormPreHandler(server, options)
 
     const getRouteOptions: RouteOptions<FormRequestRefs> = {
       pre: [
         {
-          method: loadFormPreHandler
+          method:
+            loadFormPreHandler as unknown as Lifecycle.Method<FormRequestRefs>
         }
       ]
     }
 
-    server.route({
-      method: 'get',
-      path: '/{slug}/{path}/{itemId?}',
-      handler: getHandler,
-      options: {
-        ...getRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            slug: slugSchema,
-            path: pathSchema,
-            itemId: itemIdSchema.optional()
-          })
-        }
-      }
-    })
-
-    server.route({
-      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()
-          })
-        }
-      }
-    })
-
     const postRouteOptions: RouteOptions<FormRequestPayloadRefs> = {
       payload: {
         parse: true
       },
-      pre: [{ method: loadFormPreHandler }]
-    }
-
-    server.route({
-      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()
-        }
-      }
-    })
-
-    server.route({
-      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()
-        }
-      }
-    })
-
-    /**
-     * "AddAnother" repeat routes
-     */
-
-    // List summary GET route
-    const getListSummaryHandler = (
-      request: FormRequest,
-      h: Pick<ResponseToolkit, 'redirect' | 'view'>
-    ) => {
-      const { params } = request
-
-      return redirectOrMakeHandler(request, h, (page, context) => {
-        if (!(page instanceof RepeatPageController)) {
-          throw Boom.notFound(`No repeater page found for /${params.path}`)
-        }
-
-        return page.makeGetListSummaryRouteHandler()(request, context, h)
-      })
-    }
-
-    server.route({
-      method: 'get',
-      path: '/{slug}/{path}/summary',
-      handler: getListSummaryHandler,
-      options: {
-        ...getRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            slug: slugSchema,
-            path: pathSchema
-          })
-        }
-      }
-    })
-
-    server.route({
-      method: 'get',
-      path: '/preview/{state}/{slug}/{path}/summary',
-      handler: getListSummaryHandler,
-      options: {
-        ...getRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            state: stateSchema,
-            slug: slugSchema,
-            path: pathSchema
-          })
-        }
-      }
-    })
-
-    // List summary POST route
-    const postListSummaryHandler = (
-      request: FormRequestPayload,
-      h: Pick<ResponseToolkit, 'redirect' | 'view'>
-    ) => {
-      const { params } = request
-
-      return redirectOrMakeHandler(request, h, (page, context) => {
-        const { isForceAccess } = context
-
-        if (isForceAccess || !(page instanceof RepeatPageController)) {
-          throw Boom.notFound(`No repeater page found for /${params.path}`)
-        }
-
-        return page.makePostListSummaryRouteHandler()(request, context, h)
-      })
-    }
-
-    server.route({
-      method: 'post',
-      path: '/{slug}/{path}/summary',
-      handler: postListSummaryHandler,
-      options: {
-        ...postRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            slug: slugSchema,
-            path: pathSchema
-          }),
-          payload: Joi.object()
-            .keys({
-              crumb: crumbSchema,
-              action: actionSchema
-            })
-            .required()
-        }
-      }
-    })
-
-    server.route({
-      method: 'post',
-      path: '/preview/{state}/{slug}/{path}/summary',
-      handler: postListSummaryHandler,
-      options: {
-        ...postRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            state: stateSchema,
-            slug: slugSchema,
-            path: pathSchema
-          }),
-          payload: Joi.object()
-            .keys({
-              crumb: crumbSchema,
-              action: actionSchema
-            })
-            .required()
-        }
-      }
-    })
-
-    // Item delete GET route
-    const getItemDeleteHandler = (
-      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)
-      })
-    }
-
-    server.route({
-      method: 'get',
-      path: '/{slug}/{path}/{itemId}/confirm-delete',
-      handler: getItemDeleteHandler,
-      options: {
-        ...getRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            slug: slugSchema,
-            path: pathSchema,
-            itemId: itemIdSchema
-          })
-        }
-      }
-    })
-
-    server.route({
-      method: 'get',
-      path: '/preview/{state}/{slug}/{path}/{itemId}/confirm-delete',
-      handler: getItemDeleteHandler,
-      options: {
-        ...getRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            state: stateSchema,
-            slug: slugSchema,
-            path: pathSchema,
-            itemId: itemIdSchema
-          })
-        }
-      }
-    })
-
-    // Item delete POST route
-    const postItemDeleteHandler = (
-      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}`)
+      pre: [
+        {
+          method:
+            loadFormPreHandler as unknown as Lifecycle.Method<FormRequestPayloadRefs>
         }
-
-        return page.makePostItemDeleteRouteHandler()(request, context, h)
-      })
+      ]
     }
 
-    server.route({
-      method: 'post',
-      path: '/{slug}/{path}/{itemId}/confirm-delete',
-      handler: postItemDeleteHandler,
-      options: {
-        ...postRouteOptions,
-        validate: {
-          params: Joi.object().keys({
-            slug: slugSchema,
-            path: pathSchema,
-            itemId: itemIdSchema
-          }),
-          payload: Joi.object()
-            .keys({
-              crumb: crumbSchema,
-              action: actionSchema,
-              confirm: confirmSchema
-            })
-            .required()
-        }
-      }
-    })
-
-    server.route({
-      method: 'post',
-      path: '/preview/{state}/{slug}/{path}/{itemId}/confirm-delete',
-      handler: postItemDeleteHandler,
-      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()
-        }
-      }
-    })
-
-    server.route({
-      method: 'get',
-      path: '/upload-status/{uploadId}',
-      handler: async (
-        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)
-          }
+    const routes = [
+      ...getQuestionRoutes(getRouteOptions, postRouteOptions),
+      ...getRepeaterSummaryRoutes(getRouteOptions, postRouteOptions),
+      ...getRepeaterItemDeleteRoutes(getRouteOptions, postRouteOptions),
+      ...getFileUploadStatusRoutes()
+    ]
 
-          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)
-        }
-      },
-      options: {
-        plugins: {
-          crumb: false
-        },
-        validate: {
-          params: Joi.object().keys({
-            uploadId: Joi.string().guid().required()
-          })
-        }
-      }
-    })
+    server.route(routes as unknown as ServerRoute[]) // TODO
   }
 } satisfies Plugin<PluginOptions>
-
-interface CompileOptions {
-  environment: Environment
-}
-
-export interface EngineConfigurationObject {
-  compileOptions: CompileOptions
-}