Add relative path prefix support to routeFor utilities

Introduce a routePrefix store that allows consuming projects to inject
a path prefix (e.g., /projects/{projectId}) into all UI route functions.
The prefix is inserted between the SvelteKit base path and the route
path via a withPrefix helper that wraps the 12 root resolve() calls.
Leaf functions inherit the prefix automatically through the existing
string concatenation chain. Auth routes are excluded to avoid breaking
SSO flows.

Author: Alex-Tideman

src/lib/stores/route-prefix.ts

@@ -0,0 +1,5 @@
+import { get, writable } from 'svelte/store';
+
+export const routePrefix = writable<string>('');
+
+export const getRoutePrefix = (): string => get(routePrefix);

src/lib/utilities/route-for-base-path.test.ts

@@ -1,7 +1,9 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it } from 'vitest';
 
 import { base } from '$app/paths';
 
+import { routePrefix } from '$lib/stores/route-prefix';
+
 import * as routeForModule from './route-for';
 import {
   routeForArchivalEventHistory,
@@ -217,3 +219,173 @@ describe('routeFor functions should resolve the base path exactly once', () => {
     }
   });
 });
+
+describe('routeFor functions with prefix should resolve base + prefix correctly', () => {
+  const prefix = '/projects/my-project';
+
+  const namespaceParams = { namespace: 'default' };
+  const workflowParams = {
+    namespace: 'default',
+    workflow: 'wf-id',
+    run: 'run-id',
+  };
+  const scheduleParams = { namespace: 'default', scheduleId: 'sched-1' };
+  const activityParams = {
+    namespace: 'default',
+    activityId: 'act-1',
+    runId: 'run-1',
+  };
+
+  afterEach(() => {
+    routePrefix.set('');
+  });
+
+  const prefixedCases: [string, () => string | undefined][] = [
+    ['routeForNamespaces', () => routeForNamespaces()],
+    ['routeForNexus', () => routeForNexus()],
+    ['routeForNexusEndpoint', () => routeForNexusEndpoint('ep-1')],
+    ['routeForNexusEndpointEdit', () => routeForNexusEndpointEdit('ep-1')],
+    ['routeForNexusEndpointCreate', () => routeForNexusEndpointCreate()],
+    ['routeForNamespace', () => routeForNamespace(namespaceParams)],
+    ['routeForNamespaceSelector', () => routeForNamespaceSelector()],
+    ['routeForWorkflows', () => routeForWorkflows(namespaceParams)],
+    [
+      'routeForArchivalWorkflows',
+      () => routeForArchivalWorkflows(namespaceParams),
+    ],
+    ['routeForWorkflow', () => routeForWorkflow(workflowParams)],
+    ['routeForSchedules', () => routeForSchedules(namespaceParams)],
+    ['routeForScheduleCreate', () => routeForScheduleCreate(namespaceParams)],
+    ['routeForSchedule', () => routeForSchedule(scheduleParams)],
+    ['routeForScheduleEdit', () => routeForScheduleEdit(scheduleParams)],
+    [
+      'routeForArchivalEventHistory',
+      () => routeForArchivalEventHistory(workflowParams),
+    ],
+    [
+      'routeForEventHistoryEvent',
+      () => routeForEventHistoryEvent({ ...workflowParams, eventId: '1' }),
+    ],
+    ['routeForEventHistory', () => routeForEventHistory(workflowParams)],
+    ['routeForTimeline', () => routeForTimeline(workflowParams)],
+    ['routeForWorkers', () => routeForWorkers(workflowParams)],
+    [
+      'routeForWorkerDeployments',
+      () => routeForWorkerDeployments(namespaceParams),
+    ],
+    [
+      'routeForWorkerDeployment',
+      () =>
+        routeForWorkerDeployment({
+          namespace: 'default',
+          deployment: 'dep-1',
+        }),
+    ],
+    [
+      'routeForWorkerDeploymentVersion',
+      () =>
+        routeForWorkerDeploymentVersion({
+          namespace: 'default',
+          deployment: 'dep-1',
+          version: 'v1',
+        }),
+    ],
+    ['routeForRelationships', () => routeForRelationships(workflowParams)],
+    [
+      'routeForTaskQueue',
+      () => routeForTaskQueue({ namespace: 'default', queue: 'q-1' }),
+    ],
+    ['routeForCallStack', () => routeForCallStack(workflowParams)],
+    ['routeForWorkflowQuery', () => routeForWorkflowQuery(workflowParams)],
+    ['routeForUserMetadata', () => routeForUserMetadata(workflowParams)],
+    [
+      'routeForWorkflowSearchAttributes',
+      () => routeForWorkflowSearchAttributes(workflowParams),
+    ],
+    ['routeForWorkflowMemo', () => routeForWorkflowMemo(workflowParams)],
+    ['routeForWorkflowUpdate', () => routeForWorkflowUpdate(workflowParams)],
+    [
+      'routeForPendingActivities',
+      () => routeForPendingActivities(workflowParams),
+    ],
+    ['routeForNexusLinks', () => routeForNexusLinks(workflowParams)],
+    ['routeForEventHistoryImport', () => routeForEventHistoryImport()],
+    ['routeForBatchOperations', () => routeForBatchOperations(namespaceParams)],
+    [
+      'routeForBatchOperation',
+      () => routeForBatchOperation({ namespace: 'default', jobId: 'job-1' }),
+    ],
+    [
+      'routeForStandaloneActivities',
+      () => routeForStandaloneActivities(namespaceParams),
+    ],
+    [
+      'routeForStandaloneActivitiesWithQuery',
+      () =>
+        routeForStandaloneActivitiesWithQuery(namespaceParams, 'test-query'),
+    ],
+    [
+      'routeForStartStandaloneActivity',
+      () => routeForStartStandaloneActivity(namespaceParams),
+    ],
+    [
+      'routeForStandaloneActivityDetails',
+      () => routeForStandaloneActivityDetails(activityParams),
+    ],
+    [
+      'routeForStandaloneActivityWorkers',
+      () => routeForStandaloneActivityWorkers(activityParams),
+    ],
+    [
+      'routeForStandaloneActivitySearchAttributes',
+      () => routeForStandaloneActivitySearchAttributes(activityParams),
+    ],
+    [
+      'routeForStandaloneActivityMetadata',
+      () => routeForStandaloneActivityMetadata(activityParams),
+    ],
+    [
+      'routeForWorkflowStart',
+      () => routeForWorkflowStart({ namespace: 'default' }),
+    ],
+    [
+      'routeForWorkflowsWithQuery',
+      () => routeForWorkflowsWithQuery({ namespace: 'default', query: 'test' }),
+    ],
+  ];
+
+  const authCases: [string, () => string | undefined][] = [
+    [
+      'routeForAuthentication',
+      () =>
+        routeForAuthentication({
+          settings: { auth: {}, baseUrl: 'https://example.com' },
+          searchParams: new URLSearchParams(),
+        }),
+    ],
+    ['routeForLoginPage', () => routeForLoginPage('', false)],
+  ];
+
+  it.each(prefixedCases)(
+    '%s should include base + prefix when prefix is set',
+    (_name, fn) => {
+      routePrefix.set(prefix);
+      const result = fn();
+      expect(typeof result).toBe('string');
+      expect(result).toMatch(new RegExp(`^${base}${prefix}`));
+      expect(result).not.toMatch(
+        new RegExp(`${base}${prefix}${base}${prefix}`),
+      );
+    },
+  );
+
+  it.each(authCases)(
+    '%s should NOT include prefix (auth routes excluded)',
+    (_name, fn) => {
+      routePrefix.set(prefix);
+      const result = fn();
+      expect(typeof result).toBe('string');
+      expect(result).not.toContain(prefix);
+    },
+  );
+});

