[FE-TYPE-002] fe-type: Add Zod schemas for all API responses
- Created comprehensive Zod schemas (apiSchemas.ts) for: * User, Track, Playlist, Conversation, Message * Session, AuditLog, Notification * PaginationData, ApiError, ApiResponse - Added validation utilities: * validateApiResponse: Validate and normalize responses * safeValidateApiResponse: Safe validation with error handling * validateApiResponseArray: Validate arrays of items * validatePaginatedResponse: Validate paginated responses - Integrated validation into API client interceptor - Created validatedApiClient for type-safe API calls - Automatic ID normalization during validation - Comprehensive test suite (13 tests, all passing) - Ensures runtime type safety for all API responses
This commit is contained in:
senke
parent
aba18183b8
commit
92f29ddcac
5 changed files with 881 additions and 2 deletions
|
|
@ -9156,7 +9156,7 @@
|
|||
"description": "Create Zod schemas to validate API responses at runtime",
|
||||
"owner": "frontend",
|
||||
"estimated_hours": 8,
|
||||
"status": "todo",
|
||||
"status": "completed",
|
||||
"files_involved": [],
|
||||
"implementation_steps": [
|
||||
{
|
||||
|
|
@ -9177,7 +9177,8 @@
|
|||
"Unit tests",
|
||||
"Integration tests"
|
||||
],
|
||||
"notes": ""
|
||||
"notes": "Created comprehensive Zod schemas for all API response types. Implemented schemas for User, Track, Playlist, Conversation, Message, Session, AuditLog, Notification, and more. Added validation utilities (validateApiResponse, safeValidateApiResponse, validateApiResponseArray, validatePaginatedResponse). Integrated validation into API client interceptor. Created validatedApiClient for type-safe API calls with automatic validation. All tests passing (13/13).",
|
||||
"completed_at": "2025-12-25T14:30:55.148798Z"
|
||||
},
|
||||
{
|
||||
"id": "FE-TYPE-003",
|
||||
|
|
|
|||
314
apps/web/src/schemas/apiSchemas.test.ts
Normal file
314
apps/web/src/schemas/apiSchemas.test.ts
Normal file
|
|
@ -0,0 +1,314 @@
|
|||
/**
|
||||
* Tests for API Schemas
|
||||
* FE-TYPE-002: Test Zod schema validation for API responses
|
||||
*/
|
||||
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import {
|
||||
userSchema,
|
||||
trackSchema,
|
||||
playlistSchema,
|
||||
conversationSchema,
|
||||
messageSchema,
|
||||
validateApiResponse,
|
||||
safeValidateApiResponse,
|
||||
validateApiResponseArray,
|
||||
validatePaginatedResponse,
|
||||
} from './apiSchemas';
|
||||
|
||||
describe('apiSchemas', () => {
|
||||
describe('userSchema', () => {
|
||||
it('should validate valid user', () => {
|
||||
const validUser = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
username: 'testuser',
|
||||
email: 'test@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = userSchema.safeParse(validUser);
|
||||
expect(result.success).toBe(true);
|
||||
});
|
||||
|
||||
it('should reject invalid UUID', () => {
|
||||
const invalidUser = {
|
||||
id: 'not-a-uuid',
|
||||
username: 'testuser',
|
||||
email: 'test@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = userSchema.safeParse(invalidUser);
|
||||
expect(result.success).toBe(false);
|
||||
});
|
||||
|
||||
it('should reject invalid email', () => {
|
||||
const invalidUser = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
username: 'testuser',
|
||||
email: 'not-an-email',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = userSchema.safeParse(invalidUser);
|
||||
expect(result.success).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('trackSchema', () => {
|
||||
it('should validate valid track', () => {
|
||||
const validTrack = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
creator_id: '123e4567-e89b-12d3-a456-426614174001',
|
||||
title: 'Test Track',
|
||||
artist: 'Test Artist',
|
||||
album: 'Test Album',
|
||||
duration: 180,
|
||||
genre: 'Rock',
|
||||
year: 2024,
|
||||
file_path: '/path/to/file.mp3',
|
||||
file_size: 5000000,
|
||||
format: 'mp3',
|
||||
bitrate: 320,
|
||||
sample_rate: 44100,
|
||||
is_public: true,
|
||||
status: 'completed',
|
||||
stream_status: 'ready',
|
||||
play_count: 0,
|
||||
like_count: 0,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = trackSchema.safeParse(validTrack);
|
||||
expect(result.success).toBe(true);
|
||||
});
|
||||
|
||||
it('should reject negative duration', () => {
|
||||
const invalidTrack = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
creator_id: '123e4567-e89b-12d3-a456-426614174001',
|
||||
title: 'Test Track',
|
||||
artist: 'Test Artist',
|
||||
album: 'Test Album',
|
||||
duration: -10,
|
||||
genre: 'Rock',
|
||||
year: 2024,
|
||||
file_path: '/path/to/file.mp3',
|
||||
file_size: 5000000,
|
||||
format: 'mp3',
|
||||
bitrate: 320,
|
||||
sample_rate: 44100,
|
||||
is_public: true,
|
||||
status: 'completed',
|
||||
stream_status: 'ready',
|
||||
play_count: 0,
|
||||
like_count: 0,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = trackSchema.safeParse(invalidTrack);
|
||||
expect(result.success).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('playlistSchema', () => {
|
||||
it('should validate valid playlist', () => {
|
||||
const validPlaylist = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
user_id: '123e4567-e89b-12d3-a456-426614174001',
|
||||
title: 'Test Playlist',
|
||||
is_public: true,
|
||||
track_count: 10,
|
||||
follower_count: 5,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = playlistSchema.safeParse(validPlaylist);
|
||||
expect(result.success).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('conversationSchema', () => {
|
||||
it('should validate valid conversation', () => {
|
||||
const validConversation = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
name: 'Test Conversation',
|
||||
type: 'group',
|
||||
creator_id: '123e4567-e89b-12d3-a456-426614174001',
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = conversationSchema.safeParse(validConversation);
|
||||
expect(result.success).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('validateApiResponse', () => {
|
||||
it('should validate and return data', () => {
|
||||
const validUser = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
username: 'testuser',
|
||||
email: 'test@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = validateApiResponse(userSchema, validUser);
|
||||
expect(result.id).toBe(validUser.id);
|
||||
expect(result.username).toBe(validUser.username);
|
||||
});
|
||||
|
||||
it('should throw on invalid data', () => {
|
||||
const invalidUser = {
|
||||
id: 'not-a-uuid',
|
||||
username: 'testuser',
|
||||
email: 'test@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
expect(() => validateApiResponse(userSchema, invalidUser)).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('safeValidateApiResponse', () => {
|
||||
it('should return success for valid data', () => {
|
||||
const validUser = {
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
username: 'testuser',
|
||||
email: 'test@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = safeValidateApiResponse(userSchema, validUser);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.data).toBeDefined();
|
||||
});
|
||||
|
||||
it('should return error for invalid data', () => {
|
||||
const invalidUser = {
|
||||
id: 'not-a-uuid',
|
||||
username: 'testuser',
|
||||
email: 'test@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
};
|
||||
|
||||
const result = safeValidateApiResponse(userSchema, invalidUser);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.error).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('validateApiResponseArray', () => {
|
||||
it('should validate array of items', () => {
|
||||
const validUsers = [
|
||||
{
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
username: 'user1',
|
||||
email: 'user1@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
},
|
||||
{
|
||||
id: '123e4567-e89b-12d3-a456-426614174001',
|
||||
username: 'user2',
|
||||
email: 'user2@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
},
|
||||
];
|
||||
|
||||
const result = validateApiResponseArray(userSchema, validUsers);
|
||||
expect(result.length).toBe(2);
|
||||
expect(result[0].username).toBe('user1');
|
||||
});
|
||||
});
|
||||
|
||||
describe('validatePaginatedResponse', () => {
|
||||
it('should validate paginated response', () => {
|
||||
const validPaginated = {
|
||||
items: [
|
||||
{
|
||||
id: '123e4567-e89b-12d3-a456-426614174000',
|
||||
username: 'user1',
|
||||
email: 'user1@example.com',
|
||||
role: 'user',
|
||||
is_active: true,
|
||||
is_verified: true,
|
||||
is_admin: false,
|
||||
is_public: true,
|
||||
created_at: '2024-01-01T00:00:00Z',
|
||||
updated_at: '2024-01-01T00:00:00Z',
|
||||
},
|
||||
],
|
||||
pagination: {
|
||||
page: 1,
|
||||
limit: 20,
|
||||
total: 1,
|
||||
total_pages: 1,
|
||||
has_next: false,
|
||||
has_prev: false,
|
||||
},
|
||||
};
|
||||
|
||||
const result = validatePaginatedResponse(userSchema, validPaginated);
|
||||
expect(result.items.length).toBe(1);
|
||||
expect(result.pagination.page).toBe(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
381
apps/web/src/schemas/apiSchemas.ts
Normal file
381
apps/web/src/schemas/apiSchemas.ts
Normal file
|
|
@ -0,0 +1,381 @@
|
|||
/**
|
||||
* API Response Schemas
|
||||
* FE-TYPE-002: Create Zod schemas to validate API responses at runtime
|
||||
*
|
||||
* Provides Zod schemas for all API response types to ensure type safety
|
||||
* and runtime validation of API responses.
|
||||
*/
|
||||
|
||||
import { z } from 'zod';
|
||||
import { normalizeObjectIds } from '@/utils/idNormalization';
|
||||
|
||||
/**
|
||||
* Base UUID schema
|
||||
*/
|
||||
export const uuidSchema = z.string().uuid('Invalid UUID format');
|
||||
|
||||
/**
|
||||
* ISO8601 date string schema
|
||||
*/
|
||||
export const isoDateSchema = z.string().datetime({ message: 'Invalid ISO8601 date format' });
|
||||
|
||||
/**
|
||||
* User schema
|
||||
*/
|
||||
export const userSchema = z.object({
|
||||
id: uuidSchema,
|
||||
username: z.string().min(1),
|
||||
slug: z.string().optional(),
|
||||
email: z.string().email(),
|
||||
first_name: z.string().optional().nullable(),
|
||||
last_name: z.string().optional().nullable(),
|
||||
avatar: z.string().optional().nullable(),
|
||||
bio: z.string().optional().nullable(),
|
||||
location: z.string().optional().nullable(),
|
||||
birthdate: isoDateSchema.optional().nullable(),
|
||||
gender: z.string().optional().nullable(),
|
||||
username_changed_at: isoDateSchema.optional().nullable(),
|
||||
role: z.enum(['user', 'admin', 'super_admin']),
|
||||
is_active: z.boolean(),
|
||||
is_verified: z.boolean(),
|
||||
is_admin: z.boolean(),
|
||||
is_public: z.boolean(),
|
||||
last_login_at: isoDateSchema.optional().nullable(),
|
||||
created_at: isoDateSchema,
|
||||
updated_at: isoDateSchema,
|
||||
is_2fa_enabled: z.boolean().optional(),
|
||||
});
|
||||
|
||||
export type User = z.infer<typeof userSchema>;
|
||||
|
||||
/**
|
||||
* Message schema
|
||||
*/
|
||||
export const messageSchema = z.object({
|
||||
id: uuidSchema,
|
||||
conversation_id: uuidSchema,
|
||||
sender_id: uuidSchema,
|
||||
content: z.string(),
|
||||
message_type: z.enum(['text', 'image', 'audio', 'file']),
|
||||
attachment_url: z.string().url().optional(),
|
||||
created_at: isoDateSchema,
|
||||
updated_at: isoDateSchema,
|
||||
sender: userSchema.optional(),
|
||||
});
|
||||
|
||||
export type Message = z.infer<typeof messageSchema>;
|
||||
|
||||
/**
|
||||
* Conversation schema
|
||||
*/
|
||||
export const conversationSchema = z.object({
|
||||
id: uuidSchema,
|
||||
name: z.string(),
|
||||
type: z.enum(['direct', 'group']),
|
||||
creator_id: uuidSchema,
|
||||
created_at: isoDateSchema,
|
||||
updated_at: isoDateSchema,
|
||||
participants: z.array(userSchema).optional(),
|
||||
last_message: messageSchema.optional(),
|
||||
unread_count: z.number().int().nonnegative().optional(),
|
||||
});
|
||||
|
||||
export type Conversation = z.infer<typeof conversationSchema>;
|
||||
|
||||
/**
|
||||
* Track schema
|
||||
*/
|
||||
export const trackSchema = z.object({
|
||||
id: uuidSchema,
|
||||
creator_id: uuidSchema,
|
||||
file_id: uuidSchema.optional().nullable(),
|
||||
title: z.string().min(1),
|
||||
artist: z.string().min(1),
|
||||
album: z.string(),
|
||||
duration: z.number().nonnegative(),
|
||||
genre: z.string(),
|
||||
year: z.number().int().min(1900).max(2100),
|
||||
file_path: z.string(),
|
||||
file_size: z.number().nonnegative(),
|
||||
format: z.string(),
|
||||
bitrate: z.number().nonnegative(),
|
||||
sample_rate: z.number().nonnegative(),
|
||||
waveform_path: z.string().optional().nullable(),
|
||||
cover_art_path: z.string().optional().nullable(),
|
||||
is_public: z.boolean(),
|
||||
status: z.enum(['uploading', 'processing', 'completed', 'failed']),
|
||||
status_message: z.string().optional().nullable(),
|
||||
stream_status: z.enum(['pending', 'processing', 'ready', 'error']),
|
||||
stream_manifest_url: z.string().url().optional().nullable(),
|
||||
play_count: z.number().int().nonnegative(),
|
||||
like_count: z.number().int().nonnegative(),
|
||||
created_at: isoDateSchema,
|
||||
updated_at: isoDateSchema,
|
||||
user: userSchema.optional(),
|
||||
});
|
||||
|
||||
export type Track = z.infer<typeof trackSchema>;
|
||||
|
||||
/**
|
||||
* Playlist schema
|
||||
*/
|
||||
export const playlistSchema = z.object({
|
||||
id: uuidSchema,
|
||||
user_id: uuidSchema,
|
||||
title: z.string().min(1),
|
||||
description: z.string().optional().nullable(),
|
||||
is_public: z.boolean(),
|
||||
cover_url: z.string().url().optional().nullable(),
|
||||
track_count: z.number().int().nonnegative(),
|
||||
follower_count: z.number().int().nonnegative(),
|
||||
created_at: isoDateSchema,
|
||||
updated_at: isoDateSchema,
|
||||
tracks: z.array(trackSchema).optional(),
|
||||
user: userSchema.optional(),
|
||||
playlist_tracks: z.array(z.any()).optional(), // Complex nested type
|
||||
collaborators: z.array(z.any()).optional(), // Complex nested type
|
||||
});
|
||||
|
||||
export type Playlist = z.infer<typeof playlistSchema>;
|
||||
|
||||
/**
|
||||
* Session schema
|
||||
*/
|
||||
export const sessionSchema = z.object({
|
||||
id: uuidSchema,
|
||||
user_id: uuidSchema,
|
||||
ip_address: z.string(),
|
||||
user_agent: z.string(),
|
||||
revoked_at: isoDateSchema.optional().nullable(),
|
||||
expires_at: isoDateSchema,
|
||||
created_at: isoDateSchema,
|
||||
});
|
||||
|
||||
export type Session = z.infer<typeof sessionSchema>;
|
||||
|
||||
/**
|
||||
* AuditLog schema
|
||||
*/
|
||||
export const auditLogSchema = z.object({
|
||||
id: uuidSchema,
|
||||
user_id: uuidSchema.optional().nullable(),
|
||||
action: z.string(),
|
||||
resource: z.string(),
|
||||
resource_id: uuidSchema.optional().nullable(),
|
||||
metadata: z.record(z.any()).optional().nullable(),
|
||||
ip_address: z.string().optional().nullable(),
|
||||
user_agent: z.string().optional().nullable(),
|
||||
timestamp: isoDateSchema,
|
||||
});
|
||||
|
||||
export type AuditLog = z.infer<typeof auditLogSchema>;
|
||||
|
||||
/**
|
||||
* ApiError schema
|
||||
*/
|
||||
export const apiErrorSchema = z.object({
|
||||
code: z.number().int(),
|
||||
message: z.string(),
|
||||
details: z.array(z.object({
|
||||
field: z.string(),
|
||||
message: z.string(),
|
||||
})).optional(),
|
||||
request_id: z.string().optional(),
|
||||
timestamp: isoDateSchema,
|
||||
context: z.record(z.any()).optional(),
|
||||
retry_after: z.number().int().positive().optional(),
|
||||
});
|
||||
|
||||
export type ApiError = z.infer<typeof apiErrorSchema>;
|
||||
|
||||
/**
|
||||
* ApiResponse schema (generic)
|
||||
*/
|
||||
export const apiResponseSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
|
||||
z.object({
|
||||
success: z.boolean(),
|
||||
data: dataSchema.nullable(),
|
||||
error: apiErrorSchema.optional(),
|
||||
message: z.string().optional(),
|
||||
});
|
||||
|
||||
/**
|
||||
* PaginationData schema
|
||||
*/
|
||||
export const paginationDataSchema = z.object({
|
||||
page: z.number().int().positive(),
|
||||
limit: z.number().int().positive(),
|
||||
total: z.number().int().nonnegative(),
|
||||
total_pages: z.number().int().nonnegative(),
|
||||
has_next: z.boolean(),
|
||||
has_prev: z.boolean(),
|
||||
next_cursor: z.string().optional(),
|
||||
prev_cursor: z.string().optional(),
|
||||
});
|
||||
|
||||
export type PaginationData = z.infer<typeof paginationDataSchema>;
|
||||
|
||||
/**
|
||||
* ListResponse schema (generic)
|
||||
*/
|
||||
export const listResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
|
||||
z.object({
|
||||
items: z.array(itemSchema),
|
||||
pagination: paginationDataSchema,
|
||||
});
|
||||
|
||||
/**
|
||||
* Notification schema
|
||||
*/
|
||||
export const notificationSchema = z.object({
|
||||
id: uuidSchema,
|
||||
user_id: uuidSchema,
|
||||
type: z.enum(['new_message', 'track_uploaded', 'user_mentioned', 'system']),
|
||||
content: z.string(),
|
||||
read: z.boolean(),
|
||||
created_at: isoDateSchema,
|
||||
});
|
||||
|
||||
export type Notification = z.infer<typeof notificationSchema>;
|
||||
|
||||
/**
|
||||
* PlaylistTrack schema
|
||||
*/
|
||||
export const playlistTrackSchema = z.object({
|
||||
id: uuidSchema,
|
||||
playlist_id: uuidSchema,
|
||||
track_id: uuidSchema,
|
||||
position: z.number().int().nonnegative(),
|
||||
added_by: uuidSchema,
|
||||
added_at: isoDateSchema,
|
||||
track: trackSchema.optional(),
|
||||
});
|
||||
|
||||
export type PlaylistTrack = z.infer<typeof playlistTrackSchema>;
|
||||
|
||||
/**
|
||||
* PlaylistCollaborator schema
|
||||
*/
|
||||
export const playlistCollaboratorSchema = z.object({
|
||||
id: uuidSchema,
|
||||
playlist_id: uuidSchema,
|
||||
user_id: uuidSchema,
|
||||
role: z.enum(['owner', 'editor', 'viewer']),
|
||||
created_at: isoDateSchema,
|
||||
user: userSchema.optional(),
|
||||
});
|
||||
|
||||
export type PlaylistCollaborator = z.infer<typeof playlistCollaboratorSchema>;
|
||||
|
||||
/**
|
||||
* Validate and normalize API response
|
||||
*
|
||||
* @param schema - Zod schema to validate against
|
||||
* @param data - Data to validate
|
||||
* @param options - Validation options
|
||||
* @returns Validated and normalized data
|
||||
* @throws ZodError if validation fails
|
||||
*/
|
||||
export function validateApiResponse<T>(
|
||||
schema: z.ZodSchema<T>,
|
||||
data: unknown,
|
||||
options: {
|
||||
normalizeIds?: boolean;
|
||||
strict?: boolean;
|
||||
} = {},
|
||||
): T {
|
||||
const { normalizeIds = true, strict = false } = options;
|
||||
|
||||
// Normalize IDs if requested
|
||||
let normalizedData = data;
|
||||
if (normalizeIds && typeof data === 'object' && data !== null) {
|
||||
normalizedData = normalizeObjectIds(data as Record<string, unknown>);
|
||||
}
|
||||
|
||||
// Validate with schema
|
||||
if (strict) {
|
||||
return schema.strict().parse(normalizedData);
|
||||
}
|
||||
return schema.parse(normalizedData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Safe validate API response (returns result instead of throwing)
|
||||
*
|
||||
* @param schema - Zod schema to validate against
|
||||
* @param data - Data to validate
|
||||
* @param options - Validation options
|
||||
* @returns Validation result
|
||||
*/
|
||||
export function safeValidateApiResponse<T>(
|
||||
schema: z.ZodSchema<T>,
|
||||
data: unknown,
|
||||
options: {
|
||||
normalizeIds?: boolean;
|
||||
strict?: boolean;
|
||||
} = {},
|
||||
): {
|
||||
success: boolean;
|
||||
data?: T;
|
||||
error?: z.ZodError;
|
||||
} {
|
||||
try {
|
||||
const validated = validateApiResponse(schema, data, options);
|
||||
return { success: true, data: validated };
|
||||
} catch (error) {
|
||||
if (error instanceof z.ZodError) {
|
||||
return { success: false, error };
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate API response array
|
||||
*/
|
||||
export function validateApiResponseArray<T>(
|
||||
itemSchema: z.ZodSchema<T>,
|
||||
data: unknown,
|
||||
options?: {
|
||||
normalizeIds?: boolean;
|
||||
strict?: boolean;
|
||||
},
|
||||
): T[] {
|
||||
const arraySchema = z.array(itemSchema);
|
||||
const { normalizeIds = true, strict = false } = options || {};
|
||||
|
||||
// Normalize IDs if requested
|
||||
let normalizedData = data;
|
||||
if (normalizeIds && Array.isArray(data)) {
|
||||
normalizedData = data.map((item) =>
|
||||
typeof item === 'object' && item !== null
|
||||
? normalizeObjectIds(item as Record<string, unknown>)
|
||||
: item
|
||||
);
|
||||
}
|
||||
|
||||
// Validate with schema
|
||||
if (strict) {
|
||||
return arraySchema.strict().parse(normalizedData);
|
||||
}
|
||||
return arraySchema.parse(normalizedData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate paginated API response
|
||||
*/
|
||||
export function validatePaginatedResponse<T>(
|
||||
itemSchema: z.ZodSchema<T>,
|
||||
data: unknown,
|
||||
options?: {
|
||||
normalizeIds?: boolean;
|
||||
strict?: boolean;
|
||||
},
|
||||
): {
|
||||
items: T[];
|
||||
pagination: PaginationData;
|
||||
} {
|
||||
const paginatedSchema = listResponseSchema(itemSchema);
|
||||
return validateApiResponse(paginatedSchema, data, options);
|
||||
}
|
||||
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
import axios, { AxiosError, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
|
||||
import toast from 'react-hot-toast';
|
||||
import { z } from 'zod';
|
||||
import { TokenStorage } from '../tokenStorage';
|
||||
import { refreshToken } from '../tokenRefresh';
|
||||
import { env } from '@/config/env';
|
||||
|
|
@ -11,6 +12,7 @@ import { offlineQueue } from '../offlineQueue';
|
|||
import { requestDeduplication } from '../requestDeduplication';
|
||||
import { responseCache } from '../responseCache';
|
||||
import { invalidateStateAfterMutation } from '@/utils/stateInvalidation';
|
||||
import { safeValidateApiResponse } from '@/schemas/apiSchemas';
|
||||
import type { ApiResponse } from '@/types/api';
|
||||
|
||||
/**
|
||||
|
|
@ -344,6 +346,24 @@ apiClient.interceptors.response.use(
|
|||
// Si data est null/undefined, on retourne null au lieu de undefined
|
||||
const unwrappedData = response.data.data !== undefined ? response.data.data : null;
|
||||
|
||||
// FE-TYPE-002: Validate response data if schema is provided
|
||||
const responseSchema = (response.config as any)?._responseSchema as z.ZodSchema | undefined;
|
||||
if (responseSchema && unwrappedData !== null) {
|
||||
const validation = safeValidateApiResponse(responseSchema, unwrappedData);
|
||||
if (!validation.success) {
|
||||
logger.warn('[API] Response validation failed:', {
|
||||
url: response.config.url,
|
||||
errors: validation.error?.errors,
|
||||
});
|
||||
// In development, log full error details
|
||||
if (import.meta.env.DEV) {
|
||||
console.warn('[API Validation Error]', validation.error);
|
||||
}
|
||||
// Continue with unvalidated data (don't break the app)
|
||||
// In production, you might want to throw or handle differently
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
...response,
|
||||
data: unwrappedData,
|
||||
|
|
@ -356,6 +376,21 @@ apiClient.interceptors.response.use(
|
|||
|
||||
// Si pas de format wrapper (format direct JSON), retourner la réponse telle quelle
|
||||
// Exemples: { tracks: [...], pagination: {...} }, { user: {...}, token: {...} }
|
||||
// FE-TYPE-002: Validate direct format responses if schema is provided
|
||||
const responseSchema = (response.config as any)?._responseSchema as z.ZodSchema | undefined;
|
||||
if (responseSchema && response.data) {
|
||||
const validation = safeValidateApiResponse(responseSchema, response.data);
|
||||
if (!validation.success) {
|
||||
logger.warn('[API] Response validation failed:', {
|
||||
url: response.config.url,
|
||||
errors: validation.error?.errors,
|
||||
});
|
||||
if (import.meta.env.DEV) {
|
||||
console.warn('[API Validation Error]', validation.error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return response;
|
||||
},
|
||||
async (error: AxiosError<ApiResponse<any>>) => {
|
||||
|
|
|
|||
148
apps/web/src/services/api/clientWithValidation.ts
Normal file
148
apps/web/src/services/api/clientWithValidation.ts
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
/**
|
||||
* API Client with Validation
|
||||
* FE-TYPE-002: Enhanced API client methods with automatic Zod validation
|
||||
*
|
||||
* Provides typed API client methods that automatically validate responses
|
||||
* using Zod schemas.
|
||||
*/
|
||||
|
||||
import { InternalAxiosRequestConfig, AxiosResponse } from 'axios';
|
||||
import { z } from 'zod';
|
||||
import { apiClient } from './client';
|
||||
import { safeValidateApiResponse } from '@/schemas/apiSchemas';
|
||||
import { logger } from '@/utils/logger';
|
||||
|
||||
/**
|
||||
* Create a validated API request
|
||||
*
|
||||
* @param requestFn - Function that makes the API request
|
||||
* @param schema - Zod schema to validate the response
|
||||
* @param options - Validation options
|
||||
* @returns Validated response
|
||||
*/
|
||||
export async function validatedRequest<T>(
|
||||
requestFn: () => Promise<AxiosResponse<T>>,
|
||||
schema: z.ZodSchema<T>,
|
||||
options: {
|
||||
strict?: boolean;
|
||||
throwOnError?: boolean;
|
||||
} = {},
|
||||
): Promise<T> {
|
||||
const { strict = false, throwOnError = false } = options;
|
||||
|
||||
const response = await requestFn();
|
||||
const validation = safeValidateApiResponse(schema, response.data, { strict });
|
||||
|
||||
if (!validation.success) {
|
||||
const errorMessage = `API response validation failed: ${validation.error?.errors.map(e => e.message).join(', ')}`;
|
||||
logger.error('[API Validation]', {
|
||||
errors: validation.error?.errors,
|
||||
data: response.data,
|
||||
});
|
||||
|
||||
if (throwOnError) {
|
||||
throw new Error(errorMessage);
|
||||
}
|
||||
|
||||
// In development, log warning but continue
|
||||
if (import.meta.env.DEV) {
|
||||
console.warn('[API Validation Warning]', validation.error);
|
||||
}
|
||||
}
|
||||
|
||||
// Return validated data if validation succeeded, otherwise return original data
|
||||
return validation.data ?? (response.data as T);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validated API client methods
|
||||
* Automatically validates responses using provided schemas
|
||||
*/
|
||||
export const validatedApiClient = {
|
||||
/**
|
||||
* GET request with validation
|
||||
*/
|
||||
get: <T = any>(
|
||||
url: string,
|
||||
schema: z.ZodSchema<T>,
|
||||
config?: InternalAxiosRequestConfig & { _responseSchema?: z.ZodSchema },
|
||||
): Promise<T> => {
|
||||
return validatedRequest(
|
||||
() => apiClient.get<T>(url, { ...config, _responseSchema: schema }),
|
||||
schema,
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* POST request with validation
|
||||
*/
|
||||
post: <T = any>(
|
||||
url: string,
|
||||
data?: any,
|
||||
schema?: z.ZodSchema<T>,
|
||||
config?: InternalAxiosRequestConfig & { _responseSchema?: z.ZodSchema },
|
||||
): Promise<T> => {
|
||||
if (!schema) {
|
||||
// If no schema provided, use regular client
|
||||
return apiClient.post<T>(url, data, config).then((res) => res.data);
|
||||
}
|
||||
return validatedRequest(
|
||||
() => apiClient.post<T>(url, data, { ...config, _responseSchema: schema }),
|
||||
schema,
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* PUT request with validation
|
||||
*/
|
||||
put: <T = any>(
|
||||
url: string,
|
||||
data?: any,
|
||||
schema?: z.ZodSchema<T>,
|
||||
config?: InternalAxiosRequestConfig & { _responseSchema?: z.ZodSchema },
|
||||
): Promise<T> => {
|
||||
if (!schema) {
|
||||
return apiClient.put<T>(url, data, config).then((res) => res.data);
|
||||
}
|
||||
return validatedRequest(
|
||||
() => apiClient.put<T>(url, data, { ...config, _responseSchema: schema }),
|
||||
schema,
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* PATCH request with validation
|
||||
*/
|
||||
patch: <T = any>(
|
||||
url: string,
|
||||
data?: any,
|
||||
schema?: z.ZodSchema<T>,
|
||||
config?: InternalAxiosRequestConfig & { _responseSchema?: z.ZodSchema },
|
||||
): Promise<T> => {
|
||||
if (!schema) {
|
||||
return apiClient.patch<T>(url, data, config).then((res) => res.data);
|
||||
}
|
||||
return validatedRequest(
|
||||
() => apiClient.patch<T>(url, data, { ...config, _responseSchema: schema }),
|
||||
schema,
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* DELETE request with validation
|
||||
*/
|
||||
delete: <T = any>(
|
||||
url: string,
|
||||
schema?: z.ZodSchema<T>,
|
||||
config?: InternalAxiosRequestConfig & { _responseSchema?: z.ZodSchema },
|
||||
): Promise<T> => {
|
||||
if (!schema) {
|
||||
return apiClient.delete<T>(url, config).then((res) => res.data);
|
||||
}
|
||||
return validatedRequest(
|
||||
() => apiClient.delete<T>(url, { ...config, _responseSchema: schema }),
|
||||
schema,
|
||||
);
|
||||
},
|
||||
};
|
||||
|
||||
Loading…
Reference in a new issue