@ecopages/core 0.2.0-alpha.24 → 0.2.0-alpha.26

package/src/services/validation/schema-validation-service.test.ts

@@ -1,223 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { z } from 'zod';
-import * as v from 'valibot';
-import { type } from 'arktype';
-import { SchemaValidationService } from './schema-validation-service.ts';
-
-describe('SchemaValidationService', () => {
-	const service = new SchemaValidationService();
-
-	describe('Zod validation', () => {
-		test('validates body with Zod schema', async () => {
-			const schema = z.object({
-				title: z.string().min(1),
-				count: z.number(),
-			});
-
-			const result = await service.validateRequest(
-				{ body: { title: 'Hello', count: 42 } },
-				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.body).toEqual({ title: 'Hello', count: 42 });
-		});
-
-		test('rejects invalid body with Zod schema', async () => {
-			const schema = z.object({
-				title: z.string().min(1),
-				count: z.number(),
-			});
-
-			const result = await service.validateRequest(
-				{ body: { title: '', count: 'not-a-number' } },
-				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-			expect(result.errors!.length).toBeGreaterThan(0);
-		});
-	});
-
-	describe('Valibot validation', () => {
-		test('validates query with Valibot schema', async () => {
-			const schema = v.object({
-				page: v.string(),
-				limit: v.string(),
-			});
-
-			const result = await service.validateRequest(
-				{ query: { page: '1', limit: '10' } },
-				{ query: schema as unknown as Parameters<typeof service.validateRequest>[1]['query'] },
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.query).toEqual({ page: '1', limit: '10' });
-		});
-
-		test('rejects invalid query with Valibot schema', async () => {
-			const schema = v.object({
-				page: v.pipe(v.string(), v.minLength(1)),
-			});
-
-			const result = await service.validateRequest(
-				{ query: { page: '' } },
-				{ query: schema as unknown as Parameters<typeof service.validateRequest>[1]['query'] },
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-		});
-	});
-
-	describe('ArkType validation', () => {
-		test('validates headers with ArkType schema', async () => {
-			const schema = type({
-				'content-type': 'string',
-				authorization: 'string',
-			});
-
-			const result = await service.validateRequest(
-				{
-					headers: {
-						'content-type': 'application/json',
-						authorization: 'Bearer token',
-					},
-				},
-				{ headers: schema as unknown as Parameters<typeof service.validateRequest>[1]['headers'] },
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.headers).toEqual({
-				'content-type': 'application/json',
-				authorization: 'Bearer token',
-			});
-		});
-
-		test('rejects invalid headers with ArkType schema', async () => {
-			const schema = type({
-				'content-type': 'string',
-				'x-custom': 'string>5',
-			});
-
-			const result = await service.validateRequest(
-				{
-					headers: {
-						'content-type': 'application/json',
-						'x-custom': 'ab',
-					},
-				},
-				{ headers: schema as unknown as Parameters<typeof service.validateRequest>[1]['headers'] },
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-		});
-	});
-
-	describe('Combined validation', () => {
-		test('validates multiple sources at once', async () => {
-			const bodySchema = z.object({
-				title: z.string(),
-			});
-			const querySchema = v.object({
-				format: v.string(),
-			});
-
-			const result = await service.validateRequest(
-				{
-					body: { title: 'Post Title' },
-					query: { format: 'json' },
-				},
-				{
-					body: bodySchema as unknown as Parameters<typeof service.validateRequest>[1]['body'],
-					query: querySchema as unknown as Parameters<typeof service.validateRequest>[1]['query'],
-				},
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.body).toEqual({ title: 'Post Title' });
-			expect(result.data?.query).toEqual({ format: 'json' });
-		});
-
-		test('validates route params with schema', async () => {
-			const paramsSchema = z.object({
-				id: z.coerce.number().int(),
-			});
-
-			const result = await service.validateRequest(
-				{
-					params: { id: '42' },
-				},
-				{
-					params: paramsSchema as unknown as Parameters<typeof service.validateRequest>[1]['params'],
-				},
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.params).toEqual({ id: 42 });
-		});
-
-		test('aggregates errors from multiple sources', async () => {
-			const bodySchema = z.object({
-				title: z.string().min(5),
-			});
-			const querySchema = v.object({
-				page: v.pipe(v.string(), v.regex(/^\d+$/)),
-			});
-
-			const result = await service.validateRequest(
-				{
-					body: { title: 'ab' },
-					query: { page: 'invalid' },
-				},
-				{
-					body: bodySchema as unknown as Parameters<typeof service.validateRequest>[1]['body'],
-					query: querySchema as unknown as Parameters<typeof service.validateRequest>[1]['query'],
-				},
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-			expect(result.errors!.length).toBeGreaterThan(1);
-		});
-	});
-
-	describe('Edge cases', () => {
-		test('handles missing optional schemas', async () => {
-			const result = await service.validateRequest({ body: { data: 'test' } }, {});
-
-			expect(result.success).toBe(true);
-			expect(result.data).toEqual({});
-		});
-
-		test('handles undefined source data', async () => {
-			const schema = z.object({ name: z.string() });
-
-			const result = await service.validateRequest(
-				{ body: undefined },
-				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
-			);
-
-			expect(result.success).toBe(true);
-		});
-
-		test('catches validation exceptions', async () => {
-			const brokenSchema = {
-				'~standard': {
-					version: 1,
-					vendor: 'test',
-					validate: () => {
-						throw new Error('Validation crashed');
-					},
-				},
-			} as const;
-
-			const result = await service.validateRequest({ body: { test: true } }, { body: brokenSchema });
-
-			expect(result.success).toBe(false);
-			expect(result.errors?.[0]?.message).toBe('Validation crashed');
-		});
-	});
-});

package/src/services/validation/schema-validation-service.ts

@@ -1,204 +0,0 @@
-import type { StandardSchema, StandardSchemaIssue } from './standard-schema.types.ts';
-
-export interface ValidationResult<T = unknown> {
-	success: boolean;
-	data?: T;
-	errors?: Array<{
-		message: string;
-		path?: Array<string | number>;
-	}>;
-}
-
-export interface ValidationSource {
-	body?: unknown;
-	query?: Record<string, string>;
-	headers?: Record<string, string>;
-	params?: Record<string, string>;
-}
-
-export interface ValidationSchemas {
-	body?: StandardSchema;
-	query?: StandardSchema;
-	headers?: StandardSchema;
-	params?: StandardSchema;
-}
-
-export interface ValidatedData {
-	body?: unknown;
-	query?: unknown;
-	headers?: unknown;
-	params?: unknown;
-}
-
-/**
- * Service for validating request data using Standard Schema compliant validators.
- *
- * This service provides a unified interface for validating HTTP request data (body, query parameters, headers)
- * using any validation library that implements the Standard Schema specification.
- *
- * @example Using with Zod
- * ```typescript
- * import { z } from 'zod';
- * import { SchemaValidationService } from './schema-validation-service.ts';
- *
- * const service = new SchemaValidationService();
- * const result = await service.validateRequest(
- *   { body: { title: 'Hello', count: 42 } },
- *   { body: z.object({ title: z.string(), count: z.number() }) }
- * );
- *
- * if (result.success) {
- *   console.log(result.data.body);
- * }
- * ```
- *
- * @example Using with Valibot
- * ```typescript
- * import * as v from 'valibot';
- *
- * const result = await service.validateRequest(
- *   { query: { page: '1' } },
- *   { query: v.object({ page: v.string() }) }
- * );
- * ```
- *
- * @example Using with ArkType
- * ```typescript
- * import { type } from 'arktype';
- *
- * const result = await service.validateRequest(
- *   { headers: { 'authorization': 'Bearer token' } },
- *   { headers: type({ authorization: 'string' }) }
- * );
- * ```
- *
- * @example Multiple sources
- * ```typescript
- * const result = await service.validateRequest(
- *   {
- *     body: { title: 'Post' },
- *     query: { format: 'json' },
- *     headers: { 'content-type': 'application/json' }
- *   },
- *   {
- *     body: z.object({ title: z.string() }),
- *     query: v.object({ format: v.string() }),
- *     headers: type({ 'content-type': 'string' })
- *   }
- * );
- * ```
- *
- * Supported libraries: Zod, Valibot, ArkType, Effect Schema (with standardSchemaV1 wrapper)
- */
-export class SchemaValidationService {
-	/**
-	 * Validates request data against provided schemas.
-	 *
-	 * Validates body, query parameters, and headers against their respective schemas.
-	 * All validations are performed, and errors are aggregated from all sources.
-	 *
-	 * @param source - The data to validate (body, query, headers)
-	 * @param schemas - The Standard Schema validators for each source
-	 * @returns Validation result with validated data or aggregated errors
-	 *
-	 * @example
-	 * ```typescript
-	 * const result = await service.validateRequest(
-	 *   { body: { name: 'John', age: 30 } },
-	 *   { body: z.object({ name: z.string(), age: z.number() }) }
-	 * );
-	 *
-	 * if (result.success) {
-	 *   const validated = result.data.body;
-	 * } else {
-	 *   console.error(result.errors);
-	 * }
-	 * ```
-	 */
-	async validateRequest(
-		source: ValidationSource,
-		schemas: ValidationSchemas,
-	): Promise<ValidationResult<ValidatedData>> {
-		const validated: ValidatedData = {};
-		const allErrors: Array<{ message: string; path?: Array<string | number> }> = [];
-
-		if (schemas.body && source.body !== undefined) {
-			const result = await this.validateWithSchema(schemas.body, source.body);
-			if (!result.success) {
-				allErrors.push(...(result.errors || []));
-			} else {
-				validated.body = result.data;
-			}
-		}
-
-		if (schemas.query && source.query) {
-			const result = await this.validateWithSchema(schemas.query, source.query);
-			if (!result.success) {
-				allErrors.push(...(result.errors || []));
-			} else {
-				validated.query = result.data;
-			}
-		}
-
-		if (schemas.headers && source.headers) {
-			const result = await this.validateWithSchema(schemas.headers, source.headers);
-			if (!result.success) {
-				allErrors.push(...(result.errors || []));
-			} else {
-				validated.headers = result.data;
-			}
-		}
-
-		if (schemas.params && source.params) {
-			const result = await this.validateWithSchema(schemas.params, source.params);
-			if (!result.success) {
-				allErrors.push(...(result.errors || []));
-			} else {
-				validated.params = result.data;
-			}
-		}
-
-		if (allErrors.length > 0) {
-			return { success: false, errors: allErrors };
-		}
-
-		return { success: true, data: validated };
-	}
-
-	/**
-	 * Validates a single value against a Standard Schema.
-	 *
-	 * @param schema - The Standard Schema validator
-	 * @param data - The data to validate
-	 * @returns Validation result with validated data or errors
-	 */
-	private async validateWithSchema<T>(schema: StandardSchema, data: unknown): Promise<ValidationResult<T>> {
-		try {
-			const resultOrPromise = schema['~standard'].validate(data);
-			const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
-
-			if (result.issues) {
-				return {
-					success: false,
-					errors: result.issues.map((issue: StandardSchemaIssue) => ({
-						message: issue.message,
-						path: issue.path?.map((p) => (typeof p === 'object' && 'key' in p ? p.key : p)) as
-							| Array<string | number>
-							| undefined,
-					})),
-				};
-			}
-
-			return { success: true, data: result.value as T };
-		} catch (error) {
-			return {
-				success: false,
-				errors: [
-					{
-						message: error instanceof Error ? error.message : 'Validation failed',
-					},
-				],
-			};
-		}
-	}
-}