@defra/forms-engine-plugin 0.0.4 → 0.0.6

package/src/server/index.test.ts

@@ -0,0 +1,582 @@
+import { type Server } from '@hapi/hapi'
+import { StatusCodes } from 'http-status-codes'
+
+import { createServer } from '~/src/server/index.js'
+import {
+  getFormDefinition,
+  getFormMetadata
+} from '~/src/server/plugins/engine/services/formsService.js'
+import { getUploadStatus } from '~/src/server/plugins/engine/services/uploadService.js'
+import {
+  FileStatus,
+  UploadStatus,
+  type UploadStatusResponse
+} from '~/src/server/plugins/engine/types.js'
+import { FormStatus } from '~/src/server/routes/types.js'
+import * as fixtures from '~/test/fixtures/index.js'
+
+jest.mock('~/src/server/plugins/engine/services/formsService.js')
+jest.mock('~/src/server/plugins/engine/services/uploadService.js')
+
+describe('Model cache', () => {
+  let server: Server
+
+  const getCacheSize = () => {
+    return server.app.models.size
+  }
+
+  const getCacheItem = (key: string) => {
+    return server.app.models.get(key)
+  }
+
+  beforeAll(async () => {
+    server = await createServer()
+    await server.initialize()
+  })
+
+  beforeEach(() => {
+    jest.mocked(getFormMetadata).mockResolvedValue(fixtures.form.metadata)
+    server.app.models.clear()
+  })
+
+  afterAll(async () => {
+    await server.stop()
+  })
+
+  describe('Success responses', () => {
+    test('Dispatch page with the correct state returns 302', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.MOVED_TEMPORARILY)
+      expect(res.headers.location).toBe('/slug/page-one')
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Dispatch preview page with the correct live state returns 302', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/live/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.MOVED_TEMPORARILY)
+      expect(res.headers.location).toBe('/preview/live/slug/page-one')
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Dispatch preview page with the correct draft state returns 302', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        draft: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/draft/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.MOVED_TEMPORARILY)
+      expect(res.headers.location).toBe('/preview/draft/slug/page-one')
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Get page with the correct live state returns 200', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Get preview page with the correct live state returns 200', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/live/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Get preview page with the correct draft state returns 200', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        draft: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/draft/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Get page with the correct state returns 200', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      const options = {
+        method: 'GET',
+        url: '/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(1)
+    })
+
+    test('Get page with the correct state populates the cache correctly', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValue({
+        ...fixtures.form.metadata,
+        draft: fixtures.form.state,
+        live: fixtures.form.state
+      })
+
+      jest.mocked(getFormDefinition).mockResolvedValue(fixtures.form.definition)
+
+      // Populate live/live cache item
+      const options1 = {
+        method: 'GET',
+        url: '/slug/page-one'
+      }
+
+      const res1 = await server.inject(options1)
+
+      expect(res1.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(1)
+
+      // Populate live/preview cache item
+      const options2 = {
+        method: 'GET',
+        url: '/preview/live/slug/page-one'
+      }
+
+      const res2 = await server.inject(options2)
+
+      expect(res2.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(2)
+
+      // Populate draft/preview cache item
+      const options3 = {
+        method: 'GET',
+        url: '/preview/draft/slug/page-one'
+      }
+
+      const res3 = await server.inject(options3)
+
+      expect(res3.statusCode).toBe(StatusCodes.OK)
+      expect(getCacheSize()).toBe(3)
+
+      // Execute each request again and
+      // assert the cache size is unchanged
+      await server.inject(options1)
+      await server.inject(options2)
+      await server.inject(options3)
+
+      expect(getCacheSize()).toBe(3)
+
+      // Check models cache item is regenerated on an update to the state
+      const now2 = new Date()
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        draft: fixtures.form.state,
+        live: { ...fixtures.form.state, updatedAt: now2 }
+      })
+
+      await server.inject(options1)
+
+      // Expect `getFormDefinition` to be called as the updatedAt has moved on
+      expect(getFormDefinition).toHaveBeenLastCalledWith(
+        fixtures.form.metadata.id,
+        FormStatus.Live
+      )
+
+      // Assert the live/live cache item has the correct updatedAt timestamp
+      expect(
+        getCacheItem(`${fixtures.form.metadata.id}_live_false`)?.updatedAt
+      ).toBe(now2)
+
+      // Expect the cache size to remain unchanged
+      expect(getCacheSize()).toBe(3)
+
+      // Assert the number of times `getFormDefinition`
+      // has only been called 4 times for the 7 requests
+      expect(getFormDefinition).toHaveBeenCalledTimes(4)
+    })
+  })
+
+  describe('Error responses', () => {
+    test('Dispatch page without the correct state returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce(fixtures.form.metadata)
+
+      const options = {
+        method: 'GET',
+        url: '/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Dispatch preview page without the correct draft state returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce(fixtures.form.metadata)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/draft/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Dispatch preview page without the correct live state returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce(fixtures.form.metadata)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/live/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Dispatch page with the correct live state but no definition returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+      jest.mocked(getFormDefinition).mockResolvedValue(undefined)
+
+      const options = {
+        method: 'GET',
+        url: '/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Dispatch preview page with the correct draft state but no definition returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+      jest.mocked(getFormDefinition).mockResolvedValue(undefined)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/draft/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Dispatch preview page with the correct live state but no definition returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+      jest.mocked(getFormDefinition).mockResolvedValue(undefined)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/live/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Get page without the correct state returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce(fixtures.form.metadata)
+
+      const options = {
+        method: 'GET',
+        url: '/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Get preview page without the correct draft state returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce(fixtures.form.metadata)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/draft/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Get preview page without the correct live state returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce(fixtures.form.metadata)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/live/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Get page with the correct live state but no definition returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+      jest.mocked(getFormDefinition).mockResolvedValue(undefined)
+
+      const options = {
+        method: 'GET',
+        url: '/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Get preview page with the correct draft state but no definition returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+      jest.mocked(getFormDefinition).mockResolvedValue(undefined)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/draft/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+
+    test('Get preview page with the correct live state but no definition returns 404', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValueOnce({
+        ...fixtures.form.metadata,
+        live: fixtures.form.state
+      })
+      jest.mocked(getFormDefinition).mockResolvedValue(undefined)
+
+      const options = {
+        method: 'GET',
+        url: '/preview/live/slug/page-one'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.NOT_FOUND)
+      expect(getCacheSize()).toBe(0)
+    })
+  })
+
+  describe('Help pages', () => {
+    test('Contextual help page returns 200', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValue({
+        ...fixtures.form.metadata,
+        draft: fixtures.form.state,
+        live: fixtures.form.state
+      })
+
+      const options = {
+        method: 'GET',
+        url: '/help/get-support/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.OK)
+    })
+
+    test('Privacy notice page returns 200', async () => {
+      jest.mocked(getFormMetadata).mockResolvedValue({
+        ...fixtures.form.metadata,
+        draft: fixtures.form.state,
+        live: fixtures.form.state
+      })
+
+      const options = {
+        method: 'GET',
+        url: '/help/privacy/slug'
+      }
+
+      const res = await server.inject(options)
+
+      expect(res.statusCode).toBe(StatusCodes.OK)
+    })
+  })
+})
+
+describe('Upload status route', () => {
+  let server: Server
+
+  beforeAll(async () => {
+    server = await createServer()
+    await server.initialize()
+  })
+
+  afterAll(async () => {
+    await server.stop()
+  })
+
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  test('GET /upload-status/{uploadId} returns upload status with 200 when successful', async () => {
+    const mockStatus: UploadStatusResponse = {
+      uploadStatus: UploadStatus.ready,
+      metadata: {
+        retrievalKey: 'some-key'
+      },
+      form: {
+        file: {
+          fileId: 'some-file-id',
+          filename: 'some-file-name',
+          contentLength: 1024,
+          fileStatus: FileStatus.complete
+        }
+      },
+      numberOfRejectedFiles: 0
+    }
+    jest.mocked(getUploadStatus).mockResolvedValueOnce(mockStatus)
+
+    const options = {
+      method: 'GET',
+      url: '/upload-status/123e4567-e89b-12d3-a456-426614174000'
+    }
+
+    const res = await server.inject(options)
+
+    expect(res.statusCode).toBe(StatusCodes.OK)
+    expect(res.result).toEqual(mockStatus)
+    expect(getUploadStatus).toHaveBeenCalledWith(
+      '123e4567-e89b-12d3-a456-426614174000'
+    )
+  })
+
+  test('GET /upload-status/{uploadId} returns 400 when status check fails', async () => {
+    jest.mocked(getUploadStatus).mockResolvedValueOnce(undefined)
+
+    const options = {
+      method: 'GET',
+      url: '/upload-status/123e4567-e89b-12d3-a456-426614174000'
+    }
+
+    const res = await server.inject(options)
+
+    expect(res.statusCode).toBe(StatusCodes.BAD_REQUEST)
+    expect(res.result).toEqual({ error: 'Status check failed' })
+  })
+
+  test('GET /upload-status/{uploadId} returns 500 when exception occurs', async () => {
+    jest
+      .mocked(getUploadStatus)
+      .mockRejectedValueOnce(new Error('Service unavailable'))
+
+    const options = {
+      method: 'GET',
+      url: '/upload-status/123e4567-e89b-12d3-a456-426614174000'
+    }
+
+    const res = await server.inject(options)
+
+    expect(res.statusCode).toBe(StatusCodes.INTERNAL_SERVER_ERROR)
+    expect(res.result).toEqual({ error: 'Status check error' })
+  })
+
+  test('GET /upload-status/{uploadId} returns 400 for invalid uploadId format', async () => {
+    const options = {
+      method: 'GET',
+      url: '/upload-status/not-a-valid-guid'
+    }
+
+    const res = await server.inject(options)
+
+    expect(res.statusCode).toBe(StatusCodes.BAD_REQUEST)
+  })
+})

package/src/server/index.ts

@@ -0,0 +1,135 @@
+import { Engine as CatboxMemory } from '@hapi/catbox-memory'
+import { Engine as CatboxRedis } from '@hapi/catbox-redis'
+import hapi, {
+  type Request,
+  type ResponseToolkit,
+  type ServerOptions
+} from '@hapi/hapi'
+import inert from '@hapi/inert'
+import Scooter from '@hapi/scooter'
+import Wreck from '@hapi/wreck'
+import blipp from 'blipp'
+import { ProxyAgent } from 'proxy-agent'
+
+import { config } from '~/src/config/index.js'
+import { requestLogger } from '~/src/server/common/helpers/logging/request-logger.js'
+import { requestTracing } from '~/src/server/common/helpers/logging/request-tracing.js'
+import { buildRedisClient } from '~/src/server/common/helpers/redis-client.js'
+import { configureBlankiePlugin } from '~/src/server/plugins/blankie.js'
+import { configureCrumbPlugin } from '~/src/server/plugins/crumb.js'
+import { configureEnginePlugin } from '~/src/server/plugins/engine/index.js'
+import pluginErrorPages from '~/src/server/plugins/errorPages.js'
+import { plugin as pluginViews } from '~/src/server/plugins/nunjucks/index.js'
+import pluginPulse from '~/src/server/plugins/pulse.js'
+import pluginRouter from '~/src/server/plugins/router.js'
+import pluginSession from '~/src/server/plugins/session.js'
+import { prepareSecureContext } from '~/src/server/secure-context.js'
+import { type RouteConfig } from '~/src/server/types.js'
+
+const proxyAgent = new ProxyAgent()
+
+Wreck.agents = {
+  https: proxyAgent,
+  http: proxyAgent,
+  httpsAllowUnauthorized: proxyAgent
+}
+
+const serverOptions = (): ServerOptions => {
+  const serverOptions: ServerOptions = {
+    debug: { request: [`${config.get('isDevelopment')}`] },
+    port: config.get('port'),
+    router: {
+      stripTrailingSlash: true
+    },
+    routes: {
+      validate: {
+        options: {
+          abortEarly: false
+        }
+      },
+      security: {
+        hsts: {
+          maxAge: 31536000,
+          includeSubDomains: true,
+          preload: false
+        },
+        xss: 'enabled',
+        noSniff: true,
+        xframe: true
+      }
+    },
+    cache: [
+      {
+        name: 'session',
+        engine: config.get('isTest')
+          ? new CatboxMemory()
+          : new CatboxRedis({
+              client: buildRedisClient()
+            })
+      }
+    ]
+  }
+
+  return serverOptions
+}
+
+export async function createServer(routeConfig?: RouteConfig) {
+  const server = hapi.server(serverOptions())
+
+  await server.register(requestLogger)
+
+  if (config.get('isProduction')) {
+    prepareSecureContext(server)
+  }
+
+  const pluginEngine = await configureEnginePlugin(routeConfig)
+  const pluginCrumb = configureCrumbPlugin(routeConfig)
+  const pluginBlankie = configureBlankiePlugin()
+
+  await server.register(pluginSession)
+  await server.register(pluginPulse)
+  await server.register(inert)
+  await server.register(Scooter)
+  await server.register(pluginBlankie)
+  await server.register(pluginCrumb)
+
+  server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+    const { response } = request
+
+    if ('isBoom' in response) {
+      return h.continue
+    }
+
+    // Prevent search engine indexing
+    response.header('x-robots-tag', 'noindex, nofollow')
+
+    // Disable cache to ensure back/foward navigation updates progress
+    if (
+      !request.path.startsWith('/javascripts/') &&
+      !request.path.startsWith('/stylesheets/') &&
+      !request.path.startsWith('/assets/')
+    ) {
+      response.header('cache-control', 'no-store')
+    }
+
+    return h.continue
+  })
+
+  await server.register(pluginViews)
+  await server.register(pluginEngine)
+  await server.register(pluginRouter)
+  await server.register(pluginErrorPages)
+  await server.register(blipp)
+  await server.register(requestTracing)
+
+  server.state('cookieConsent', {
+    ttl: 365 * 24 * 60 * 60 * 1000, // 1 year in ms
+    clearInvalid: true,
+    isHttpOnly: false,
+    isSecure: config.get('isProduction'),
+    path: '/',
+    encoding: 'none' // handle this inside the application so we can share frontend/backend cookie modification
+  })
+
+  return server
+}