@pulzar/core/dist/validation/zod-validator.d.ts

Next-generation Node.js framework for ultra-fast web applications with zero-reflection DI, GraphQL, WebSockets, events, and edge runtime support

import { z } from "zod";
import type { FastifyRequest, FastifyReply, FastifyPluginAsync } from "fastify";
export { z };
export interface ValidationError {
    field: string;
    message: string;
    code: string;
    value?: any;
}
export interface ValidationResult<T> {
    success: boolean;
    data?: T;
    errors?: ValidationError[];
}
/**
 * Convert Zod errors to structured validation errors
 */
export declare function formatZodErrors(zodError: z.ZodError): ValidationError[];
/**
 * Convert Zod schema to JSON Schema for Fastify
 */
export declare function zodToJsonSchema(schema: z.ZodSchema): any;
/**
 * Validate data against Zod schema
 */
export declare function validateData<T>(schema: z.ZodSchema<T>, data: unknown): ValidationResult<T>;
/**
 * Create validation middleware for specific request parts
 */
export interface ValidationMiddlewareOptions {
    body?: z.ZodSchema;
    query?: z.ZodSchema;
    params?: z.ZodSchema;
    headers?: z.ZodSchema;
    abortEarly?: boolean;
    stripUnknown?: boolean;
}
/**
 * Fastify plugin for Zod validation
 */
export declare const zodValidationPlugin: FastifyPluginAsync<ValidationMiddlewareOptions>;
/**
 * Create a validation schema decorator for route handlers
 */
export declare function validate(options: ValidationMiddlewareOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
/**
 * Utility functions for common validation patterns
 */
export declare const CommonSchemas: {
    pagination: z.ZodObject<{
        page: z.ZodDefault<z.ZodNumber>;
        limit: z.ZodDefault<z.ZodNumber>;
        sort: z.ZodOptional<z.ZodString>;
        order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
    }, "strip", z.ZodTypeAny, {
        order: "asc" | "desc";
        limit: number;
        page: number;
        sort?: string | undefined;
    }, {
        sort?: string | undefined;
        order?: "asc" | "desc" | undefined;
        limit?: number | undefined;
        page?: number | undefined;
    }>;
    id: z.ZodObject<{
        id: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        id: string;
    }, {
        id: string;
    }>;
    numericId: z.ZodObject<{
        id: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        id: number;
    }, {
        id: number;
    }>;
    search: z.ZodObject<{
        q: z.ZodString;
        filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        q: string;
        filters?: Record<string, string> | undefined;
    }, {
        q: string;
        filters?: Record<string, string> | undefined;
    }>;
    fileUpload: z.ZodObject<{
        filename: z.ZodString;
        mimetype: z.ZodString;
        size: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        size: number;
        filename: string;
        mimetype: string;
    }, {
        size: number;
        filename: string;
        mimetype: string;
    }>;
    response: <T extends z.ZodSchema>(dataSchema: T) => z.ZodObject<{
        success: z.ZodBoolean;
        data: T;
        message: z.ZodOptional<z.ZodString>;
        pagination: z.ZodOptional<z.ZodObject<{
            page: z.ZodNumber;
            limit: z.ZodNumber;
            total: z.ZodNumber;
            pages: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }>>;
    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
        success: z.ZodBoolean;
        data: T;
        message: z.ZodOptional<z.ZodString>;
        pagination: z.ZodOptional<z.ZodObject<{
            page: z.ZodNumber;
            limit: z.ZodNumber;
            total: z.ZodNumber;
            pages: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }>>;
    }>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
        success: z.ZodBoolean;
        data: T;
        message: z.ZodOptional<z.ZodString>;
        pagination: z.ZodOptional<z.ZodObject<{
            page: z.ZodNumber;
            limit: z.ZodNumber;
            total: z.ZodNumber;
            pages: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }>>;
    }>, any>[k]; } : never, z.baseObjectInputType<{
        success: z.ZodBoolean;
        data: T;
        message: z.ZodOptional<z.ZodString>;
        pagination: z.ZodOptional<z.ZodObject<{
            page: z.ZodNumber;
            limit: z.ZodNumber;
            total: z.ZodNumber;
            pages: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }>>;
    }> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
        success: z.ZodBoolean;
        data: T;
        message: z.ZodOptional<z.ZodString>;
        pagination: z.ZodOptional<z.ZodObject<{
            page: z.ZodNumber;
            limit: z.ZodNumber;
            total: z.ZodNumber;
            pages: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }, {
            total: number;
            limit: number;
            page: number;
            pages: number;
        }>>;
    }>[k_1]; } : never>;
    errorResponse: z.ZodObject<{
        error: z.ZodString;
        message: z.ZodString;
        statusCode: z.ZodNumber;
        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            message: z.ZodString;
            code: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            code: string;
            message: string;
            field: string;
        }, {
            code: string;
            message: string;
            field: string;
        }>, "many">>;
        timestamp: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        error: string;
        statusCode: number;
        timestamp: string;
        details?: {
            code: string;
            message: string;
            field: string;
        }[] | undefined;
    }, {
        message: string;
        error: string;
        statusCode: number;
        timestamp: string;
        details?: {
            code: string;
            message: string;
            field: string;
        }[] | undefined;
    }>;
};
/**
 * Create typed request handler with validation
 */
export declare function createValidatedHandler<Body = unknown, Query = unknown, Params = unknown, Headers = unknown>(schema: {
    body?: z.ZodSchema<Body>;
    query?: z.ZodSchema<Query>;
    params?: z.ZodSchema<Params>;
    headers?: z.ZodSchema<Headers>;
}, handler: (request: {
    body: Body;
    query: Query;
    params: Params;
    headers: Headers;
    raw: FastifyRequest;
}, reply: FastifyReply) => Promise<any> | any): (request: FastifyRequest, reply: FastifyReply) => Promise<any>;
/**
 * Response validation helper
 */
export declare function validateResponse<T>(schema: z.ZodSchema<T>, data: unknown): T;
//# sourceMappingURL=zod-validator.d.ts.map