Restructures frontend to a feature-based folder layout
Continuous Integration / config (pull_request) Successful in 11s
Continuous Integration / changes (pull_request) Successful in 21s
Continuous Integration / backend-build (pull_request) Skipped
Continuous Integration / backend-test (pull_request) Skipped
Continuous Integration / vulnerability-scan (pull_request) Skipped
Continuous Integration / frontend-prepare (pull_request) Successful in 1m37s
Continuous Integration / frontend-build (pull_request) Successful in 2m12s
Continuous Integration / frontend-test (pull_request) Successful in 4m42s
Continuous Integration / frontend-lint (pull_request) Successful in 2m2s
Continuous Integration / publish-production (pull_request) Skipped
Continuous Integration / deploy-production (pull_request) Skipped
Continuous Integration / publish-test (pull_request) Successful in 6m51s
Continuous Integration / deploy-test (pull_request) Skipped

Groups auth, setup, invitation, profile, users, cms, availability and
system code (services/hooks, components, schemas, mocks, pages) under
src/features/<name> instead of splitting by technical layer (api/,
components/, lib/schemas/, mocks/, pages/). Renames the old
connection-oriented `api` layer to `services` per feature, and splits
the monolithic api/types.ts into per-feature types.ts files (with
ProblemDetails/ApiResult merged into lib/api-client.ts as shared
infra). Layout-agnostic code (ui primitives, app shell, i18n, test
utils, lib) stays at the top level.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
2026-07-31 22:30:37 +02:00
co-authored by Claude Sonnet 5
parent 650cf09cfa
commit 11ec08aac3
83 changed files with 249 additions and 254 deletions
@@ -0,0 +1,100 @@
import { screen } from '@testing-library/react';
import { describe, expect, it } from 'vitest';
import { renderWithProviders } from '@/test/utils';
import { AvailabilityStatusBadge } from './AvailabilityStatusBadge';
describe('AvailabilityStatusBadge', () => {
it('renders Available status with green styling', () => {
renderWithProviders(<AvailabilityStatusBadge status="Available" />);
const label = screen.getByTestId('availability-status-label');
expect(label).toHaveTextContent('Available');
const badge = screen.getByTestId('availability-badge');
expect(badge.querySelector('.bg-green-100')).toBeTruthy();
});
it('renders Maintenance status with amber styling', () => {
renderWithProviders(<AvailabilityStatusBadge status="Maintenance" />);
const label = screen.getByTestId('availability-status-label');
expect(label).toHaveTextContent('Maintenance');
const badge = screen.getByTestId('availability-badge');
expect(badge.querySelector('.bg-amber-100')).toBeTruthy();
});
it('renders Unavailable status with red styling', () => {
renderWithProviders(<AvailabilityStatusBadge status="NotAvailable" />);
const label = screen.getByTestId('availability-status-label');
expect(label).toHaveTextContent('Unavailable');
const badge = screen.getByTestId('availability-badge');
expect(badge.querySelector('.bg-red-100')).toBeTruthy();
});
it('Available always shows the default translated message, ignoring any backend message', () => {
renderWithProviders(<AvailabilityStatusBadge status="Available" message="ignored" />);
expect(screen.getByTestId('availability-message')).toHaveTextContent(
'System is running normally.',
);
});
it('Available shows the default translated message when no message is provided', () => {
renderWithProviders(<AvailabilityStatusBadge status="Available" />);
expect(screen.getByTestId('availability-message')).toHaveTextContent(
'System is running normally.',
);
});
it('Maintenance shows a custom reason when provided', () => {
renderWithProviders(
<AvailabilityStatusBadge status="Maintenance" message="Scheduled downtime until 18:00" />,
);
expect(screen.getByTestId('availability-message')).toHaveTextContent(
'Scheduled downtime until 18:00',
);
});
it('Maintenance falls back to default translated message when no reason is provided', () => {
renderWithProviders(<AvailabilityStatusBadge status="Maintenance" />);
expect(screen.getByTestId('availability-message')).toHaveTextContent(
'System is undergoing scheduled maintenance.',
);
});
it('Unavailable shows a custom reason when provided', () => {
renderWithProviders(
<AvailabilityStatusBadge status="NotAvailable" message="Emergency shutdown in progress" />,
);
expect(screen.getByTestId('availability-message')).toHaveTextContent(
'Emergency shutdown in progress',
);
});
it('Unavailable falls back to default translated message when no reason is provided', () => {
renderWithProviders(<AvailabilityStatusBadge status="NotAvailable" />);
expect(screen.getByTestId('availability-message')).toHaveTextContent(
'System is currently unavailable.',
);
});
it('shows stale indicator when stale={true}', () => {
renderWithProviders(<AvailabilityStatusBadge status="Available" stale={true} />);
expect(screen.getByTestId('availability-stale-indicator')).toBeInTheDocument();
});
it('hides stale indicator when stale is omitted (default false)', () => {
renderWithProviders(<AvailabilityStatusBadge status="Available" />);
expect(screen.queryByTestId('availability-stale-indicator')).toBeNull();
});
});
@@ -0,0 +1,82 @@
import { AlertTriangle, CheckCircle, Clock, XCircle } from 'lucide-react';
import { useTranslation } from 'react-i18next';
import type { AvailabilityStatus } from '@/features/availability/services/types';
interface AvailabilityStatusBadgeProps {
status: AvailabilityStatus;
message?: string;
stale?: boolean;
}
const STATUS_CONFIG: Record<
AvailabilityStatus,
{
labelKey: string;
defaultMessageKey: string;
/** When true the default translated message is always shown, ignoring any backend message. */
alwaysDefault: boolean;
colorClass: string;
Icon: React.ComponentType<{ className?: string }>;
}
> = {
Available: {
labelKey: 'availability.available',
defaultMessageKey: 'availability.messageAvailable',
alwaysDefault: true,
colorClass: 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200',
Icon: CheckCircle,
},
Maintenance: {
labelKey: 'availability.maintenance',
defaultMessageKey: 'availability.messageMaintenance',
alwaysDefault: false,
colorClass: 'bg-amber-100 text-amber-800 dark:bg-amber-900 dark:text-amber-200',
Icon: AlertTriangle,
},
NotAvailable: {
labelKey: 'availability.unavailable',
defaultMessageKey: 'availability.messageUnavailable',
alwaysDefault: false,
colorClass: 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200',
Icon: XCircle,
},
};
export function AvailabilityStatusBadge({
status,
message,
stale = false,
}: AvailabilityStatusBadgeProps) {
const { t } = useTranslation();
const { labelKey, defaultMessageKey, alwaysDefault, colorClass, Icon } = STATUS_CONFIG[status];
const displayMessage = alwaysDefault ? t(defaultMessageKey) : (message || t(defaultMessageKey));
return (
<div
data-testid="availability-badge"
className={stale ? 'rounded-lg border-2 border-dashed border-amber-400 p-3' : undefined}
>
<div className={`inline-flex items-center gap-2 rounded-full px-3 py-1 text-sm font-medium ${colorClass}`}>
<Icon className="size-4" />
<span data-testid="availability-status-label">{t(labelKey)}</span>
</div>
<p
data-testid="availability-message"
className="mt-2 text-sm text-muted-foreground"
>
{displayMessage}
</p>
{stale && (
<div
data-testid="availability-stale-indicator"
className="mt-2 flex items-center gap-1 text-xs text-amber-600 dark:text-amber-400"
>
<Clock className="size-3" />
<span>{t('availability.staleLabel')}</span>
</div>
)}
</div>
);
}
@@ -0,0 +1,14 @@
import { http, HttpResponse } from 'msw';
export const availabilityHandlers = [
http.get('*/Availability/status', () =>
HttpResponse.json({
status: 'Available',
checkedAt: new Date().toISOString(),
message: '',
isMasterControlled: false,
}),
),
http.post('*/Availability/admin/status', () => new HttpResponse(null, { status: 200 })),
];
@@ -0,0 +1,9 @@
export type AvailabilityStatus = 'Available' | 'Maintenance' | 'NotAvailable';
export interface AvailabilityResponse {
status: AvailabilityStatus;
checkedAt: string; // ISO 8601
message: string;
/** True when a Master CMS has taken control of this instance's gate — the local status cannot be changed here. */
isMasterControlled: boolean;
}
@@ -0,0 +1,73 @@
import { renderHook, waitFor } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { http, HttpResponse } from 'msw';
import { createElement } from 'react';
import { describe, expect, it } from 'vitest';
import { server } from '@/mocks/server';
import { API_BASE } from '@/features/auth/mocks/fixtures';
import { useAvailabilityStatus } from './useAvailability';
function createWrapper() {
const queryClient = new QueryClient({
defaultOptions: { queries: { retry: false } },
});
return ({ children }: { children: React.ReactNode }) =>
createElement(QueryClientProvider, { client: queryClient }, children);
}
const AVAILABILITY_URL = `${API_BASE}/api/v1/Availability/status`;
describe('useAvailabilityStatus', () => {
it('starts in loading state', () => {
const { result } = renderHook(() => useAvailabilityStatus(), {
wrapper: createWrapper(),
});
expect(result.current.isLoading).toBe(true);
expect(result.current.data).toBeUndefined();
});
it('returns data on successful fetch', async () => {
const { result } = renderHook(() => useAvailabilityStatus(), {
wrapper: createWrapper(),
});
await waitFor(() => expect(result.current.isLoading).toBe(false));
expect(result.current.isError).toBe(false);
expect(result.current.data).toMatchObject({
status: 'Available',
message: '',
});
expect(typeof result.current.data?.checkedAt).toBe('string');
});
it('enters error state when the server returns 5xx', async () => {
server.use(
http.get(AVAILABILITY_URL, () =>
HttpResponse.json(
{ title: 'Internal Server Error', status: 500 },
{ status: 500 },
),
),
);
const { result } = renderHook(() => useAvailabilityStatus(), {
wrapper: createWrapper(),
});
await waitFor(() => expect(result.current.isLoading).toBe(false));
expect(result.current.isError).toBe(true);
expect(result.current.data).toBeUndefined();
});
it('exposes a refetch function', async () => {
const { result } = renderHook(() => useAvailabilityStatus(), {
wrapper: createWrapper(),
});
await waitFor(() => expect(result.current.isLoading).toBe(false));
expect(typeof result.current.refetch).toBe('function');
});
});
@@ -0,0 +1,24 @@
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { api } from '@/lib/api-client';
import type { AvailabilityResponse, AvailabilityStatus } from './types';
export interface UpdateAvailabilityPayload {
newStatus: AvailabilityStatus;
reason: string;
}
export function useAvailabilityStatus() {
return useQuery<AvailabilityResponse, Error>({
queryKey: ['availability', 'status'],
queryFn: () => api.get<AvailabilityResponse>('/api/v1/Availability/status'),
staleTime: 30_000,
});
}
export function useUpdateAvailability() {
const queryClient = useQueryClient();
return useMutation<void, Error, UpdateAvailabilityPayload>({
mutationFn: (data) => api.post<void>('/api/v1/Availability/admin/status', data),
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['availability', 'status'] }),
});
}