feat(website): remove lapisUrls from runtime config

`lapisUrls` is no longer injected into `runtime_config.json` — the
LAPIS URL for any organism is now derived as
`{backendUrl}/{organism}/lapis`, matching the backend proxy routes
added in the previous commit.

Changes:
- `runtimeConfig.ts`: remove `lapisUrls` field from `serviceUrls` Zod
  schema
- `config.ts`: rewrite `getLapisUrl()` to compute from `backendUrl`
  instead of reading a config map; no more runtime error on unknown
  organisms
- `GroupPage.tsx`: replace `clientConfig.lapisUrls[key]` (with null
  guard) with `getLapisUrl(clientConfig, key)`
- `SeqSetRecordsTableWithMetadata.tsx`: add `organisms: string[]` prop;
  iterate that list and compute each URL via `getLapisUrl` — removes the
  hacky `lapisUrls` dummy-organism filter
- `SeqSetItem.tsx`: thread `organisms` prop through to
  `SeqSetRecordsTableWithMetadata`
- `seqsets/[seqSetId].[version].astro`: pass
  `Object.keys(websiteConfig.organisms)` as `organisms`
- `api-documentation/index.astro`: compute LAPIS doc links from
  `backendUrl` + organism keys (already available as `organismKeys`)
- `loculus-info/index.ts`: compute `lapis` response field from
  `backendUrl` + organism keys instead of reading `lapisUrls`
- `_common-metadata.tpl`: remove `lapisUrls` from `publicRuntimeConfig`
- `loculus-website-config.yaml`: remove `lapisUrls` from serverSide
  block (URL is now computed client-side)
- test files: replace `testConfig.serverSide.lapisUrls[testOrganism]`
  with `getLapisUrl(testConfig.serverSide, testOrganism)`

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: fhennig

kubernetes/loculus/templates/_common-metadata.tpl

@@ -611,10 +611,7 @@ fields:
 
 {{- define "loculus.publicRuntimeConfig" }}
 {{- $backendUrl := include "loculus.backendUrl" . }}
-{{- $lapisUrlTemplate := printf "%s/%%organism%%/lapis" $backendUrl }}
-{{- $externalLapisUrlConfig := dict "lapisUrlTemplate" $lapisUrlTemplate "config" $.Values }}
             "backendUrl": "{{ $backendUrl }}",
-            "lapisUrls": {{- include "loculus.generateExternalLapisUrls" $externalLapisUrlConfig | fromYaml | toJson }},
             "keycloakUrl":  "{{ include "loculus.keycloakUrl" . }}"
 {{- end }}
 

kubernetes/loculus/templates/loculus-website-config.yaml

@@ -19,7 +19,6 @@ data:
             {{- else -}}
             "backendUrl": "http://loculus-backend-service:8079",
             {{- end }}
-            "lapisUrls": {{- include "loculus.generateInternalLapisUrlsViaBackend" . | fromYaml | toJson }},
             "keycloakUrl": "{{ if not .Values.disableWebsite -}}http://loculus-keycloak-service:8083{{ else -}}http://{{ $.Values.localHost }}:8083{{ end }}"
             {{- end }}
         },

website/src/components/SeqSetCitations/SeqSetItem.tsx

