refactor(facets): translate the four facet dimensions as one set (#524)

* refactor(facets): translate the four facet dimensions as one set

`referentiecomponent` -> referenceComponent, `standaard` -> standard,
`applicatieservice` -> applicationService, `domein` -> domain. 84
substitutions across 10 files.

All four or none. They are the endpoint's query parameters AND its response
keys, and FacetController, FacetService, the frontend FACET_DIMENSIONS, the
store and the gemma-faceted-search e2e spec each hold their own copy.
Translating one of four silently broke filtering in tranche 1: a filter on
a dimension nobody sends renders a page with no filters and no error.

Whole quoted tokens only, so `standaard_gemma` and `standaarden` — which
are different words — are untouched.

TWO FILES DELIBERATELY EXCLUDED, both of which a blanket rename would have
corrupted:
  * SettingsService's only match is `'domein' => $emailSettings
    ['mailgunDomain']` — Mailgun's domain, nothing to do with facets.
  * RenameDutchCatalogColumns is a column MAP; its `'standaard' =>
    'standard'` entry is data, and rewriting it would leave `'standard' =>
    'standard'`, an identity that migrates nothing while reporting success.

That map is also the evidence this rename was overdue: the COLUMN moved to
`standard` already, so the facet dimension had been lagging behind the
property it filters on.

Checked before renaming: none of the four is a schema key (so no
ImportHandler slug migration is involved) and none feeds a derived
`<type>_schema` config key — FacetService resolves those through
SettingsService::LEGACY_SCHEMA_KEY, not from the dimension name.

Unit suite failing set IDENTICAL to development (1 both sides, 0
introduced); the 22 Facet tests pass.

* fix(facets): move the dimension in every shape, not just quoted tokens

The first pass renamed whole QUOTED tokens, which left three shapes behind
and CI's jest run found them:

  * bare object keys — `activeFilters.referentiecomponent`, `domein: []`
  * the URL-ENCODED form — `referentiecomponent%5B%5D=A` inside a longer
    string literal
  * the route-query form `_gf_referentiecomponent`. `\b` does NOT match
    after an underscore, so the word-boundary pass skipped every one of
    them, and `setFiltersFromQuery` returned {} — the store silently
    restored no filters at all.

The real schema fields are deliberately NOT the dimension names and stay
put: `referentieComponenten` and `standaardVersies` are different
identifiers, which the negative lookahead protects.

Also restores a HISTORICAL comment the rename made self-contradictory. It
described the tranche-1 bug — frontend sending `standard[]` to a backend
reading `standaard[]` — and translating its Dutch spelling turned it into
"sending standard[] to a backend that only reads standard[]". The Dutch
words are the point of that sentence.

jest 120/120; the 22 Facet PHPUnit tests pass.

* style: prettier the facet store spec

Format-only; the rename left a call spanning lines prettier joins. jest
23/23 on that file.

---------

Co-authored-by: Conduction Release Bot <release-bot@conduction.nl>

Author: rubenvdlinde

lib/Controller/FacetController.php

@@ -62,7 +62,7 @@ public function __construct(
 	 *
 	 * Query Parameters:
 	 * - search (string): Free-text query narrowing the candidate set.
-	 * - referentiecomponent[], standaard[], applicatieservice[], domein[] (string[]):
+	 * - referenceComponent[], standard[], applicationService[], domain[] (string[]):
 	 *   Currently-selected facet values per dimension.
 	 * - organization (string): Optional organisation override.
 	 *
@@ -144,7 +144,7 @@ public function getFacets(string $schema): JSONResponse {
 	 * @return array<string,array> Raw filters keyed by dimension.
 	 */
 	private function parseFilters(): array {
-		$dimensions = ['referentiecomponent', 'standaard', 'applicatieservice', 'domein'];
+		$dimensions = ['referenceComponent', 'standard', 'applicationService', 'domain'];
 		$filters = [];
 
 		foreach ($dimensions as $dimension) {

lib/Service/FacetService.php

@@ -3,8 +3,8 @@
 /**
  * Facet Service for SoftwareCatalog
  *
- * Aggregates GEMMA-dimension facet counts (referentiecomponent, standaard,
- * applicatieservice, domein) across the `module` and `dienst` listings,
+ * Aggregates GEMMA-dimension facet counts (referenceComponent, standard,
+ * applicationService, domain) across the `module` and `dienst` listings,
  * scoped to the caller's RBAC/tenant context and combinable with the
  * existing free-text search.
  *
@@ -39,8 +39,8 @@
  *
  * Architecture (see design.md): resolves a bounded, RBAC-scoped candidate
  * object set for the requested schema (`module` or `dienst`), builds a
- * per-object map of GEMMA dimension values (resolving `domein` and
- * `applicatieservice` via linked `element` lookups through the existing
+ * per-object map of GEMMA dimension values (resolving `domain` and
+ * `applicationService` via linked `element` lookups through the existing
  * `ArchiMateService`), then computes disjunctive ("self-count not narrowed
  * by its own selection") facet counts over that map.
  *
@@ -89,7 +89,7 @@ class FacetService {
 	private const MAX_BASE_PAGES = 5;
 
 	/**
-	 * Bounded limit for element/relation lookup queries (domein/applicatieservice resolution).
+	 * Bounded limit for element/relation lookup queries (domain/applicationService resolution).
 	 */
 	private const ELEMENT_LOOKUP_LIMIT = 1000;
 
@@ -105,15 +105,15 @@ class FacetService {
 	 *
 	 * @var string[]
 	 */
-	private const DIMENSIONS = ['referentiecomponent', 'standaard', 'applicatieservice', 'domein'];
+	private const DIMENSIONS = ['referenceComponent', 'standard', 'applicationService', 'domain'];
 
 	/**
 	 * Constructor for FacetService.
 	 *
 	 * @param ContainerInterface $container PSR-11 container interface (for lazy ObjectService lookup).
 	 * @param SettingsService $settingsService Settings service for voorzieningen register/schema configuration.
 	 * @param ArchiMateService $archiMateService Reused for bounded `element`/`relationship` lookups
-	 *                                           (domein/applicatieservice resolution) instead of
+	 *                                           (domain/applicationService resolution) instead of
 	 *                                           duplicating AMEF register/schema resolution logic.
 	 * @param ViewQueryBuilder $queryBuilder Reused for the `_search` query-param convention.
 	 * @param IUserSession $userSession User session service for current user/RBAC cache-key context.
@@ -138,16 +138,16 @@ public function __construct(
 	 *
 	 * @param string $schema `module` or `dienst`.
 	 * @param array $filters Currently-selected facet values keyed by dimension,
-	 *                       e.g. `['referentiecomponent' => ['Zaakregistratiecomponent']]`.
+	 *                       e.g. `['referenceComponent' => ['Zaakregistratiecomponent']]`.
 	 * @param string|null $search Free-text query narrowing the candidate set.
 	 * @param string|null $organization Optional organisation override (mirrors
 	 *                                  view-enrichment-api's `organization` parameter).
 	 *
 	 * @throws InvalidArgumentException When `$schema` is not supported.
 	 * @throws RuntimeException When OpenRegister's ObjectService is unavailable.
 	 *
-	 * @return array{referentiecomponent: array, standaard: array, applicatieservice: array,
-	 *     domein: array, _meta: array{totalMatched: int, processingTimeMs: float, cached: bool,
+	 * @return array{referenceComponent: array, standard: array, applicationService: array,
+	 *     domain: array, _meta: array{totalMatched: int, processingTimeMs: float, cached: bool,
 	 *     matchedObjectIds: string[]}}
 	 *
 	 * @spec openspec/specs/gemma-faceted-search/spec.md#requirement-facet-aggregation-endpoint-returns-gemma-dimension-counts
@@ -232,8 +232,8 @@ private function assertSupportedSchema(string $schema): void {
 	 * @param string|null $normalizedSearch Normalized free-text query.
 	 * @param string|null $organization Optional organisation override.
 	 *
-	 * @return array{referentiecomponent: array, standaard: array, applicatieservice: array,
-	 *     domein: array, _meta: array{totalMatched: int, processingTimeMs: float, cached: bool,
+	 * @return array{referenceComponent: array, standard: array, applicationService: array,
+	 *     domain: array, _meta: array{totalMatched: int, processingTimeMs: float, cached: bool,
 	 *     matchedObjectIds: string[]}}
 	 */
 	private function computeFacetsForRequest(
@@ -276,8 +276,8 @@ private function computeFacetsForRequest(
 		// `matchedObjectIds` — the RBAC/filter/search-scoped object id set this
 		// response's counts describe (proposal.md's Approach: "the RBAC-filtered
 		// object IDs needed to drive the index page's existing list query").
-		// Several dimensions (`domein`, `applicatieservice`, and `referentiecomponent`/
-		// `standaard` by display NAME) are not directly filterable on the
+		// Several dimensions (`domain`, `applicationService`, and `referenceComponent`/
+		// `standard` by display NAME) are not directly filterable on the
 		// `module`/`dienst` schema itself, so the frontend narrows its own object
 		// list via `{ id: matchedObjectIds }` rather than re-deriving an
 		// equivalent filter from the facet selection. Already bounded — this id
@@ -634,8 +634,8 @@ private function fetchModulesByIdentifiers(ObjectService $objectService, array $
 
 	/**
 	 * Build the per-object GEMMA dimension value map: for every base object,
-	 * the set of referentiecomponent/standaard names it carries directly, and
-	 * the set of domein/applicatieservice names resolved transitively via its
+	 * the set of referenceComponent/standard names it carries directly, and
+	 * the set of domain/applicationService names resolved transitively via its
 	 * linked `element` objects.
 	 *
 	 * @param array<string,array<int,array>> $modulesByObjectId Object id => module objects.
@@ -645,7 +645,7 @@ private function fetchModulesByIdentifiers(ObjectService $objectService, array $
 	 * @spec openspec/specs/gemma-faceted-search/spec.md#requirement-facet-aggregation-endpoint-returns-gemma-dimension-counts
 	 */
 	private function buildDimensionValueMap(array $modulesByObjectId): array {
-		// Pass 1: direct fields (referentiecomponent identifiers + standaard identifiers).
+		// Pass 1: direct fields (referenceComponent identifiers + standard identifiers).
 		$refCompIdsByObjId = [];
 		$stdValsByObjId = [];
 		$allRefCompIds = [];
@@ -669,12 +669,12 @@ private function buildDimensionValueMap(array $modulesByObjectId): array {
 
 		$allRefCompIds = array_values(array_unique($allRefCompIds));
 
-		// Pass 2: resolve referentiecomponent elements themselves (for the
-		// referentiecomponent facet's display value + the `domein` field).
+		// Pass 2: resolve referenceComponent elements themselves (for the
+		// referenceComponent facet's display value + the `domain` field).
 		$elementsById = $this->resolveElementsByIdentifier(identifiers: $allRefCompIds);
 
-		// Pass 3: resolve applicatieservice elements reachable via a `relation`
-		// touching one of the referentiecomponent elements.
+		// Pass 3: resolve applicationService elements reachable via a `relation`
+		// touching one of the referenceComponent elements.
 		$appSvcNmByRefComp = $this->resolveApplicatieservicesForReferentiecomponenten(
 			refCompIds: $allRefCompIds
 		);
@@ -700,9 +700,9 @@ private function buildDimensionValueMap(array $modulesByObjectId): array {
 					fallbackIdentifier: $refCompId
 				);
 
-				$domein = $element['domein'] ?? null;
-				if (is_string($domein) === true && trim($domein) !== '') {
-					$domeinValues[] = trim($domein);
+				$domain = $element['domain'] ?? null;
+				if (is_string($domain) === true && trim($domain) !== '') {
+					$domeinValues[] = trim($domain);
 				}
 
 				foreach (($appSvcNmByRefComp[$refCompId] ?? []) as $appSvcName) {
@@ -711,10 +711,10 @@ private function buildDimensionValueMap(array $modulesByObjectId): array {
 			}
 
 			$dimValsByObjId[$objectId] = [
-				'referentiecomponent' => array_values(array_unique($refCompNames)),
-				'standaard' => $stdValsByObjId[$objectId] ?? [],
-				'domein' => array_values(array_unique($domeinValues)),
-				'applicatieservice' => array_values(array_unique($appSvcValues)),
+				'referenceComponent' => array_values(array_unique($refCompNames)),
+				'standard' => $stdValsByObjId[$objectId] ?? [],
+				'domain' => array_values(array_unique($domeinValues)),
+				'applicationService' => array_values(array_unique($appSvcValues)),
 			];
 		}//end foreach
 
@@ -764,16 +764,16 @@ private function resolveElementsByIdentifier(array $identifiers): array {
 	}//end resolveElementsByIdentifier()
 
 	/**
-	 * Resolve, for each referentiecomponent identifier, the distinct display
+	 * Resolve, for each referenceComponent identifier, the distinct display
 	 * names of `Applicatieservice`-typed `element` objects reachable via a
 	 * `relation` object touching it (either endpoint) — the module schema has
-	 * no direct applicatieservice link, so this two-hop lookup mirrors the
+	 * no direct applicationService link, so this two-hop lookup mirrors the
 	 * relationship-resolution pattern `ViewService`/`ArchiMateService` already
-	 * perform for referentiecomponent overlays (design.md trade-offs).
+	 * perform for referenceComponent overlays (design.md trade-offs).
 	 *
-	 * @param array $refCompIds Distinct referentiecomponent element identifiers.
+	 * @param array $refCompIds Distinct referenceComponent element identifiers.
 	 *
-	 * @return array<string,string[]> Referentiecomponent identifier => applicatieservice names.
+	 * @return array<string,string[]> Referentiecomponent identifier => applicationService names.
 	 *
 	 * @spec openspec/specs/gemma-faceted-search/spec.md#requirement-facet-aggregation-endpoint-returns-gemma-dimension-counts
 	 * @spec openspec/specs/gemma-faceted-search/spec.md#requirement-facet-aggregation-queries-must-be-bounded
@@ -791,7 +791,7 @@ private function resolveApplicatieservicesForReferentiecomponenten(array $refCom
 			);
 		} catch (\Exception $e) {
 			$this->logger->warning(
-				message: 'FacetService: failed to resolve relationships for applicatieservice facet',
+				message: 'FacetService: failed to resolve relationships for applicationService facet',
 				context: ['error' => $e->getMessage()]
 			);
 			return [];
@@ -818,12 +818,12 @@ private function resolveApplicatieservicesForReferentiecomponenten(array $refCom
 
 	/**
 	 * For every `relation` object, record the OTHER endpoint (source or
-	 * target) whenever one side matches a referentiecomponent identifier —
+	 * target) whenever one side matches a referenceComponent identifier —
 	 * relations are undirected for this lookup's purposes (either endpoint
 	 * order counts).
 	 *
 	 * @param array $relations Bounded relation objects.
-	 * @param array $refCompIds Distinct referentiecomponent element identifiers.
+	 * @param array $refCompIds Distinct referenceComponent element identifiers.
 	 *
 	 * @return array<string,string[]> Referentiecomponent identifier => other-endpoint identifiers.
 	 */
@@ -851,13 +851,13 @@ private function collectRelationEndpoints(array $relations, array $refCompIds):
 	}//end collectRelationEndpoints()
 
 	/**
-	 * Filter each referentiecomponent's other-endpoint identifiers down to
+	 * Filter each referenceComponent's other-endpoint identifiers down to
 	 * `Applicatieservice`-typed elements and resolve their display names.
 	 *
 	 * @param array $otherEpsByRefComp Referentiecomponent identifier => other-endpoint identifiers.
 	 * @param array $elementsById Resolved element identifier => element object.
 	 *
-	 * @return array<string,string[]> Referentiecomponent identifier => applicatieservice names.
+	 * @return array<string,string[]> Referentiecomponent identifier => applicationService names.
 	 */
 	private function mapEndpointsToApplicatieserviceNames(array $otherEpsByRefComp, array $elementsById): array {
 		$result = [];

src/services/facets.js

@@ -21,16 +21,17 @@ import { generateUrl } from '@nextcloud/router'
 /** GEMMA facet dimensions this client supports, in display order. */
 export const FACET_DIMENSIONS = [
 	// WIRE NAMES, and they must stay as a SET. FacetController and FacetService
-	// both declare ['referentiecomponent', 'standaard', 'applicatieservice',
-	// 'domein'] — these strings are the query parameters and the response keys of
-	// this app's own facet endpoint. The vocabulary pass translated exactly ONE of
-	// the four, so the frontend started sending `standard[]` to a backend that
-	// only reads `standaard[]`: facet filtering by standard silently returned
-	// everything, with no error on either side.
-	'referentiecomponent',
-	'standaard',
-	'applicatieservice',
-	'domein',
+	// both declare ['referenceComponent', 'standard', 'applicationService',
+	// 'domain'] — these strings are the query parameters and the response keys of
+	// this app's own facet endpoint. They were Dutch until the vocabulary pass
+	// moved all four together; an earlier tranche translated exactly ONE of
+	// them, so the frontend sent `standard[]` to a backend still reading
+	// `standaard[]` and facet filtering by standard silently returned
+	// everything, with no error on either side. That is why they move as a SET.
+	'referenceComponent',
+	'standard',
+	'applicationService',
+	'domain',
 ]
 
 /**
@@ -39,7 +40,7 @@ export const FACET_DIMENSIONS = [
  * convention and the spec's documented query shape).
  *
  * @param {object} options Request options.
- * @param {object} [options.filters] Selected facet values keyed by dimension: `{ referentiecomponent: ['A', 'B'] }`.
+ * @param {object} [options.filters] Selected facet values keyed by dimension: `{ referenceComponent: ['A', 'B'] }`.
  * @param {string} [options.search] Free-text query.
  * @param {string} [options.organization] Organisation override.
  * @return {URLSearchParams} The query parameters.
@@ -80,7 +81,7 @@ export function buildFacetQueryParams({
  *
  * @param {string} schema `module` or `dienst`.
  * @param {object} [options] See `buildFacetQueryParams()`.
- * @return {Promise<object>} The facet response: `{ referentiecomponent, standaard, applicatieservice, domein, _meta }`.
+ * @return {Promise<object>} The facet response: `{ referenceComponent, standard, applicationService, domain, _meta }`.
  *
  * @spec openspec/specs/gemma-faceted-search/spec.md#requirement-facet-aggregation-endpoint-returns-gemma-dimension-counts
  */

src/services/facets.spec.js

@@ -29,10 +29,10 @@ jest.mock('@nextcloud/router', () => ({
 describe('facets.FACET_DIMENSIONS', () => {
 	it('lists all four GEMMA dimensions', () => {
 		expect(FACET_DIMENSIONS).toEqual([
-			'referentiecomponent',
-			'standaard',
-			'applicatieservice',
-			'domein',
+			'referenceComponent',
+			'standard',
+			'applicationService',
+			'domain',
 		])
 	})
 })
@@ -41,30 +41,30 @@ describe('facets.buildFacetQueryParams', () => {
 	it('builds repeated dimension[]= params for array-valued filters', () => {
 		const params = buildFacetQueryParams({
 			filters: {
-				referentiecomponent: [
+				referenceComponent: [
 					'Zaakregistratiecomponent',
 					'Klantcontactcomponent',
 				],
 			},
 		})
-		expect(params.getAll('referentiecomponent[]')).toEqual([
+		expect(params.getAll('referenceComponent[]')).toEqual([
 			'Zaakregistratiecomponent',
 			'Klantcontactcomponent',
 		])
 	})
 
 	it('omits a dimension entirely when its filter value is not an array', () => {
 		const params = buildFacetQueryParams({
-			filters: { referentiecomponent: 'not-an-array' },
+			filters: { referenceComponent: 'not-an-array' },
 		})
-		expect(params.has('referentiecomponent[]')).toBe(false)
+		expect(params.has('referenceComponent[]')).toBe(false)
 	})
 
 	it('drops blank/whitespace-only values within a dimension', () => {
 		const params = buildFacetQueryParams({
-			filters: { standaard: ['StUF-ZKN', '', '   '] },
+			filters: { standard: ['StUF-ZKN', '', '   '] },
 		})
-		expect(params.getAll('standaard[]')).toEqual(['StUF-ZKN'])
+		expect(params.getAll('standard[]')).toEqual(['StUF-ZKN'])
 	})
 
 	it('sets search only when non-blank', () => {
@@ -94,16 +94,16 @@ describe('facets.fetchFacets', () => {
 	it('requests GET /apps/softwarecatalog/api/facets/{schema} with the encoded schema and query params', async () => {
 		axios.get.mockResolvedValue({
 			data: {
-				referentiecomponent: [],
-				standaard: [],
-				applicatieservice: [],
-				domein: [],
+				referenceComponent: [],
+				standard: [],
+				applicationService: [],
+				domain: [],
 				_meta: {},
 			},
 		})
 
 		await fetchFacets('module', {
-			filters: { referentiecomponent: ['A'] },
+			filters: { referenceComponent: ['A'] },
 			search: 'zaak',
 		})
 
@@ -112,7 +112,7 @@ describe('facets.fetchFacets', () => {
 		)
 		const [calledUrl] = axios.get.mock.calls[0]
 		expect(calledUrl).toContain('/apps/softwarecatalog/api/facets/module?')
-		expect(calledUrl).toContain('referentiecomponent%5B%5D=A')
+		expect(calledUrl).toContain('referenceComponent%5B%5D=A')
 		expect(calledUrl).toContain('search=zaak')
 	})
 
@@ -127,10 +127,10 @@ describe('facets.fetchFacets', () => {
 
 	it('returns the response body', async () => {
 		const body = {
-			referentiecomponent: [{ value: 'A', label: 'A', count: 3 }],
-			standaard: [],
-			applicatieservice: [],
-			domein: [],
+			referenceComponent: [{ value: 'A', label: 'A', count: 3 }],
+			standard: [],
+			applicationService: [],
+			domain: [],
 			_meta: { totalMatched: 3 },
 		}
 		axios.get.mockResolvedValue({ data: body })