@defra/lis-infra-ui-services 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra/lis-infra-ui-services",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "UI-Services shared definitions for the livestock taxonomy topology.",
   "main": "src/index.js",
   "repository": {
@@ -54,6 +54,7 @@
   "author": "Defra DDTS",
   "license": "OGL-UK-3.0",
   "dependencies": {
+    "@defra/lis-hubs-infra-registry": "^0.3.0",
     "@elastic/ecs-pino-format": "1.5.0",
     "@hapi/catbox-memory": "6.0.2",
     "@hapi/catbox-redis": "7.0.2",

package/src/base-path.js

@@ -1,5 +1,7 @@
 /** @import { Request } from '@hapi/hapi' */
 
+import { getBasePathForModule } from '@defra/lis-hubs-infra-registry'
+
 function normalizePath(path) {
   if (!path || path === '/') {
     return '/'
@@ -96,12 +98,14 @@ export function getAssetPaths({ basePath: _basePath = '', assetPath }) {
 }
 
 /**
- * @param {object} config
+ * @param {{ moduleId?: string, assetPath: string }} options
  * @returns {object}
  */
-export function createBasePathHelpersForConfig(config) {
+export function createBasePathHelpersForConfig({ moduleId, assetPath }) {
+  const basePath = moduleId ? getBasePathForModule(moduleId) : ''
+
   function getBasePath() {
-    return config.get('basePath')
+    return basePath
   }
 
   return {
@@ -134,7 +138,7 @@ export function createBasePathHelpersForConfig(config) {
     getAssetPaths() {
       return getAssetPaths({
         basePath: getBasePath(),
-        assetPath: config.get('assetPath')
+        assetPath
       })
     }
   }

package/src/base-path.test.js

@@ -1,6 +1,6 @@
-import assert from 'node:assert/strict'
-import { test } from 'vitest'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
 
+import { getBasePathForModule } from '@defra/lis-hubs-infra-registry'
 import {
   buildAppPath,
   createBasePathHelpersForConfig,
@@ -10,111 +10,285 @@ import {
   isPrefixedRequest
 } from './base-path.js'
 
-test('isPrefixedRequest detects a forwarded prefix that matches the configured base path', () => {
-  assert.equal(
-    isPrefixedRequest({
-      request: {
-        path: '/about',
-        headers: {
-          'x-forwarded-prefix': '/chicken/move'
-        }
-      },
-      basePath: '/chicken/move'
-    }),
-    true
-  )
-})
+vi.mock('@defra/lis-hubs-infra-registry')
 
-test('isPrefixedRequest ignores a forwarded prefix that does not match the configured base path', () => {
-  assert.equal(
-    isPrefixedRequest({
-      request: {
-        path: '/about',
-        headers: {
-          'x-forwarded-prefix': '/goat/move'
-        }
-      },
-      basePath: '/chicken/move'
-    }),
-    false
-  )
+const mocks = {
+  getBasePathForModule: vi.mocked(getBasePathForModule)
+}
+
+describe('isPrefixedRequest()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('detects a forwarded prefix that matches the configured base path', () => {
+    // Arrange
+    const request = {
+      path: '/about',
+      headers: {
+        'x-forwarded-prefix': '/chicken/move'
+      }
+    }
+
+    // Act
+    const result = isPrefixedRequest({ request, basePath: '/chicken/move' })
+
+    // Assert
+    expect(result).toBe(true)
+  })
+
+  test('ignores a forwarded prefix that does not match the configured base path', () => {
+    // Arrange
+    const request = {
+      path: '/about',
+      headers: {
+        'x-forwarded-prefix': '/goat/move'
+      }
+    }
+
+    // Act
+    const result = isPrefixedRequest({ request, basePath: '/chicken/move' })
+
+    // Assert
+    expect(result).toBe(false)
+  })
 })
 
-test('getRequestBasePath preserves direct requests to the configured base path', () => {
-  assert.equal(
-    getRequestBasePath({
-      request: {
-        path: '/chicken/move/about',
-        headers: {}
-      },
-      basePath: '/chicken/move'
-    }),
-    '/chicken/move'
-  )
+describe('getRequestBasePath()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('preserves direct requests to the configured base path', () => {
+    // Arrange
+    const request = {
+      path: '/chicken/move/about',
+      headers: {}
+    }
+
+    // Act
+    const result = getRequestBasePath({ request, basePath: '/chicken/move' })
+
+    // Assert
+    expect(result).toBe('/chicken/move')
+  })
 })
 
-test('buildAppPath uses the forwarded prefix for outbound paths when present', () => {
-  assert.equal(
-    buildAppPath({
-      request: {
-        path: '/about',
-        headers: {
-          'x-forwarded-prefix': '/chicken/move'
-        }
-      },
+describe('buildAppPath()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('uses the forwarded prefix for outbound paths when present', () => {
+    // Arrange
+    const request = {
+      path: '/about',
+      headers: {
+        'x-forwarded-prefix': '/chicken/move'
+      }
+    }
+
+    // Act
+    const result = buildAppPath({
+      request,
       routePath: '/more-info',
       basePath: '/chicken/move'
-    }),
-    '/chicken/move/more-info'
-  )
-})
+    })
+
+    // Assert
+    expect(result).toBe('/chicken/move/more-info')
+  })
 
-test('getRouteVariants only returns the internal route path', () => {
-  assert.deepEqual(
-    getRouteVariants({
-      routePath: '/about',
+  test('returns just the base path for the root route', () => {
+    // Arrange
+    const request = {
+      path: '/chicken/move',
+      headers: {}
+    }
+
+    // Act
+    const result = buildAppPath({
+      request,
+      routePath: '/',
       basePath: '/chicken/move'
-    }),
-    ['/about']
-  )
+    })
+
+    // Assert
+    expect(result).toBe('/chicken/move')
+  })
+
+  test('falls back to / for the root route with no base path', () => {
+    // Arrange
+    const request = {
+      path: '/',
+      headers: {}
+    }
+
+    // Act
+    const result = buildAppPath({ request, routePath: '/' })
+
+    // Assert
+    expect(result).toBe('/')
+  })
 })
 
-test('getAssetPaths only returns the internal asset path', () => {
-  assert.deepEqual(
-    getAssetPaths({
-      basePath: '/chicken/move',
-      assetPath: '/public'
-    }),
-    ['/public']
-  )
+describe('getRouteVariants()', () => {
+  test('only returns the internal route path', () => {
+    // Arrange
+    const routePath = '/about'
+
+    // Act
+    const result = getRouteVariants({ routePath, basePath: '/chicken/move' })
+
+    // Assert
+    expect(result).toEqual(['/about'])
+  })
 })
 
-test('createBasePathHelpersForConfig binds config for request and asset helpers', () => {
-  const calls = []
-  const config = {
-    get(key) {
-      calls.push(key)
+describe('getAssetPaths()', () => {
+  test('only returns the internal asset path', () => {
+    // Arrange
+    const assetPath = '/public'
 
-      if (key === 'basePath') {
-        return '/chicken/move'
-      }
+    // Act
+    const result = getAssetPaths({ basePath: '/chicken/move', assetPath })
 
-      if (key === 'assetPath') {
-        return '/public'
-      }
+    // Assert
+    expect(result).toEqual(['/public'])
+  })
+})
+
+describe('createBasePathHelpersForConfig()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('resolves the base path from the module registry when moduleId is given', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+
+    // Act
+    const helpers = createBasePathHelpersForConfig({
+      moduleId: 'cattle-register',
+      assetPath: '/public'
+    })
+
+    // Assert
+    expect(mocks.getBasePathForModule).toHaveBeenCalledWith('cattle-register')
+    expect(helpers.getBasePath()).toBe('/cattle/register')
+  })
+
+  test('defaults to an empty base path when no moduleId is given', () => {
+    // Arrange
+    // Act
+    const helpers = createBasePathHelpersForConfig({ assetPath: '/public' })
+
+    // Assert
+    expect(helpers.getBasePath()).toBe('')
+    expect(mocks.getBasePathForModule).not.toHaveBeenCalled()
+  })
+
+  test('binds the resolved base path to isPrefixedRequest', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+    const helpers = createBasePathHelpersForConfig({
+      moduleId: 'cattle-register',
+      assetPath: '/public'
+    })
+    const request = {
+      path: '/cattle/register/about',
+      headers: {}
     }
-  }
-  const helpers = createBasePathHelpersForConfig(config)
 
-  assert.equal(
-    helpers.getRequestBasePath({
-      path: '/about',
-      headers: {
-        'x-forwarded-prefix': '/chicken/move'
-      }
-    }),
-    '/chicken/move'
-  )
-  assert.deepEqual(helpers.getAssetPaths(), ['/public'])
-  assert.deepEqual(calls, ['basePath', 'basePath', 'assetPath'])
+    // Act
+    const result = helpers.isPrefixedRequest(request)
+
+    // Assert
+    expect(result).toBe(true)
+  })
+
+  test('binds the resolved base path to getRequestBasePath', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+    const helpers = createBasePathHelpersForConfig({
+      moduleId: 'cattle-register',
+      assetPath: '/public'
+    })
+    const request = {
+      path: '/cattle/register/about',
+      headers: {}
+    }
+
+    // Act
+    const result = helpers.getRequestBasePath(request)
+
+    // Assert
+    expect(result).toBe('/cattle/register')
+  })
+
+  test('binds the resolved base path to buildAppPath', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+    const helpers = createBasePathHelpersForConfig({
+      moduleId: 'cattle-register',
+      assetPath: '/public'
+    })
+    const request = {
+      path: '/cattle/register/about',
+      headers: {}
+    }
+
+    // Act
+    const result = helpers.buildAppPath(request, '/more-info')
+
+    // Assert
+    expect(result).toBe('/cattle/register/more-info')
+  })
+
+  test('binds the resolved base path to getRouteVariants', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+    const helpers = createBasePathHelpersForConfig({
+      moduleId: 'cattle-register',
+      assetPath: '/public'
+    })
+
+    // Act
+    const result = helpers.getRouteVariants('/about')
+
+    // Assert
+    expect(result).toEqual(['/about'])
+  })
+
+  test('defaults buildAppPath and getRouteVariants to the root route path', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+    const helpers = createBasePathHelpersForConfig({
+      moduleId: 'cattle-register',
+      assetPath: '/public'
+    })
+    const request = {
+      path: '/cattle/register',
+      headers: {}
+    }
+
+    // Act
+    const appPath = helpers.buildAppPath(request)
+    const routeVariants = helpers.getRouteVariants()
+
+    // Assert
+    expect(appPath).toBe('/cattle/register')
+    expect(routeVariants).toEqual(['/'])
+  })
+
+  test('binds the configured asset path to getAssetPaths', () => {
+    // Arrange
+    const helpers = createBasePathHelpersForConfig({ assetPath: '/public' })
+
+    // Act
+    const result = helpers.getAssetPaths()
+
+    // Assert
+    expect(result).toEqual(['/public'])
+  })
 })

package/src/nunjucks/plugin.js

@@ -5,6 +5,8 @@ import hapiVision from '@hapi/vision'
 import { createRequire } from 'node:module'
 import { fileURLToPath } from 'node:url'
 
+import { getBasePathForModule } from '@defra/lis-hubs-infra-registry'
+
 import { createNunjucksContextBuilder } from './context.js'
 import { buildPrimaryNavigation } from './build-navigation.js'
 import * as filters from './filters.js'
@@ -155,10 +157,16 @@ function buildNunjucksEnvironment({
 }
 
 /**
- * @param {{ config: object, logger: object, getRequestBasePath: Function }} options
+ * @param {{ config: object, logger: object, getRequestBasePath: Function, moduleId?: string }} options
  * @returns {object}
  */
-export function createNunjucksConfig({ config, logger, getRequestBasePath }) {
+export function createNunjucksConfig({
+  config,
+  logger,
+  getRequestBasePath,
+  moduleId
+}) {
+  const basePath = moduleId ? getBasePathForModule(moduleId) : ''
   const projectRoot = config.get('root')
   const infrastructureRoot = path.resolve(
     path.dirname(fileURLToPath(import.meta.url)),
@@ -178,7 +186,7 @@ export function createNunjucksConfig({ config, logger, getRequestBasePath }) {
   const buildNavigation = (request) =>
     buildPrimaryNavigation({
       request,
-      basePath: config.get('basePath'),
+      basePath,
       hubOrigin: request?.app?.hubOrigin ?? ''
     })
 

package/src/nunjucks/plugin.test.js

@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import nunjucks from 'nunjucks'
+import { getBasePathForModule } from '@defra/lis-hubs-infra-registry'
+import { createNunjucksConfig } from './plugin.js'
+
+vi.mock('nunjucks')
+vi.mock('@defra/lis-hubs-infra-registry')
+
+const mocks = {
+  nunjucksConfigure: vi.mocked(nunjucks.configure),
+  getBasePathForModule: vi.mocked(getBasePathForModule)
+}
+
+function createProjectRoot() {
+  const root = mkdtempSync(path.join(tmpdir(), 'ui-services-nunjucks-'))
+
+  writeFileSync(
+    path.join(root, 'package.json'),
+    JSON.stringify({ dependencies: {} })
+  )
+  mkdirSync(path.join(root, 'node_modules/govuk-frontend'), {
+    recursive: true
+  })
+  writeFileSync(
+    path.join(root, 'node_modules/govuk-frontend/package.json'),
+    '{}'
+  )
+
+  return root
+}
+
+describe('createNunjucksConfig()', () => {
+  let projectRoot
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    projectRoot = createProjectRoot()
+    mocks.nunjucksConfigure.mockReturnValue({
+      addGlobal: vi.fn(),
+      addFilter: vi.fn()
+    })
+  })
+
+  afterEach(() => {
+    rmSync(projectRoot, { recursive: true, force: true })
+  })
+
+  test('resolves the base path from the module registry when moduleId is given', () => {
+    // Arrange
+    mocks.getBasePathForModule.mockReturnValue('/cattle/register')
+    const config = { get: vi.fn((key) => (key === 'root' ? projectRoot : false)) }
+
+    // Act
+    createNunjucksConfig({
+      config,
+      logger: {},
+      getRequestBasePath: vi.fn(),
+      moduleId: 'cattle-register'
+    })
+
+    // Assert
+    expect(mocks.getBasePathForModule).toHaveBeenCalledWith('cattle-register')
+  })
+
+  test('defaults to an empty base path when no moduleId is given', () => {
+    // Arrange
+    const config = { get: vi.fn((key) => (key === 'root' ? projectRoot : false)) }
+
+    // Act
+    const nunjucksConfig = createNunjucksConfig({
+      config,
+      logger: {},
+      getRequestBasePath: vi.fn()
+    })
+
+    // Assert
+    expect(mocks.getBasePathForModule).not.toHaveBeenCalled()
+    expect(nunjucksConfig.plugin).toBeDefined()
+  })
+})