@carno.js/core 1.0.2 → 1.0.4

package/src/validation/ValibotAdapter.ts

@@ -1,95 +1,95 @@
-import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
-import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
-import { ValidationException } from './ZodAdapter';
-
-/**
- * Valibot Adapter for Turbo validation.
- * 
- * Usage:
- * ```typescript
- * import * as v from 'valibot';
- * 
- * @Schema(v.object({
- *   name: v.pipe(v.string(), v.minLength(1)),
- *   email: v.pipe(v.string(), v.email())
- * }))
- * class CreateUserDto {
- *   name: string;
- *   email: string;
- * }
- * ```
- */
-export class ValibotAdapter implements ValidatorAdapter {
-    readonly name = 'ValibotAdapter';
-
-    private schemaCache = new Map<any, any>();
-    private valibot: any = null;
-
-    constructor() {
-        // Lazy load valibot
-        try {
-            this.valibot = require('valibot');
-        } catch {
-            // Will be loaded on first use
-        }
-    }
-
-    private ensureValibot(): any {
-        if (!this.valibot) {
-            this.valibot = require('valibot');
-        }
-        return this.valibot;
-    }
-
-    hasValidation(target: any): boolean {
-        return getSchema(target) !== undefined;
-    }
-
-    validate<T>(target: any, value: unknown): ValidationResult<T> {
-        const schema = this.getOrCacheSchema(target);
-
-        if (!schema) {
-            return { success: true, data: value as T };
-        }
-
-        const v = this.ensureValibot();
-        const result = v.safeParse(schema, value);
-
-        if (result.success) {
-            return { success: true, data: result.output };
-        }
-
-        return {
-            success: false,
-            errors: this.formatErrors(result.issues)
-        };
-    }
-
-    validateOrThrow<T>(target: any, value: unknown): T {
-        const result = this.validate<T>(target, value);
-
-        if (result.success) {
-            return result.data!;
-        }
-
-        throw new ValidationException(result.errors!);
-    }
-
-    private getOrCacheSchema(target: any): any {
-        let schema = this.schemaCache.get(target);
-
-        if (schema === undefined) {
-            schema = getSchema(target) ?? null;
-            this.schemaCache.set(target, schema);
-        }
-
-        return schema;
-    }
-
-    private formatErrors(issues: any[]): ValidationError[] {
-        return issues.map((issue: any) => ({
-            path: issue.path?.map((p: any) => p.key).join('.') || '',
-            message: issue.message
-        }));
-    }
-}
+import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
+import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
+import { ValidationException } from './ZodAdapter';
+
+/**
+ * Valibot Adapter for Turbo validation.
+ * 
+ * Usage:
+ * ```typescript
+ * import * as v from 'valibot';
+ * 
+ * @Schema(v.object({
+ *   name: v.pipe(v.string(), v.minLength(1)),
+ *   email: v.pipe(v.string(), v.email())
+ * }))
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ * ```
+ */
+export class ValibotAdapter implements ValidatorAdapter {
+    readonly name = 'ValibotAdapter';
+
+    private schemaCache = new Map<any, any>();
+    private valibot: any = null;
+
+    constructor() {
+        // Lazy load valibot
+        try {
+            this.valibot = require('valibot');
+        } catch {
+            // Will be loaded on first use
+        }
+    }
+
+    private ensureValibot(): any {
+        if (!this.valibot) {
+            this.valibot = require('valibot');
+        }
+        return this.valibot;
+    }
+
+    hasValidation(target: any): boolean {
+        return getSchema(target) !== undefined;
+    }
+
+    validate<T>(target: any, value: unknown): ValidationResult<T> {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return { success: true, data: value as T };
+        }
+
+        const v = this.ensureValibot();
+        const result = v.safeParse(schema, value);
+
+        if (result.success) {
+            return { success: true, data: result.output };
+        }
+
+        return {
+            success: false,
+            errors: this.formatErrors(result.issues)
+        };
+    }
+
+    validateOrThrow<T>(target: any, value: unknown): T {
+        const result = this.validate<T>(target, value);
+
+        if (result.success) {
+            return result.data!;
+        }
+
+        throw new ValidationException(result.errors!);
+    }
+
+    private getOrCacheSchema(target: any): any {
+        let schema = this.schemaCache.get(target);
+
+        if (schema === undefined) {
+            schema = getSchema(target) ?? null;
+            this.schemaCache.set(target, schema);
+        }
+
+        return schema;
+    }
+
+    private formatErrors(issues: any[]): ValidationError[] {
+        return issues.map((issue: any) => ({
+            path: issue.path?.map((p: any) => p.key).join('.') || '',
+            message: issue.message
+        }));
+    }
+}

