@noony-serverless/core 0.1.1 → 0.2.0

package/build/middlewares/httpAttributesMiddleware.js

@@ -3,6 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatedQueryParameters = exports.headerVariablesValidator = exports.pathParameters = exports.PathParametersMiddleware = void 0;
 const errors_1 = require("../core/errors");
 const zod_1 = require("zod");
+/**
+ * Middleware class that extracts path parameters from the URL.
+ * Parses URL segments and extracts parameters based on colon-prefixed patterns.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * Basic path parameter extraction:
+ * ```typescript
+ * import { Handler, PathParametersMiddleware } from '@noony-serverless/core';
+ *
+ * // For URL: /users/123/posts/456
+ * const userPostHandler = new Handler()
+ *   .use(new PathParametersMiddleware())
+ *   .handle(async (context) => {
+ *     // Assuming your routing pattern is /users/:userId/posts/:postId
+ *     const { userId, postId } = context.req.params || {};
+ *
+ *     const user = await getUserById(userId);
+ *     const post = await getPostById(postId);
+ *
+ *     return { success: true, user, post };
+ *   });
+ * ```
+ *
+ * @example
+ * RESTful API with multiple parameters:
+ * ```typescript
+ * // For URL: /api/v1/organizations/org-123/projects/proj-456/tasks/task-789
+ * const taskHandler = new Handler()
+ *   .use(new PathParametersMiddleware())
+ *   .handle(async (context) => {
+ *     const { organizationId, projectId, taskId } = context.req.params || {};
+ *
+ *     const task = await getTask(organizationId, projectId, taskId);
+ *     return { success: true, task };
+ *   });
+ * ```
+ *
+ * @example
+ * E-commerce product details:
+ * ```typescript
+ * // For URL: /categories/electronics/products/laptop-123
+ * const productHandler = new Handler()
+ *   .use(new PathParametersMiddleware())
+ *   .handle(async (context) => {
+ *     const { category, productId } = context.req.params || {};
+ *
+ *     const product = await getProductByCategory(category, productId);
+ *     const recommendations = await getRecommendations(category, productId);
+ *
+ *     return { success: true, product, recommendations };
+ *   });
+ * ```
+ */
 class PathParametersMiddleware {
     async before(context) {
         const host = (Array.isArray(context.req.headers.host)
@@ -24,6 +79,54 @@ class PathParametersMiddleware {
     }
 }
 exports.PathParametersMiddleware = PathParametersMiddleware;
+/**
+ * Factory function that creates a path parameters extraction middleware.
+ * Extracts URL path segments and sets them in context.req.params.
+ *
+ * @returns BaseMiddleware object with path parameter extraction logic
+ *
+ * @example
+ * Simple product API:
+ * ```typescript
+ * import { Handler, pathParameters } from '@noony-serverless/core';
+ *
+ * // For URL: /products/123
+ * const getProductHandler = new Handler()
+ *   .use(pathParameters())
+ *   .handle(async (context) => {
+ *     const productId = context.req.params?.id;
+ *     const product = await getProduct(productId);
+ *     return { success: true, product };
+ *   });
+ * ```
+ *
+ * @example
+ * Blog post with category:
+ * ```typescript
+ * // For URL: /blog/technology/post-123
+ * const blogPostHandler = new Handler()
+ *   .use(pathParameters())
+ *   .handle(async (context) => {
+ *     const { category, postId } = context.req.params || {};
+ *     const post = await getBlogPost(category, postId);
+ *     const relatedPosts = await getRelatedPosts(category);
+ *     return { success: true, post, relatedPosts };
+ *   });
+ * ```
+ *
+ * @example
+ * Nested resource API:
+ * ```typescript
+ * // For URL: /users/user-123/orders/order-456/items
+ * const orderItemsHandler = new Handler()
+ *   .use(pathParameters())
+ *   .handle(async (context) => {
+ *     const { userId, orderId } = context.req.params || {};
+ *     const orderItems = await getOrderItems(userId, orderId);
+ *     return { success: true, items: orderItems };
+ *   });
+ * ```
+ */
 const pathParameters = () => ({
     before: async (context) => {
         const host = (Array.isArray(context.req.headers.host)
@@ -43,6 +146,60 @@ const pathParameters = () => ({
     },
 });
 exports.pathParameters = pathParameters;
+/**
+ * Factory function that creates a header validation middleware.
+ * Validates that all required headers are present in the request.
+ *
+ * @param requiredHeaders - Array of header names that must be present
+ * @returns BaseMiddleware object with header validation logic
+ *
+ * @example
+ * API authentication headers:
+ * ```typescript
+ * import { Handler, headerVariablesValidator } from '@noony-serverless/core';
+ *
+ * const secureApiHandler = new Handler()
+ *   .use(headerVariablesValidator(['authorization', 'x-api-key']))
+ *   .handle(async (context) => {
+ *     const authToken = context.req.headers.authorization;
+ *     const apiKey = context.req.headers['x-api-key'];
+ *
+ *     const isValid = await validateCredentials(authToken, apiKey);
+ *     return { success: isValid, message: 'Access granted' };
+ *   });
+ * ```
+ *
+ * @example
+ * Content type validation:
+ * ```typescript
+ * const uploadHandler = new Handler()
+ *   .use(headerVariablesValidator(['content-type', 'content-length']))
+ *   .handle(async (context) => {
+ *     const contentType = context.req.headers['content-type'];
+ *     const contentLength = context.req.headers['content-length'];
+ *
+ *     if (contentType !== 'application/json') {
+ *       throw new Error('Only JSON content is accepted');
+ *     }
+ *
+ *     return { success: true, received: contentLength };
+ *   });
+ * ```
+ *
+ * @example
+ * Multi-tenant application:
+ * ```typescript
+ * const tenantHandler = new Handler()
+ *   .use(headerVariablesValidator(['x-tenant-id', 'x-client-version']))
+ *   .handle(async (context) => {
+ *     const tenantId = context.req.headers['x-tenant-id'];
+ *     const clientVersion = context.req.headers['x-client-version'];
+ *
+ *     const tenantConfig = await getTenantConfig(tenantId);
+ *     return { success: true, config: tenantConfig, version: clientVersion };
+ *   });
+ * ```
+ */
 const headerVariablesValidator = (requiredHeaders) => ({
     before: async (context) => {
         for (const header of requiredHeaders) {
@@ -53,6 +210,84 @@ const headerVariablesValidator = (requiredHeaders) => ({
     },
 });
 exports.headerVariablesValidator = headerVariablesValidator;
+/**
+ * Factory function that creates a query parameter validation middleware using Zod schema.
+ * Validates query parameters against a provided schema and throws ValidationError if invalid.
+ *
+ * @param schema - Zod schema to validate query parameters against
+ * @returns BaseMiddleware object with query parameter validation logic
+ *
+ * @example
+ * Pagination parameters validation:
+ * ```typescript
+ * import { z } from 'zod';
+ * import { Handler, validatedQueryParameters } from '@noony-serverless/core';
+ *
+ * const paginationSchema = z.object({
+ *   page: z.string().regex(/^\d+$/).transform(Number).default('1'),
+ *   limit: z.string().regex(/^\d+$/).transform(Number).default('10'),
+ *   sort: z.enum(['asc', 'desc']).default('asc')
+ * });
+ *
+ * const listUsersHandler = new Handler()
+ *   .use(validatedQueryParameters(paginationSchema))
+ *   .handle(async (context) => {
+ *     const { page, limit, sort } = context.req.query;
+ *     const users = await getUsersPaginated(page, limit, sort);
+ *     return { success: true, users, pagination: { page, limit, sort } };
+ *   });
+ * ```
+ *
+ * @example
+ * Search and filter parameters:
+ * ```typescript
+ * const searchSchema = z.object({
+ *   q: z.string().min(1),
+ *   category: z.string().optional(),
+ *   price_min: z.string().regex(/^\d+(\.\d{2})?$/).optional(),
+ *   price_max: z.string().regex(/^\d+(\.\d{2})?$/).optional(),
+ *   in_stock: z.enum(['true', 'false']).optional()
+ * });
+ *
+ * const searchProductsHandler = new Handler()
+ *   .use(validatedQueryParameters(searchSchema))
+ *   .handle(async (context) => {
+ *     const { q, category, price_min, price_max, in_stock } = context.req.query;
+ *     const filters = {
+ *       query: q,
+ *       category,
+ *       priceRange: { min: price_min, max: price_max },
+ *       inStock: in_stock === 'true'
+ *     };
+ *     const products = await searchProducts(filters);
+ *     return { success: true, products, filters };
+ *   });
+ * ```
+ *
+ * @example
+ * Date range and reporting parameters:
+ * ```typescript
+ * const reportSchema = z.object({
+ *   start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+ *   end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+ *   granularity: z.enum(['day', 'week', 'month']).default('day'),
+ *   metrics: z.string().transform(val => val.split(',')).optional()
+ * });
+ *
+ * const analyticsHandler = new Handler()
+ *   .use(validatedQueryParameters(reportSchema))
+ *   .handle(async (context) => {
+ *     const { start_date, end_date, granularity, metrics } = context.req.query;
+ *     const report = await generateReport({
+ *       startDate: new Date(start_date),
+ *       endDate: new Date(end_date),
+ *       granularity,
+ *       metrics
+ *     });
+ *     return { success: true, report };
+ *   });
+ * ```
+ */
 const validatedQueryParameters = (schema) => ({
     before: async (context) => {
         const queryParams = context.req.query;
@@ -61,7 +296,7 @@ const validatedQueryParameters = (schema) => ({
         }
         catch (error) {
             if (error instanceof zod_1.z.ZodError) {
-                throw new errors_1.ValidationError('Validation error', JSON.stringify(error.errors));
+                throw new errors_1.ValidationError('Validation error', JSON.stringify(error.issues));
             }
             throw error;
         }

package/build/middlewares/index.d.ts

@@ -1,3 +1,6 @@
+export * from './SecurityMiddleware';
+export * from './ConsolidatedValidationMiddleware';
+export * from './ProcessingMiddleware';
 export * from './authenticationMiddleware';
 export * from './bodyParserMiddleware';
 export * from './bodyValidationMiddleware';
@@ -10,6 +13,5 @@ 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,6 +14,11 @@ 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);
@@ -26,6 +31,6 @@ __exportStar(require("./rateLimitingMiddleware"), exports);
 __exportStar(require("./responseWrapperMiddleware"), exports);
 __exportStar(require("./securityAuditMiddleware"), exports);
 __exportStar(require("./securityHeadersMiddleware"), exports);
-__exportStar(require("./validationMiddleware"), exports);
+// NOTE: validationMiddleware export removed due to naming conflict with new ValidationMiddleware
 __exportStar(require("./guards"), exports);
 //# sourceMappingURL=index.js.map

package/build/middlewares/queryParametersMiddleware.d.ts

@@ -1,8 +1,113 @@
 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.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * Basic query parameter validation:
+ * ```typescript
+ * import { Handler, QueryParametersMiddleware } from '@noony-serverless/core';
+ *
+ * const searchHandler = new Handler()
+ *   .use(new QueryParametersMiddleware(['q', 'type']))
+ *   .handle(async (context) => {
+ *     const { q, type } = context.req.query;
+ *     const results = await search(q, type);
+ *     return { success: true, results, query: q, type };
+ *   });
+ * ```
+ *
+ * @example
+ * Pagination with required parameters:
+ * ```typescript
+ * const listHandler = new Handler()
+ *   .use(new QueryParametersMiddleware(['page', 'limit']))
+ *   .handle(async (context) => {
+ *     const { page, limit, sort } = context.req.query;
+ *     const items = await getItems(parseInt(page), parseInt(limit), sort);
+ *     return { success: true, items, pagination: { page, limit } };
+ *   });
+ * ```
+ *
+ * @example
+ * Optional parameters (empty required array):
+ * ```typescript
+ * const flexibleHandler = new Handler()
+ *   .use(new QueryParametersMiddleware([])) // No required parameters
+ *   .handle(async (context) => {
+ *     const { filter, sort, category } = context.req.query || {};
+ *     const data = await getData({ filter, sort, category });
+ *     return { success: true, data };
+ *   });
+ * ```
+ */
 export declare class QueryParametersMiddleware implements BaseMiddleware {
     private readonly requiredParams;
     constructor(requiredParams?: string[]);
     before(context: Context): Promise<void>;
 }
+/**
+ * Factory function that creates a query parameter processing middleware.
+ * Extracts and validates query parameters from the request URL.
+ *
+ * @param requiredParams - Array of parameter names that must be present (default: empty array)
+ * @returns BaseMiddleware object with query parameter processing logic
+ *
+ * @example
+ * API endpoint with required search parameters:
+ * ```typescript
+ * import { Handler, queryParametersMiddleware } from '@noony-serverless/core';
+ *
+ * const searchApiHandler = new Handler()
+ *   .use(queryParametersMiddleware(['q'])) // 'q' parameter is required
+ *   .handle(async (context) => {
+ *     const { q, category, sort } = context.req.query;
+ *     const searchResults = await performSearch(q, { category, sort });
+ *     return { success: true, results: searchResults };
+ *   });
+ * ```
+ *
+ * @example
+ * E-commerce product listing with filters:
+ * ```typescript
+ * const productListHandler = new Handler()
+ *   .use(queryParametersMiddleware(['category'])) // Category is required
+ *   .handle(async (context) => {
+ *     const { category, price_min, price_max, brand, sort } = context.req.query;
+ *     const products = await getProducts({
+ *       category,
+ *       priceRange: { min: price_min, max: price_max },
+ *       brand,
+ *       sortBy: sort || 'name'
+ *     });
+ *     return { success: true, products, filters: { category, brand, sort } };
+ *   });
+ * ```
+ *
+ * @example
+ * Flexible API with optional parameters:
+ * ```typescript
+ * const dataHandler = new Handler()
+ *   .use(queryParametersMiddleware()) // No required parameters
+ *   .handle(async (context) => {
+ *     const queryParams = context.req.query || {};
+ *     const {
+ *       page = '1',
+ *       limit = '10',
+ *       sort = 'created_at',
+ *       order = 'desc'
+ *     } = queryParams;
+ *
+ *     const data = await fetchData({
+ *       pagination: { page: parseInt(page), limit: parseInt(limit) },
+ *       sorting: { field: sort, order }
+ *     });
+ *
+ *     return { success: true, data, meta: { page, limit, sort, order } };
+ *   });
+ * ```
+ */
 export declare const queryParametersMiddleware: (requiredParams?: string[]) => BaseMiddleware;
 //# sourceMappingURL=queryParametersMiddleware.d.ts.map

package/build/middlewares/queryParametersMiddleware.js

@@ -20,6 +20,50 @@ const convertQueryToRecord = (query) => {
     }
     return result;
 };
+/**
+ * Middleware class that validates and processes query parameters from the request URL.
+ * Extracts query parameters and validates that required parameters are present.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * Basic query parameter validation:
+ * ```typescript
+ * import { Handler, QueryParametersMiddleware } from '@noony-serverless/core';
+ *
+ * const searchHandler = new Handler()
+ *   .use(new QueryParametersMiddleware(['q', 'type']))
+ *   .handle(async (context) => {
+ *     const { q, type } = context.req.query;
+ *     const results = await search(q, type);
+ *     return { success: true, results, query: q, type };
+ *   });
+ * ```
+ *
+ * @example
+ * Pagination with required parameters:
+ * ```typescript
+ * const listHandler = new Handler()
+ *   .use(new QueryParametersMiddleware(['page', 'limit']))
+ *   .handle(async (context) => {
+ *     const { page, limit, sort } = context.req.query;
+ *     const items = await getItems(parseInt(page), parseInt(limit), sort);
+ *     return { success: true, items, pagination: { page, limit } };
+ *   });
+ * ```
+ *
+ * @example
+ * Optional parameters (empty required array):
+ * ```typescript
+ * const flexibleHandler = new Handler()
+ *   .use(new QueryParametersMiddleware([])) // No required parameters
+ *   .handle(async (context) => {
+ *     const { filter, sort, category } = context.req.query || {};
+ *     const data = await getData({ filter, sort, category });
+ *     return { success: true, data };
+ *   });
+ * ```
+ */
 class QueryParametersMiddleware {
     requiredParams;
     constructor(requiredParams = []) {
@@ -36,6 +80,67 @@ class QueryParametersMiddleware {
     }
 }
 exports.QueryParametersMiddleware = QueryParametersMiddleware;
+/**
+ * Factory function that creates a query parameter processing middleware.
+ * Extracts and validates query parameters from the request URL.
+ *
+ * @param requiredParams - Array of parameter names that must be present (default: empty array)
+ * @returns BaseMiddleware object with query parameter processing logic
+ *
+ * @example
+ * API endpoint with required search parameters:
+ * ```typescript
+ * import { Handler, queryParametersMiddleware } from '@noony-serverless/core';
+ *
+ * const searchApiHandler = new Handler()
+ *   .use(queryParametersMiddleware(['q'])) // 'q' parameter is required
+ *   .handle(async (context) => {
+ *     const { q, category, sort } = context.req.query;
+ *     const searchResults = await performSearch(q, { category, sort });
+ *     return { success: true, results: searchResults };
+ *   });
+ * ```
+ *
+ * @example
+ * E-commerce product listing with filters:
+ * ```typescript
+ * const productListHandler = new Handler()
+ *   .use(queryParametersMiddleware(['category'])) // Category is required
+ *   .handle(async (context) => {
+ *     const { category, price_min, price_max, brand, sort } = context.req.query;
+ *     const products = await getProducts({
+ *       category,
+ *       priceRange: { min: price_min, max: price_max },
+ *       brand,
+ *       sortBy: sort || 'name'
+ *     });
+ *     return { success: true, products, filters: { category, brand, sort } };
+ *   });
+ * ```
+ *
+ * @example
+ * Flexible API with optional parameters:
+ * ```typescript
+ * const dataHandler = new Handler()
+ *   .use(queryParametersMiddleware()) // No required parameters
+ *   .handle(async (context) => {
+ *     const queryParams = context.req.query || {};
+ *     const {
+ *       page = '1',
+ *       limit = '10',
+ *       sort = 'created_at',
+ *       order = 'desc'
+ *     } = queryParams;
+ *
+ *     const data = await fetchData({
+ *       pagination: { page: parseInt(page), limit: parseInt(limit) },
+ *       sorting: { field: sort, order }
+ *     });
+ *
+ *     return { success: true, data, meta: { page, limit, sort, order } };
+ *   });
+ * ```
+ */
 const queryParametersMiddleware = (requiredParams = []) => ({
     async before(context) {
         const host = (Array.isArray(context.req.headers.host)