@noony-serverless/core 0.2.2 → 0.3.1

package/build/middlewares/guards/resolvers/ExpressionPermissionResolver.js

@@ -412,7 +412,7 @@ class ExpressionPermissionResolver extends PermissionResolver_1.PermissionResolv
      * Check if this resolver can handle the given requirement type
      */
     canHandle(requirement) {
-        return Boolean(requirement &&
+        return (requirement &&
             typeof requirement === 'object' &&
             PermissionResolver_1.PermissionUtils.isValidExpression(requirement));
     }

package/build/middlewares/guards/resolvers/PermissionResolver.d.ts

@@ -19,7 +19,7 @@
  * different types of permission requirements. The generic type T represents
  * the specific requirement format for each resolver.
  */
-export declare abstract class PermissionResolver<T = unknown> {
+export declare abstract class PermissionResolver<T = any> {
     /**
      * Check if user permissions satisfy the requirement
      *

package/build/middlewares/guards/resolvers/PlainPermissionResolver.d.ts

@@ -96,6 +96,6 @@ export declare class PlainPermissionResolver extends PermissionResolver<string[]
      * @param requirement - The requirement to check
      * @returns true if this resolver can handle the requirement
      */
-    canHandle(requirement: unknown): requirement is string[];
+    canHandle(requirement: any): requirement is string[];
 }
 //# sourceMappingURL=PlainPermissionResolver.d.ts.map

package/build/middlewares/guards/resolvers/WildcardPermissionResolver.d.ts

@@ -141,6 +141,6 @@ export declare class WildcardPermissionResolver extends PermissionResolver<strin
     /**
      * Check if this resolver can handle the given requirement type
      */
-    canHandle(requirement: unknown): requirement is string[];
+    canHandle(requirement: any): requirement is string[];
 }
 //# sourceMappingURL=WildcardPermissionResolver.d.ts.map

package/build/middlewares/guards/services/FastUserContextService.d.ts

@@ -23,13 +23,14 @@
  * @version 1.0.0
  */
 import { CacheAdapter } from '../cache/CacheAdapter';
-import { GuardConfiguration } from '../config/GuardConfiguration';
+import { GuardConfiguration, PermissionResolutionStrategy } from '../config/GuardConfiguration';
 import { PermissionRegistry } from '../registry/PermissionRegistry';
 import { PermissionResolverType, PermissionCheckResult, PermissionExpression } from '../resolvers/PermissionResolver';
 /**
  * Type alias for permission requirements that can be strings, string arrays, or complex expressions
+ * Note: Currently defined but reserved for future use
  */
-type PermissionRequirement = string | string[] | PermissionExpression | Record<string, unknown>;
+export type PermissionRequirement = string | string[] | PermissionExpression | Record<string, unknown>;
 /**
  * User context with cached permissions and metadata
  */
@@ -37,7 +38,7 @@ export interface UserContext {
     userId: string;
     permissions: Set<string>;
     roles: string[];
-    metadata: Record<string, unknown>;
+    metadata: Record<string, any>;
     expandedPermissions?: Set<string>;
     lastUpdated: string;
     expiresAt?: string;
@@ -52,7 +53,7 @@ export interface UserPermissionSource {
     getUserPermissions(userId: string): Promise<{
         permissions: string[];
         roles: string[];
-        metadata?: Record<string, unknown>;
+        metadata?: Record<string, any>;
     } | null>;
     /**
      * Get role-based permissions for expansion
@@ -117,7 +118,7 @@ export declare class FastUserContextService {
      * @param options - Check options
      * @returns Detailed permission check result
      */
-    checkPermission(userId: string, requirement: PermissionRequirement, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
+    checkPermission(userId: string, requirement: any, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
     /**
      * Batch check multiple permissions for a user
      *
@@ -130,7 +131,7 @@ export declare class FastUserContextService {
      * @returns Array of permission check results
      */
     checkPermissions(userId: string, requirements: Array<{
-        requirement: PermissionRequirement;
+        requirement: any;
         resolverType?: PermissionResolverType;
     }>, options?: PermissionCheckOptions): Promise<PermissionCheckResult[]>;
     /**
@@ -165,9 +166,33 @@ export declare class FastUserContextService {
         averageResolutionTimeUs: number;
         totalResolutionTimeUs: number;
         resolverStats: {
-            plain: Record<string, unknown>;
-            wildcard: Record<string, unknown>;
-            expression: Record<string, unknown>;
+            plain: {
+                checkCount: number;
+                averageResolutionTimeUs: number;
+                totalResolutionTimeUs: number;
+            };
+            wildcard: {
+                strategy: PermissionResolutionStrategy;
+                checkCount: number;
+                averageResolutionTimeUs: number;
+                totalResolutionTimeUs: number;
+                cacheHitRate: number;
+                cacheHits: number;
+                cacheMisses: number;
+            };
+            expression: {
+                checkCount: number;
+                averageResolutionTimeUs: number;
+                totalResolutionTimeUs: number;
+                cacheHitRate: number;
+                cacheHits: number;
+                cacheMisses: number;
+                complexityDistribution: {
+                    simple: number;
+                    moderate: number;
+                    complex: number;
+                };
+            };
         };
     };
     /**
@@ -199,5 +224,4 @@ export declare class FastUserContextService {
      */
     private recordAuditTrail;
 }
-export {};
 //# sourceMappingURL=FastUserContextService.d.ts.map

package/build/middlewares/index.d.ts

@@ -1,6 +1,3 @@
-export * from './SecurityMiddleware';
-export * from './ConsolidatedValidationMiddleware';
-export * from './ProcessingMiddleware';
 export * from './authenticationMiddleware';
 export * from './bodyParserMiddleware';
 export * from './bodyValidationMiddleware';
@@ -13,5 +10,6 @@ export * from './rateLimitingMiddleware';
 export * from './responseWrapperMiddleware';
 export * from './securityAuditMiddleware';
 export * from './securityHeadersMiddleware';
+export * from './validationMiddleware';
 export * from './guards';
 //# sourceMappingURL=index.d.ts.map

package/build/middlewares/index.js

@@ -14,11 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// === NEW CONSOLIDATED MIDDLEWARES ===
-__exportStar(require("./SecurityMiddleware"), exports);
-__exportStar(require("./ConsolidatedValidationMiddleware"), exports);
-__exportStar(require("./ProcessingMiddleware"), exports);
-// === EXISTING INDIVIDUAL MIDDLEWARES (for backward compatibility) ===
 __exportStar(require("./authenticationMiddleware"), exports);
 __exportStar(require("./bodyParserMiddleware"), exports);
 __exportStar(require("./bodyValidationMiddleware"), exports);
@@ -31,6 +26,6 @@ __exportStar(require("./rateLimitingMiddleware"), exports);
 __exportStar(require("./responseWrapperMiddleware"), exports);
 __exportStar(require("./securityAuditMiddleware"), exports);
 __exportStar(require("./securityHeadersMiddleware"), exports);
-// NOTE: validationMiddleware export removed due to naming conflict with new ValidationMiddleware
+__exportStar(require("./validationMiddleware"), exports);
 __exportStar(require("./guards"), exports);
 //# sourceMappingURL=index.js.map

package/build/middlewares/queryParametersMiddleware.d.ts

@@ -3,6 +3,8 @@ import { BaseMiddleware, Context } from '../core';
  * Middleware class that validates and processes query parameters from the request URL.
  * Extracts query parameters and validates that required parameters are present.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
  * @example
@@ -43,15 +45,17 @@ import { BaseMiddleware, Context } from '../core';
  *   });
  * ```
  */
-export declare class QueryParametersMiddleware implements BaseMiddleware {
+export declare class QueryParametersMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private readonly requiredParams;
     constructor(requiredParams?: string[]);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a query parameter processing middleware.
  * Extracts and validates query parameters from the request URL.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param requiredParams - Array of parameter names that must be present (default: empty array)
  * @returns BaseMiddleware object with query parameter processing logic
  *
@@ -109,5 +113,5 @@ export declare class QueryParametersMiddleware implements BaseMiddleware {
  *   });
  * ```
  */
-export declare const queryParametersMiddleware: (requiredParams?: string[]) => BaseMiddleware;
+export declare const queryParametersMiddleware: <TBody = unknown, TUser = unknown>(requiredParams?: string[]) => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=queryParametersMiddleware.d.ts.map

package/build/middlewares/queryParametersMiddleware.js

@@ -24,6 +24,8 @@ const convertQueryToRecord = (query) => {
  * Middleware class that validates and processes query parameters from the request URL.
  * Extracts query parameters and validates that required parameters are present.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
  * @example
@@ -84,6 +86,8 @@ exports.QueryParametersMiddleware = QueryParametersMiddleware;
  * Factory function that creates a query parameter processing middleware.
  * Extracts and validates query parameters from the request URL.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param requiredParams - Array of parameter names that must be present (default: empty array)
  * @returns BaseMiddleware object with query parameter processing logic
  *

package/build/middlewares/responseWrapperMiddleware.d.ts

@@ -5,6 +5,8 @@ import { Context } from '../core/core';
  * Automatically wraps the response with success flag, payload, and timestamp.
  *
  * @template T - The type of response data being wrapped
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
  * @example
@@ -60,14 +62,16 @@ import { Context } from '../core/core';
  *   });
  * ```
  */
-export declare class ResponseWrapperMiddleware<T> implements BaseMiddleware {
-    after(context: Context): Promise<void>;
+export declare class ResponseWrapperMiddleware<T = unknown, TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
+    after(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a response wrapper middleware.
  * Automatically wraps response data in a standardized format with success flag and timestamp.
  *
  * @template T - The type of response data being wrapped
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @returns BaseMiddleware object with response wrapping logic
  *
  * @example
@@ -118,12 +122,14 @@ export declare class ResponseWrapperMiddleware<T> implements BaseMiddleware {
  *   });
  * ```
  */
-export declare const responseWrapperMiddleware: <T>() => BaseMiddleware;
+export declare const responseWrapperMiddleware: <T = unknown, TBody = unknown, TUser = unknown>() => BaseMiddleware<TBody, TUser>;
 /**
  * Helper function to set response data in context for later wrapping.
  * This function should be used in handlers when using ResponseWrapperMiddleware.
  *
  * @template T - The type of data being set
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param context - The request context
  * @param data - The data to be included in the response payload
  *
@@ -176,5 +182,5 @@ export declare const responseWrapperMiddleware: <T>() => BaseMiddleware;
  *   });
  * ```
  */
-export declare function setResponseData<T>(context: Context, data: T): void;
+export declare function setResponseData<T, TBody = unknown, TUser = unknown>(context: Context<TBody, TUser>, data: T): void;
 //# sourceMappingURL=responseWrapperMiddleware.d.ts.map

package/build/middlewares/responseWrapperMiddleware.js

@@ -18,6 +18,8 @@ const wrapResponse = (context) => {
  * Automatically wraps the response with success flag, payload, and timestamp.
  *
  * @template T - The type of response data being wrapped
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
  * @example
@@ -84,6 +86,8 @@ exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
  * Automatically wraps response data in a standardized format with success flag and timestamp.
  *
  * @template T - The type of response data being wrapped
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @returns BaseMiddleware object with response wrapping logic
  *
  * @example
@@ -145,6 +149,8 @@ exports.responseWrapperMiddleware = responseWrapperMiddleware;
  * This function should be used in handlers when using ResponseWrapperMiddleware.
  *
  * @template T - The type of data being set
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param context - The request context
  * @param data - The data to be included in the response payload
  *

package/build/middlewares/validationMiddleware.d.ts

@@ -0,0 +1,154 @@
+import { BaseMiddleware, Context } from '../core';
+import { z } from 'zod';
+/**
+ * Middleware class that validates request data (body or query parameters) using Zod schemas.
+ * Automatically detects GET requests and validates query parameters, or validates body for other methods.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * User registration validation:
+ * ```typescript
+ * import { z } from 'zod';
+ * import { Handler, ValidationMiddleware } from '@noony-serverless/core';
+ *
+ * const userRegistrationSchema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ *   firstName: z.string().min(1),
+ *   lastName: z.string().min(1),
+ *   age: z.number().int().min(18).max(120)
+ * });
+ *
+ * const registerHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(new ValidationMiddleware(userRegistrationSchema))
+ *   .handle(async (context) => {
+ *     const validatedUser = context.req.validatedBody;
+ *     const newUser = await createUser(validatedUser);
+ *     return { success: true, userId: newUser.id };
+ *   });
+ * ```
+ *
+ * @example
+ * GET request query parameter validation:
+ * ```typescript
+ * const searchSchema = z.object({
+ *   q: z.string().min(1),
+ *   page: z.string().regex(/^\d+$/).transform(Number).default('1'),
+ *   limit: z.string().regex(/^\d+$/).transform(Number).default('10'),
+ *   category: z.string().optional()
+ * });
+ *
+ * const searchHandler = new Handler()
+ *   .use(new ValidationMiddleware(searchSchema))
+ *   .handle(async (context) => {
+ *     const { q, page, limit, category } = context.req.query;
+ *     const results = await searchItems(q, { page, limit, category });
+ *     return { success: true, results, query: { q, page, limit, category } };
+ *   });
+ * ```
+ *
+ * @example
+ * Product creation with nested validation:
+ * ```typescript
+ * const productSchema = z.object({
+ *   name: z.string().min(1).max(100),
+ *   description: z.string().max(1000),
+ *   price: z.number().positive(),
+ *   category: z.enum(['electronics', 'clothing', 'books', 'home']),
+ *   specifications: z.record(z.string()),
+ *   images: z.array(z.string().url()).max(5),
+ *   inventory: z.object({
+ *     inStock: z.boolean(),
+ *     quantity: z.number().int().min(0),
+ *     warehouse: z.string()
+ *   })
+ * });
+ *
+ * const createProductHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(new ValidationMiddleware(productSchema))
+ *   .handle(async (context) => {
+ *     const productData = context.req.validatedBody;
+ *     const product = await createProduct(productData);
+ *     return { success: true, productId: product.id };
+ *   });
+ * ```
+ */
+export declare class ValidationMiddleware implements BaseMiddleware {
+    private readonly schema;
+    constructor(schema: z.ZodSchema);
+    before(context: Context): Promise<void>;
+}
+/**
+ * Factory function that creates a validation middleware using Zod schema.
+ * Automatically validates request body for non-GET requests or query parameters for GET requests.
+ *
+ * @param schema - Zod schema to validate against
+ * @returns BaseMiddleware object with validation logic
+ *
+ * @example
+ * Login endpoint validation:
+ * ```typescript
+ * import { z } from 'zod';
+ * import { Handler, validationMiddleware } from '@noony-serverless/core';
+ *
+ * const loginSchema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(1),
+ *   rememberMe: z.boolean().optional()
+ * });
+ *
+ * const loginHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(validationMiddleware(loginSchema))
+ *   .handle(async (context) => {
+ *     const { email, password, rememberMe } = context.req.validatedBody;
+ *     const token = await authenticate(email, password);
+ *     return { success: true, token, rememberMe };
+ *   });
+ * ```
+ *
+ * @example
+ * API filtering with query validation:
+ * ```typescript
+ * const filterSchema = z.object({
+ *   status: z.enum(['active', 'inactive', 'pending']).optional(),
+ *   sort: z.enum(['name', 'date', 'status']).default('name'),
+ *   order: z.enum(['asc', 'desc']).default('asc'),
+ *   limit: z.coerce.number().int().min(1).max(100).default(10)
+ * });
+ *
+ * const getItemsHandler = new Handler()
+ *   .use(validationMiddleware(filterSchema))
+ *   .handle(async (context) => {
+ *     const filters = context.req.query;
+ *     const items = await getFilteredItems(filters);
+ *     return { success: true, items, appliedFilters: filters };
+ *   });
+ * ```
+ *
+ * @example
+ * File upload validation:
+ * ```typescript
+ * const uploadSchema = z.object({
+ *   filename: z.string().min(1),
+ *   mimeType: z.string().regex(/^(image|document)\//),
+ *   size: z.number().max(10 * 1024 * 1024), // 10MB max
+ *   description: z.string().max(200).optional(),
+ *   tags: z.array(z.string()).max(10).optional()
+ * });
+ *
+ * const uploadHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(validationMiddleware(uploadSchema))
+ *   .handle(async (context) => {
+ *     const fileData = context.req.validatedBody;
+ *     const upload = await processFileUpload(fileData);
+ *     return { success: true, fileId: upload.id };
+ *   });
+ * ```
+ */
+export declare const validationMiddleware: (schema: z.ZodSchema) => BaseMiddleware;
+//# sourceMappingURL=validationMiddleware.d.ts.map

package/build/middlewares/validationMiddleware.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationMiddleware = exports.ValidationMiddleware = void 0;
+const core_1 = require("../core");
+const zod_1 = require("zod");
+const validate = async (schema, context) => {
+    try {
+        const data = context.req.method === 'GET' ? context.req.query : context.req.parsedBody;
+        const validated = await schema.parseAsync(data);
+        if (context.req.method === 'GET') {
+            context.req.query = validated;
+        }
+        else {
+            context.req.validatedBody = validated;
+        }
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            throw new core_1.ValidationError('Validation error', JSON.stringify(error.issues));
+        }
+        throw error;
+    }
+};
+/**
+ * Middleware class that validates request data (body or query parameters) using Zod schemas.
+ * Automatically detects GET requests and validates query parameters, or validates body for other methods.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * User registration validation:
+ * ```typescript
+ * import { z } from 'zod';
+ * import { Handler, ValidationMiddleware } from '@noony-serverless/core';
+ *
+ * const userRegistrationSchema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ *   firstName: z.string().min(1),
+ *   lastName: z.string().min(1),
+ *   age: z.number().int().min(18).max(120)
+ * });
+ *
+ * const registerHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(new ValidationMiddleware(userRegistrationSchema))
+ *   .handle(async (context) => {
+ *     const validatedUser = context.req.validatedBody;
+ *     const newUser = await createUser(validatedUser);
+ *     return { success: true, userId: newUser.id };
+ *   });
+ * ```
+ *
+ * @example
+ * GET request query parameter validation:
+ * ```typescript
+ * const searchSchema = z.object({
+ *   q: z.string().min(1),
+ *   page: z.string().regex(/^\d+$/).transform(Number).default('1'),
+ *   limit: z.string().regex(/^\d+$/).transform(Number).default('10'),
+ *   category: z.string().optional()
+ * });
+ *
+ * const searchHandler = new Handler()
+ *   .use(new ValidationMiddleware(searchSchema))
+ *   .handle(async (context) => {
+ *     const { q, page, limit, category } = context.req.query;
+ *     const results = await searchItems(q, { page, limit, category });
+ *     return { success: true, results, query: { q, page, limit, category } };
+ *   });
+ * ```
+ *
+ * @example
+ * Product creation with nested validation:
+ * ```typescript
+ * const productSchema = z.object({
+ *   name: z.string().min(1).max(100),
+ *   description: z.string().max(1000),
+ *   price: z.number().positive(),
+ *   category: z.enum(['electronics', 'clothing', 'books', 'home']),
+ *   specifications: z.record(z.string()),
+ *   images: z.array(z.string().url()).max(5),
+ *   inventory: z.object({
+ *     inStock: z.boolean(),
+ *     quantity: z.number().int().min(0),
+ *     warehouse: z.string()
+ *   })
+ * });
+ *
+ * const createProductHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(new ValidationMiddleware(productSchema))
+ *   .handle(async (context) => {
+ *     const productData = context.req.validatedBody;
+ *     const product = await createProduct(productData);
+ *     return { success: true, productId: product.id };
+ *   });
+ * ```
+ */
+class ValidationMiddleware {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    async before(context) {
+        await validate(this.schema, context);
+    }
+}
+exports.ValidationMiddleware = ValidationMiddleware;
+/**
+ * Factory function that creates a validation middleware using Zod schema.
+ * Automatically validates request body for non-GET requests or query parameters for GET requests.
+ *
+ * @param schema - Zod schema to validate against
+ * @returns BaseMiddleware object with validation logic
+ *
+ * @example
+ * Login endpoint validation:
+ * ```typescript
+ * import { z } from 'zod';
+ * import { Handler, validationMiddleware } from '@noony-serverless/core';
+ *
+ * const loginSchema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(1),
+ *   rememberMe: z.boolean().optional()
+ * });
+ *
+ * const loginHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(validationMiddleware(loginSchema))
+ *   .handle(async (context) => {
+ *     const { email, password, rememberMe } = context.req.validatedBody;
+ *     const token = await authenticate(email, password);
+ *     return { success: true, token, rememberMe };
+ *   });
+ * ```
+ *
+ * @example
+ * API filtering with query validation:
+ * ```typescript
+ * const filterSchema = z.object({
+ *   status: z.enum(['active', 'inactive', 'pending']).optional(),
+ *   sort: z.enum(['name', 'date', 'status']).default('name'),
+ *   order: z.enum(['asc', 'desc']).default('asc'),
+ *   limit: z.coerce.number().int().min(1).max(100).default(10)
+ * });
+ *
+ * const getItemsHandler = new Handler()
+ *   .use(validationMiddleware(filterSchema))
+ *   .handle(async (context) => {
+ *     const filters = context.req.query;
+ *     const items = await getFilteredItems(filters);
+ *     return { success: true, items, appliedFilters: filters };
+ *   });
+ * ```
+ *
+ * @example
+ * File upload validation:
+ * ```typescript
+ * const uploadSchema = z.object({
+ *   filename: z.string().min(1),
+ *   mimeType: z.string().regex(/^(image|document)\//),
+ *   size: z.number().max(10 * 1024 * 1024), // 10MB max
+ *   description: z.string().max(200).optional(),
+ *   tags: z.array(z.string()).max(10).optional()
+ * });
+ *
+ * const uploadHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(validationMiddleware(uploadSchema))
+ *   .handle(async (context) => {
+ *     const fileData = context.req.validatedBody;
+ *     const upload = await processFileUpload(fileData);
+ *     return { success: true, fileId: upload.id };
+ *   });
+ * ```
+ */
+const validationMiddleware = (schema) => ({
+    before: async (context) => {
+        await validate(schema, context);
+    },
+});
+exports.validationMiddleware = validationMiddleware;
+//# sourceMappingURL=validationMiddleware.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noony-serverless/core",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -43,13 +43,11 @@
     "@google-cloud/functions-framework": "^4.0.0",
     "@google-cloud/pubsub": "^4.1.0",
     "@types/jsonwebtoken": "^9.0.10",
-    "@types/qs": "^6.14.0",
     "axios": "^1.11.0",
     "fastify": "^5.6.0",
     "firebase-admin": "^13.5.0",
     "firebase-functions": "^6.4.0",
     "jsonwebtoken": "^9.0.2",
-    "qs": "^6.14.0",
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0",
     "zod": "^4.1.5"