src/lib/utilities/route-for.test.ts

@@ -8,6 +8,7 @@ import type {
   EventSortOrder,
   WorkflowViewPreference,
 } from '$lib/stores/event-view';
+import { routePrefix } from '$lib/stores/route-prefix';
 
 import {
   baseRouteForWorkflow,
@@ -24,6 +25,7 @@ import {
   routeForLoginPage,
   routeForNamespace,
   routeForNamespaces,
+  routeForNexus,
   routeForPendingActivities,
   routeForSchedule,
   routeForScheduleCreate,
@@ -530,3 +532,79 @@ describe('routeForWorkflow', () => {
     expect(path).not.toContain('sort=descending');
   });
 });
+
+describe('routeFor with prefix', () => {
+  const prefix = '/projects/my-project';
+
+  afterEach(() => {
+    routePrefix.set('');
+  });
+
+  it('should prepend prefix to root route', () => {
+    routePrefix.set(prefix);
+    expect(routeForNamespaces()).toBe(`${base}${prefix}/namespaces`);
+  });
+
+  it('should prepend prefix to namespace route', () => {
+    routePrefix.set(prefix);
+    expect(routeForNamespace({ namespace: 'default' })).toBe(
+      `${base}${prefix}/namespaces/default`,
+    );
+  });
+
+  it('should propagate prefix through leaf functions', () => {
+    routePrefix.set(prefix);
+    expect(routeForWorkflows({ namespace: 'default' })).toBe(
+      `${base}${prefix}/namespaces/default/workflows`,
+    );
+  });
+
+  it('should propagate prefix through deep leaf functions', () => {
+    routePrefix.set(prefix);
+    expect(
+      routeForCallStack({
+        namespace: 'default',
+        workflow: 'abc',
+        run: 'def',
+      }),
+    ).toBe(`${base}${prefix}/namespaces/default/workflows/abc/def/call-stack`);
+  });
+
+  it('should propagate prefix to nexus routes', () => {
+    routePrefix.set(prefix);
+    expect(routeForNexus()).toBe(`${base}${prefix}/nexus`);
+  });
+
+  it('should propagate prefix to schedule routes', () => {
+    routePrefix.set(prefix);
+    expect(routeForSchedules({ namespace: 'default' })).toBe(
+      `${base}${prefix}/namespaces/default/schedules`,
+    );
+  });
+
+  it('should not apply prefix when store is empty', () => {
+    routePrefix.set('');
+    expect(routeForNamespaces()).toBe(`${base}/namespaces`);
+  });
+
+  it('should not apply prefix to auth routes', () => {
+    routePrefix.set(prefix);
+    const settings = { auth: {}, baseUrl: 'https://localhost' };
+    const searchParams = new URLSearchParams();
+    const sso = routeForAuthentication({ settings, searchParams });
+    expect(sso).not.toContain(prefix);
+  });
+
+  it('should not apply prefix to login page', () => {
+    routePrefix.set(prefix);
+    const login = routeForLoginPage('', false);
+    expect(login).not.toContain(prefix);
+  });
+
+  it('should revert to default behavior when prefix is cleared', () => {
+    routePrefix.set(prefix);
+    expect(routeForNamespaces()).toBe(`${base}${prefix}/namespaces`);
+    routePrefix.set('');
+    expect(routeForNamespaces()).toBe(`${base}/namespaces`);
+  });
+});