@noony-serverless/core 0.2.2 → 0.3.0

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.0",
   "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"