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

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

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,204 @@
+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',
+					},
+				],
+			};
+		}
+	}
+}

package/src/services/validation/{standard-schema.types.d.ts → standard-schema.types.ts}

@@ -22,43 +22,46 @@
  * ```
  */
 export interface StandardSchema<Input = unknown, Output = Input> {
-    readonly '~standard': {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
-        readonly types?: {
-            readonly input: Input;
-            readonly output: Output;
-        };
-    };
+	readonly '~standard': {
+		readonly version: 1;
+		readonly vendor: string;
+		readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+		readonly types?: {
+			readonly input: Input;
+			readonly output: Output;
+		};
+	};
 }
+
 /**
  * Result of Standard Schema validation.
  */
 export type StandardSchemaResult<Output> = StandardSchemaSuccessResult<Output> | StandardSchemaFailureResult;
+
 /**
  * Successful validation result.
  */
 export interface StandardSchemaSuccessResult<Output> {
-    readonly value: Output;
-    readonly issues?: undefined;
+	readonly value: Output;
+	readonly issues?: undefined;
 }
+
 /**
  * Failed validation result.
  */
 export interface StandardSchemaFailureResult {
-    readonly value?: undefined;
-    readonly issues: ReadonlyArray<StandardSchemaIssue>;
+	readonly value?: undefined;
+	readonly issues: ReadonlyArray<StandardSchemaIssue>;
 }
+
 /**
  * Validation issue details.
  */
 export interface StandardSchemaIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        key: PropertyKey;
-    }>;
+	readonly message: string;
+	readonly path?: ReadonlyArray<PropertyKey | { key: PropertyKey }>;
 }
+
 /**
  * Infers the output type from a Standard Schema.
  */