FJurmanovic/acc-server-manager-web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

introduce zod schemas

Browse Source
This commit is contained in:
Fran Jurmanović
2025-09-24 20:07:57 +02:00
parent 0cbc6935db
commit 996f1a1385
43 changed files with 798 additions and 559 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/lib/api/server/auth.ts
View File

@@ -1,17 +1,26 @@
import { User } from '@/lib/types';
import {
Login,
LoginResponse,
loginResponseSchema,
loginSchema,
loginTokenSchema,
User,
userSchema
} from '@/lib/schemas';
import { fetchServerAPI } from './base';
const BASE_URL = process.env.API_BASE_URL || 'http://localhost:8080';
const authRoute = '/auth';
export async function loginUser(username: string, password: string) {
export async function loginUser(login: Login): Promise<LoginResponse> {
const validatedLogin = loginSchema.parse(login);
const response = await fetch(`${BASE_URL}${authRoute}/login`, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({ username, password })
body: JSON.stringify(validatedLogin)
});
if (!response.ok) {
@@ -22,16 +31,18 @@ export async function loginUser(username: string, password: string) {
throw new Error(`Login failed: ${response.statusText}`);
}
const { token } = await response.json();
const rawData = await response.json();
const { token } = loginTokenSchema.parse(rawData);
const userResponse = await getCurrentUser(token);
return { token, user: userResponse };
return loginResponseSchema.parse({ token, user: userResponse });
}
export async function getCurrentUser(token: string): Promise<User> {
const response = await fetchServerAPI<User>(`${authRoute}/me`, token);
return response.data!;
return userSchema.parse(response.data);
}
export async function getOpenToken(token: string): Promise<string> {
@@ -40,5 +51,5 @@ export async function getOpenToken(token: string): Promise<string> {
token,
'POST'
);
return response.data!.token;
return loginTokenSchema.parse(response.data).token;
}

23
src/lib/api/server/configuration.ts
View File

@@ -1,5 +1,12 @@
import { fetchServerAPI } from './base';
import type { Configurations, ConfigFile, Config } from '@/lib/types/config';
import {
type Configurations,
type Config,
ConfigFile,
configurationsSchema,
configSchemaMap
} from '@/lib/schemas/config';
import * as z from 'zod';
const serverRoute = '/server';
@@ -8,7 +15,15 @@ export async function getServerConfigurations(
serverId: string
): Promise<Configurations> {
const response = await fetchServerAPI<Configurations>(`${serverRoute}/${serverId}/config`, token);
return response.data!;
return configurationsSchema.parse(response.data);
}
export function validateConfig(
configType: ConfigFile,
data: unknown
): z.infer<(typeof configSchemaMap)[typeof configType]> {
const schema = configSchemaMap[configType];
return schema.parse(data);
}
export async function getServerConfiguration(
@@ -20,7 +35,7 @@ export async function getServerConfiguration(
`${serverRoute}/${serverId}/config/${configType}`,
token
);
return response.data!;
return validateConfig(configType, response.data);
}
export async function updateServerConfiguration(
@@ -31,7 +46,7 @@ export async function updateServerConfiguration(
restart = false
): Promise<void> {
await fetchServerAPI(`${serverRoute}/${serverId}/config/${configType}`, token, 'PUT', {
...config,
...validateConfig(configType, config),
restart
});
}

23
src/lib/api/server/lookups.ts
View File

@@ -1,21 +1,32 @@
import { fetchServerAPI } from './base';
import { Track, CarModel, CupCategory, DriverCategory, SessionType } from '@/lib/types';
import {
Track,
CarModel,
CupCategory,
DriverCategory,
SessionType,
trackSchema,
carModelSchema,
cupCategorySchema,
driverCategorySchema,
sessionTypeSchema
} from '@/lib/schemas';
const lookupRoute = '/lookup';
export async function getTracks(token: string): Promise<Track[]> {
const response = await fetchServerAPI<Track[]>(`${lookupRoute}/tracks`, token);
return response.data!;
return trackSchema.array().parse(response.data);
}
export async function getCarModels(token: string): Promise<CarModel[]> {
const response = await fetchServerAPI<CarModel[]>(`${lookupRoute}/car-models`, token);
return response.data!;
return carModelSchema.array().parse(response.data);
}
export async function getCupCategories(token: string): Promise<CupCategory[]> {
const response = await fetchServerAPI<CupCategory[]>(`${lookupRoute}/cup-categories`, token);
return response.data!;
return cupCategorySchema.array().parse(response.data);
}
export async function getDriverCategories(token: string): Promise<DriverCategory[]> {
@@ -23,10 +34,10 @@ export async function getDriverCategories(token: string): Promise<DriverCategory
`${lookupRoute}/driver-categories`,
token
);
return response.data!;
return driverCategorySchema.array().parse(response.data);
}
export async function getSessionTypes(token: string): Promise<SessionType[]> {
const response = await fetchServerAPI<SessionType[]>(`${lookupRoute}/session-types`, token);
return response.data!;
return sessionTypeSchema.array().parse(response.data);
}

25
src/lib/api/server/membership.ts
View File

@@ -1,5 +1,6 @@
import { use } from 'react';
import { fetchServerAPI } from './base';
import { User, Role } from '@/lib/types';
import { User, Role, userSchema, UserCreate, userCreateSchema, roleSchema } from '@/lib/schemas';
export interface UserListParams {
username?: string;
@@ -25,27 +26,29 @@ export async function getUsers(token: string, params: UserListParams = {}): Prom
const endpoint = `${membershipRoute}${queryString ? `?${queryString}` : ''}`;
const response = await fetchServerAPI<User[]>(endpoint, token);
return response.data!;
return userSchema.array().parse(response.data);
}
export async function createUser(
token: string,
userData: { username: string; password: string; role: string }
): Promise<void> {
await fetchServerAPI(membershipRoute, token, 'POST', userData);
export async function createUser(token: string, userData: UserCreate): Promise<void> {
await fetchServerAPI(membershipRoute, token, 'POST', userCreateSchema.parse(userData));
}
export async function getUserById(token: string, userId: string): Promise<User> {
const response = await fetchServerAPI<User>(`${membershipRoute}/${userId}`, token);
return response.data!;
return userSchema.parse(response.data);
}
export async function updateUser(
token: string,
userId: string,
userData: Partial<User>
userData: Partial<UserCreate>
): Promise<void> {
await fetchServerAPI(`${membershipRoute}/${userId}`, token, 'PUT', userData);
await fetchServerAPI(
`${membershipRoute}/${userId}`,
token,
'PUT',
userCreateSchema.parse(userData)
);
}
export async function deleteUser(token: string, userId: string): Promise<void> {
@@ -54,5 +57,5 @@ export async function deleteUser(token: string, userId: string): Promise<void> {
export async function getRoles(token: string): Promise<Role[]> {
const response = await fetchServerAPI<Role[]>(`${membershipRoute}/roles`, token);
return response.data!;
return roleSchema.array().parse(response.data);
}

10
src/lib/api/server/servers.ts
View File

@@ -1,16 +1,16 @@
import { fetchServerAPI } from './base';
import { Server, ServiceStatus } from '@/lib/types/server';
import { Server, serverSchema, ServiceStatus, serviceStatusSchema } from '@/lib/schemas/server';
const serverRoute = '/server';
export async function getServers(token: string): Promise<Server[]> {
const response = await fetchServerAPI<Server[]>(serverRoute, token);
return response.data!;
return serverSchema.array().parse(response.data);
}
export async function getServer(token: string, serverId: string): Promise<Server> {
const response = await fetchServerAPI<Server>(`${serverRoute}/${serverId}`, token);
return response.data!;
return serverSchema.parse(response.data);
}
export async function restartService(token: string, serverId: string): Promise<void> {
@@ -27,12 +27,12 @@ export async function stopService(token: string, serverId: string): Promise<void
export async function getServiceStatus(token: string, serverId: string): Promise<ServiceStatus> {
const response = await fetchServerAPI<ServiceStatus>(`${serverRoute}/${serverId}/service`, token);
return response.data!;
return serviceStatusSchema.parse(response.data);
}
export async function createServer(token: string, name: string): Promise<Server> {
const response = await fetchServerAPI<Server>(serverRoute, token, 'POST', { name });
return response.data!;
return serverSchema.parse(response.data);
}
export async function deleteServer(token: string, serverId: string): Promise<void> {

13
src/lib/api/server/statistics.ts
View File

@@ -1,17 +1,22 @@
import { fetchServerAPI } from './base';
import type { StateHistoryStats } from '@/lib/types/statistics';
import {
StateHistoryStatsFilter,
stateHistoryStatsFilterSchema,
stateHistoryStatsSchema,
type StateHistoryStats
} from '@/lib/schemas/statistics';
const serverRoute = '/server';
export async function getServerStatistics(
token: string,
serverId: string,
startDate: string,
endDate: string
filters: StateHistoryStatsFilter
): Promise<StateHistoryStats> {
const { startDate, endDate } = stateHistoryStatsFilterSchema.parse(filters);
const response = await fetchServerAPI<StateHistoryStats>(
`${serverRoute}/${serverId}/state-history/statistics?start_date=${startDate}&end_date=${endDate}`,
token
);
return response.data!;
return stateHistoryStatsSchema.parse(response.data);
}