package/src/validation/ValidatorAdapter.ts

@@ -1,69 +1,69 @@
-/**
- * Validation result type.
- */
-export interface ValidationResult<T = any> {
-    success: boolean;
-    data?: T;
-    errors?: ValidationError[];
-}
-
-export interface ValidationError {
-    path: string;
-    message: string;
-}
-
-/**
- * Base interface for validation adapters.
- * Adapters provide validation capabilities for different libraries.
- */
-export interface ValidatorAdapter {
-    /**
-     * Validator name for debugging.
-     */
-    readonly name: string;
-
-    /**
-     * Check if a target has validation schema.
-     */
-    hasValidation(target: any): boolean;
-
-    /**
-     * Validate and transform a value.
-     * Returns result object instead of throwing for better performance.
-     */
-    validate<T>(target: any, value: unknown): ValidationResult<T>;
-
-    /**
-     * Validate and transform, throwing on error.
-     * Used when you want to short-circuit on failure.
-     */
-    validateOrThrow<T>(target: any, value: unknown): T;
-}
-
-/**
- * Validation configuration for Turbo.
- */
-export interface ValidationConfig {
-    adapter: ValidatorAdapter;
-}
-
-/**
- * Symbol for storing validation schema on DTOs.
- */
-export const VALIDATION_SCHEMA = Symbol('turbo:validation');
-
-/**
- * Decorator to attach a validation schema to a DTO class.
- */
-export function Schema(schema: any): ClassDecorator {
-    return (target) => {
-        Reflect.defineMetadata(VALIDATION_SCHEMA, schema, target);
-    };
-}
-
-/**
- * Get the validation schema from a DTO class.
- */
-export function getSchema(target: any): any | undefined {
-    return Reflect.getMetadata(VALIDATION_SCHEMA, target);
-}
+/**
+ * Validation result type.
+ */
+export interface ValidationResult<T = any> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationError[];
+}
+
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+
+/**
+ * Base interface for validation adapters.
+ * Adapters provide validation capabilities for different libraries.
+ */
+export interface ValidatorAdapter {
+    /**
+     * Validator name for debugging.
+     */
+    readonly name: string;
+
+    /**
+     * Check if a target has validation schema.
+     */
+    hasValidation(target: any): boolean;
+
+    /**
+     * Validate and transform a value.
+     * Returns result object instead of throwing for better performance.
+     */
+    validate<T>(target: any, value: unknown): ValidationResult<T>;
+
+    /**
+     * Validate and transform, throwing on error.
+     * Used when you want to short-circuit on failure.
+     */
+    validateOrThrow<T>(target: any, value: unknown): T;
+}
+
+/**
+ * Validation configuration for Turbo.
+ */
+export interface ValidationConfig {
+    adapter: ValidatorAdapter;
+}
+
+/**
+ * Symbol for storing validation schema on DTOs.
+ */
+export const VALIDATION_SCHEMA = Symbol('turbo:validation');
+
+/**
+ * Decorator to attach a validation schema to a DTO class.
+ */
+export function Schema(schema: any): ClassDecorator {
+    return (target) => {
+        Reflect.defineMetadata(VALIDATION_SCHEMA, schema, target);
+    };
+}
+
+/**
+ * Get the validation schema from a DTO class.
+ */
+export function getSchema(target: any): any | undefined {
+    return Reflect.getMetadata(VALIDATION_SCHEMA, target);
+}

package/src/validation/ZodAdapter.ts