@@ -49,6 +49,7 @@ const SeqSetSectionEntry: FC<{ label: string; value: React.ReactNode }> = ({ lab
 
 type SeqSetItemProps = {
     clientConfig: ClientConfig;
+    organisms: string[];
     accessToken: string;
     seqSetAccessionVersion: string;
     seqSet: SeqSet;
@@ -63,6 +64,7 @@ type SeqSetItemProps = {
 
 const SeqSetItemInner: FC<SeqSetItemProps> = ({
     clientConfig,
+    organisms,
     accessToken,
     seqSetAccessionVersion,
     seqSet,
@@ -222,6 +224,7 @@ const SeqSetItemInner: FC<SeqSetItemProps> = ({
                 <SeqSetRecordsTableWithMetadata
                     seqSetRecords={getPaginatedSeqSetRecords()}
                     clientConfig={clientConfig}
+                    organisms={organisms}
                     fieldsToDisplay={fieldsToDisplay}
                     organismDisplayNames={organismDisplayNames}
                 />

website/src/components/SeqSetCitations/SeqSetRecordsTableWithMetadata.tsx

@@ -2,6 +2,7 @@ import { useQuery } from '@tanstack/react-query';
 import axios from 'axios';
 import { type FC, useMemo } from 'react';
 
+import { getLapisUrl } from '../../config';
 import { versionStatuses } from '../../types/lapis';
 import type { ClientConfig } from '../../types/runtimeConfig';
 import { type SeqSetRecord, SeqSetRecordType } from '../../types/seqSetCitation';
@@ -20,6 +21,7 @@ type FieldToDisplay = {
 type SeqSetRecordsTableWithMetadataProps = {
     seqSetRecords: SeqSetRecord[];
     clientConfig: ClientConfig;
+    organisms: string[];
     fieldsToDisplay?: FieldToDisplay[];
     sortByKey?: keyof SeqSetRecord;
     organismDisplayNames?: Record<string, string>;
@@ -46,6 +48,7 @@ async function queryLapisDetails(
 const fetchRecordsMetadata = async (
     records: SeqSetRecord[],
     clientConfig: ClientConfig,
+    organisms: string[],
     fieldsToDisplay: FieldToDisplay[],
 ): Promise<Map<string, RecordMetadata>> => {
     const accessions = records.map((record) => record.accession);
@@ -61,17 +64,11 @@ const fetchRecordsMetadata = async (
     // Extract just the field names for the API request
     const fields = fieldsToDisplay.map((f) => f.field);
 
-    // filter out "organism" as substring in lapisUrls as a hack to remove the dummy organisms
-    // #TODO: do this better, in a less hacky way
-    // But if we do try to query something that doesn't have the field its no huge problem it will just lead to a console error
-    const lapisUrlsWithoutDummies = Object.fromEntries(
-        Object.entries(clientConfig.lapisUrls).filter(([organism]) => !organism.includes('organism')),
-    );
-
     const metadataMap = new Map<string, RecordMetadata>();
 
     // Query all LAPIS instances in parallel
-    const lapisPromises = Object.entries(lapisUrlsWithoutDummies).map(async ([organism, lapisUrl]) => {
+    const lapisPromises = organisms.map(async (organism) => {
+        const lapisUrl = getLapisUrl(clientConfig, organism);
         const queries: Promise<{ data: Record<string, unknown>[]; keyField: string }>[] = [];
 
         // Query versioned accessions by accessionVersion
@@ -129,6 +126,7 @@ const SeqSetRecordsTableCell: FC<{ title: string; children: React.ReactNode }> =
 export const SeqSetRecordsTableWithMetadata: FC<SeqSetRecordsTableWithMetadataProps> = ({
     seqSetRecords,
     clientConfig,
+    organisms,
     fieldsToDisplay = [
         { field: 'geoLocCountry', displayName: 'Country' },
         { field: 'sampleCollectionDate', displayName: 'Collection date' },
@@ -138,8 +136,8 @@ export const SeqSetRecordsTableWithMetadata: FC<SeqSetRecordsTableWithMetadataPr
     organismDisplayNames = {},
 }) => {
     const { data: metadataMap, isLoading } = useQuery({
-        queryKey: ['seqset-records-metadata', seqSetRecords, clientConfig, fieldsToDisplay],
-        queryFn: () => fetchRecordsMetadata(seqSetRecords, clientConfig, fieldsToDisplay),
+        queryKey: ['seqset-records-metadata', seqSetRecords, clientConfig, organisms, fieldsToDisplay],
+        queryFn: () => fetchRecordsMetadata(seqSetRecords, clientConfig, organisms, fieldsToDisplay),
         staleTime: 5 * 60 * 1000, // 5 minutes
     });
 

website/src/components/SequenceDetailsPage/getTableData.spec.ts

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, test } from 'vitest';
 import { getTableData, type GetTableDataResult } from './getTableData.ts';
 import { type TableDataEntry } from './types.ts';
 import { mockRequest, testConfig, testOrganism } from '../../../vitest.setup.ts';
+import { getLapisUrl } from '../../config.ts';
 import { LapisClient } from '../../services/lapisClient.ts';
 import type { ProblemDetail } from '../../types/backend.ts';
 import {
@@ -56,7 +57,7 @@ const info = {
 
 const accessionVersion = 'accession';
 
-const lapisClient = LapisClient.create(testConfig.serverSide.lapisUrls[testOrganism], schema);
+const lapisClient = LapisClient.create(getLapisUrl(testConfig.serverSide, testOrganism), schema);
 
 describe('getTableData', () => {
     beforeEach(() => {

website/src/components/Submission/FileUpload/FolderUploadComponent.spec.tsx

@@ -41,7 +41,7 @@ const defaultProps = {
     },
     inputMode: 'bulk' as const,
     accessToken: 'test-token',
-    clientConfig: { backendUrl: 'http://test-backend', lapisUrls: {} },
+    clientConfig: { backendUrl: 'http://test-backend' },
     groupId: 1,
     setFileMapping: mockSetFileMapping,
     onError: mockOnError,

website/src/components/User/GroupPage.tsx

@@ -4,7 +4,7 @@ import { type FC, type FormEvent, useMemo, useState, type ReactNode } from 'reac
 
 import { CumulativeSubmissionsChart, type TimeSeriesData } from './CumulativeSubmissionsChart.tsx';
 import { getClientLogger } from '../../clientLogger.ts';
-import type { Organism } from '../../config.ts';
+import { getLapisUrl, type Organism } from '../../config.ts';
 import { useGroupPageHooks } from '../../hooks/useGroupOperations.ts';
 import { routes } from '../../routes/routes.ts';
 import type { ContinueSubmissionIntent } from '../../routes/routes.ts';
@@ -314,11 +314,7 @@ async function fetchSequenceCounts(groupId: number, clientConfig: ClientConfig,
     const counts: Record<string, number> = {};
     await Promise.all(
         organisms.map(async ({ key }) => {
-            const url = clientConfig.lapisUrls[key];
-            if (!url) {
-                counts[key] = 0;
-                return;
-            }
+            const url = getLapisUrl(clientConfig, key);
             try {
                 const response = await axios.post(`${url}/sample/aggregated`, {
                     [GROUP_ID_FIELD]: groupId,
@@ -346,11 +342,7 @@ async function fetchTimeSeriesData(
     const data: TimeSeriesData = {};
     await Promise.all(
         organisms.map(async ({ key }) => {
-            const url = clientConfig.lapisUrls[key];
-            if (!url) {
-                data[key] = [];
-                return;
-            }
+            const url = getLapisUrl(clientConfig, key);
             try {
                 const response = await axios.post(`${url}/sample/aggregated`, {
                     [GROUP_ID_FIELD]: groupId,

website/src/config.ts

@@ -239,10 +239,7 @@ export function getRuntimeConfig(): RuntimeConfig {
 }
 
 export function getLapisUrl(serviceConfig: ServiceUrls, organism: string): string {
-    if (!(organism in serviceConfig.lapisUrls)) {
-        throw new Error(`No lapis url configured for organism ${organism}`);
-    }
-    return serviceConfig.lapisUrls[organism];
+    return `${serviceConfig.backendUrl}/${organism}/lapis`;
 }
 
 export function getReferenceGenomes(organism: string): ReferenceGenomesInfo {

website/src/pages/api-documentation/index.astro

@@ -1,6 +1,6 @@
 ---
 import { authenticationApiDocsUrl } from './authenticationApiDocsUrl';
-import { dataUseTermsAreEnabled, getRuntimeConfig, getWebsiteConfig } from '../../config';
+import { dataUseTermsAreEnabled, getLapisUrl, getRuntimeConfig, getWebsiteConfig } from '../../config';
 import BaseLayout from '../../layouts/BaseLayout.astro';
 import { routes } from '../../routes/routes.ts';
 import { getAuthBaseUrl } from '../../utils/getAuthUrl';
@@ -82,22 +82,28 @@ const BUTTON_CLASS =
             <h2 class='text-xl font-semibold text-primary-400 mb-4'>LAPIS query engines</h2>
             <div class='space-y-4'>
                 {
-                    Object.entries(clientConfig.lapisUrls).map(([organism, url]) => (
-                        <a class={BUTTON_CLASS} href={url + '/swagger-ui/index.html'}>
-                            {organismToDisplayName[organism]} LAPIS API documentation
-                        </a>
-                    ))
+                    organismKeys.map((organism) => {
+                        const url = getLapisUrl(clientConfig, organism);
+                        return (
+                            <a class={BUTTON_CLASS} href={url + '/swagger-ui/index.html'}>
+                                {organismToDisplayName[organism]} LAPIS API documentation
+                            </a>
+                        );
+                    })
                 }
             </div>
             <div class='mt-8'>
                 <span class='font-medium'>URLs of LAPIS query engines:</span>
                 <ul class='list-disc ml-6'>
                     {
-                        Object.entries(clientConfig.lapisUrls).map(([organism, url]) => (
-                            <li>
-                                {organismToDisplayName[organism]}: <code>{url}</code>
-                            </li>
-                        ))
+                        organismKeys.map((organism) => {
+                            const url = getLapisUrl(clientConfig, organism);
+                            return (
+                                <li>
+                                    {organismToDisplayName[organism]}: <code>{url}</code>
+                                </li>
+                            );
+                        })
                     }
                 </ul>
             </div>

website/src/pages/loculus-info/index.ts

@@ -19,7 +19,9 @@ export const GET: APIRoute = async ({ request }) => {
     const response = {
         hosts: {
             backend: runtime.public.backendUrl,
-            lapis: runtime.public.lapisUrls,
+            lapis: Object.fromEntries(
+                Object.keys(website.organisms).map((org) => [org, `${runtime.public.backendUrl}/${org}/lapis`]),
+            ),
             keycloak: keycloakUrl,
             website: new URL(request.url).origin,
         },