@noony-serverless/core/build/middlewares/ConsolidatedValidationMiddleware.d.ts

A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript

import { ZodSchema } from 'zod';
import { BaseMiddleware, Context } from '../core';
/**
 * Configuration for body validation
 */
export interface BodyValidationConfig<T = unknown> {
    schema?: ZodSchema<T>;
    required?: boolean;
    maxSize?: number;
    allowEmpty?: boolean;
    customValidator?: (body: unknown) => Promise<T> | T;
}
/**
 * Configuration for header validation
 */
export interface HeaderValidationConfig {
    required?: string[];
    optional?: string[];
    patterns?: Record<string, RegExp>;
    customValidators?: Record<string, (value: string) => boolean>;
    caseSensitive?: boolean;
}
/**
 * Configuration for query parameter validation
 */
export interface QueryValidationConfig {
    allowedParams?: string[];
    requiredParams?: string[];
    patterns?: Record<string, RegExp>;
    maxParams?: number;
    parseTypes?: Record<string, 'string' | 'number' | 'boolean' | 'array'>;
}
/**
 * Complete configuration for ConsolidatedValidationMiddleware
 */
export interface ConsolidatedValidationMiddlewareConfig<T = unknown> {
    body?: BodyValidationConfig<T>;
    headers?: HeaderValidationConfig;
    query?: QueryValidationConfig;
    skipValidation?: (context: Context<T>) => boolean;
}
/**
 * Consolidated ValidationMiddleware that combines body validation, header validation, and query parameter validation.
 *
 * This middleware replaces the need for separate:
 * - BodyValidationMiddleware
 * - ValidationMiddleware
 * - HeaderVariablesMiddleware
 *
 * @example
 * Complete validation setup:
 * ```typescript
 * const createUserSchema = z.object({
 *   name: z.string().min(1).max(100),
 *   email: z.string().email(),
 *   age: z.number().min(18).max(120)
 * });
 *
 * const handler = new Handler()
 *   .use(new ConsolidatedValidationMiddleware({
 *     body: {
 *       schema: createUserSchema,
 *       required: true,
 *       maxSize: 1024 * 1024 // 1MB
 *     },
 *     headers: {
 *       required: ['authorization', 'content-type'],
 *       optional: ['x-trace-id', 'user-agent'],
 *       patterns: {
 *         'x-trace-id': /^[a-f0-9-]{36}$/
 *       }
 *     },
 *     query: {
 *       allowedParams: ['page', 'limit', 'sort'],
 *       requiredParams: ['page'],
 *       parseTypes: {
 *         page: 'number',
 *         limit: 'number'
 *       }
 *     }
 *   }))
 *   .handle(async (context) => {
 *     // context.req.validatedBody is typed as z.infer<typeof createUserSchema>
 *     const { name, email, age } = context.req.validatedBody!;
 *     return { message: `Creating user ${name}` };
 *   });
 * ```
 */
export declare class ConsolidatedValidationMiddleware<T = unknown> implements BaseMiddleware<T> {
    private config;
    constructor(config?: ConsolidatedValidationMiddlewareConfig<T>);
    before(context: Context<T>): Promise<void>;
    private validateHeaders;
    private validateQueryParameters;
    private validateBody;
    private normalizeHeaders;
    private parseQueryParamType;
    private isEmpty;
    private getBodySize;
}
/**
 * Factory functions for creating ConsolidatedValidationMiddleware with common configurations
 */
export declare const createConsolidatedValidationMiddleware: {
    /**
     * Body-only validation with Zod schema
     */
    bodyOnly: <T>(schema: ZodSchema<T>) => ConsolidatedValidationMiddleware<T>;
    /**
     * Headers-only validation
     */
    headersOnly: (required: string[], optional?: string[]) => ConsolidatedValidationMiddleware;
    /**
     * Query-only validation
     */
    queryOnly: (config: QueryValidationConfig) => ConsolidatedValidationMiddleware;
    /**
     * Complete validation setup
     */
    complete: <T>(config: ConsolidatedValidationMiddlewareConfig<T>) => ConsolidatedValidationMiddleware<T>;
    /**
     * API validation with common patterns
     */
    apiValidation: <T>(schema: ZodSchema<T>) => ConsolidatedValidationMiddleware<T>;
};
//# sourceMappingURL=ConsolidatedValidationMiddleware.d.ts.map