@@ -1,102 +1,102 @@
-import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
-import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
-
-/**
- * Zod Adapter - Default validation adapter for Turbo.
- * 
- * Usage:
- * ```typescript
- * import { z } from 'zod';
- * 
- * @Schema(z.object({
- *   name: z.string().min(1),
- *   email: z.string().email()
- * }))
- * class CreateUserDto {
- *   name: string;
- *   email: string;
- * }
- * ```
- */
-export class ZodAdapter implements ValidatorAdapter {
-    readonly name = 'ZodAdapter';
-
-    // Cache parsed schemas for performance
-    private schemaCache = new Map<any, any>();
-
-    hasValidation(target: any): boolean {
-        return getSchema(target) !== undefined;
-    }
-
-    validate<T>(target: any, value: unknown): ValidationResult<T> {
-        const schema = this.getOrCacheSchema(target);
-
-        if (!schema) {
-            return { success: true, data: value as T };
-        }
-
-        const result = schema.safeParse(value);
-
-        if (result.success) {
-            return { success: true, data: result.data };
-        }
-
-        return {
-            success: false,
-            errors: this.formatErrors(result.error)
-        };
-    }
-
-    validateOrThrow<T>(target: any, value: unknown): T {
-        const schema = this.getOrCacheSchema(target);
-
-        if (!schema) {
-            return value as T;
-        }
-
-        const result = schema.safeParse(value);
-
-        if (result.success) {
-            return result.data;
-        }
-
-        const errors = this.formatErrors(result.error);
-        throw new ValidationException(errors);
-    }
-
-    private getOrCacheSchema(target: any): any {
-        let schema = this.schemaCache.get(target);
-
-        if (schema === undefined) {
-            schema = getSchema(target) ?? null;
-            this.schemaCache.set(target, schema);
-        }
-
-        return schema;
-    }
-
-    private formatErrors(zodError: any): ValidationError[] {
-        return zodError.issues.map((issue: any) => ({
-            path: issue.path.join('.'),
-            message: issue.message
-        }));
-    }
-}
-
-/**
- * Validation exception thrown when validation fails.
- */
-export class ValidationException extends Error {
-    constructor(public readonly errors: ValidationError[]) {
-        super(`Validation failed: ${errors.map(e => `${e.path}: ${e.message}`).join(', ')}`);
-        this.name = 'ValidationException';
-    }
-
-    toResponse(): Response {
-        return Response.json({
-            statusCode: 400,
-            message: 'Validation failed',
-            errors: this.errors
-        }, { status: 400 });
-    }
-}
+import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
+import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
+
+/**
+ * Zod Adapter - Default validation adapter for Turbo.
+ * 
+ * Usage:
+ * ```typescript
+ * import { z } from 'zod';
+ * 
+ * @Schema(z.object({
+ *   name: z.string().min(1),
+ *   email: z.string().email()
+ * }))
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ * ```
+ */
+export class ZodAdapter implements ValidatorAdapter {
+    readonly name = 'ZodAdapter';
+
+    // Cache parsed schemas for performance
+    private schemaCache = new Map<any, any>();
+
+    hasValidation(target: any): boolean {
+        return getSchema(target) !== undefined;
+    }
+
+    validate<T>(target: any, value: unknown): ValidationResult<T> {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return { success: true, data: value as T };
+        }
+
+        const result = schema.safeParse(value);
+
+        if (result.success) {
+            return { success: true, data: result.data };
+        }
+
+        return {
+            success: false,
+            errors: this.formatErrors(result.error)
+        };
+    }
+
+    validateOrThrow<T>(target: any, value: unknown): T {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return value as T;
+        }
+
+        const result = schema.safeParse(value);
+
+        if (result.success) {
+            return result.data;
+        }
+
+        const errors = this.formatErrors(result.error);
+        throw new ValidationException(errors);
+    }
+
+    private getOrCacheSchema(target: any): any {
+        let schema = this.schemaCache.get(target);
+
+        if (schema === undefined) {
+            schema = getSchema(target) ?? null;
+            this.schemaCache.set(target, schema);
+        }
+
+        return schema;
+    }
+
+    private formatErrors(zodError: any): ValidationError[] {
+        return zodError.issues.map((issue: any) => ({
+            path: issue.path.join('.'),
+            message: issue.message
+        }));
+    }
+}
+
+/**
+ * Validation exception thrown when validation fails.
+ */
+export class ValidationException extends Error {
+    constructor(public readonly errors: ValidationError[]) {
+        super(`Validation failed: ${errors.map(e => `${e.path}: ${e.message}`).join(', ')}`);
+        this.name = 'ValidationException';
+    }
+
+    toResponse(): Response {
+        return Response.json({
+            statusCode: 400,
+            message: 'Validation failed',
+            errors: this.errors
+        }, { status: 400 });
+    }
+}