@noony-serverless/core 0.1.1 → 0.2.0

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

@@ -23,9 +23,13 @@
  * @version 1.0.0
  */
 import { CacheAdapter } from '../cache/CacheAdapter';
-import { GuardConfiguration, PermissionResolutionStrategy } from '../config/GuardConfiguration';
+import { GuardConfiguration } from '../config/GuardConfiguration';
 import { PermissionRegistry } from '../registry/PermissionRegistry';
-import { PermissionResolverType, PermissionCheckResult } from '../resolvers/PermissionResolver';
+import { PermissionResolverType, PermissionCheckResult, PermissionExpression } from '../resolvers/PermissionResolver';
+/**
+ * Type alias for permission requirements that can be strings, string arrays, or complex expressions
+ */
+type PermissionRequirement = string | string[] | PermissionExpression | Record<string, unknown>;
 /**
  * User context with cached permissions and metadata
  */
@@ -33,7 +37,7 @@ export interface UserContext {
     userId: string;
     permissions: Set<string>;
     roles: string[];
-    metadata: Record<string, any>;
+    metadata: Record<string, unknown>;
     expandedPermissions?: Set<string>;
     lastUpdated: string;
     expiresAt?: string;
@@ -48,7 +52,7 @@ export interface UserPermissionSource {
     getUserPermissions(userId: string): Promise<{
         permissions: string[];
         roles: string[];
-        metadata?: Record<string, any>;
+        metadata?: Record<string, unknown>;
     } | null>;
     /**
      * Get role-based permissions for expansion
@@ -85,6 +89,12 @@ export declare class FastUserContextService {
     private permissionChecks;
     private totalResolutionTimeUs;
     constructor(cache: CacheAdapter, config: GuardConfiguration, permissionSource: UserPermissionSource, permissionRegistry: PermissionRegistry);
+    /**
+     * Check if caching is effectively disabled
+     *
+     * @returns true if caching is disabled (either by environment variable or NoopCacheAdapter)
+     */
+    private isCachingDisabled;
     /**
      * Get or load user context with permissions
      *
@@ -107,7 +117,7 @@ export declare class FastUserContextService {
      * @param options - Check options
      * @returns Detailed permission check result
      */
-    checkPermission(userId: string, requirement: any, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
+    checkPermission(userId: string, requirement: PermissionRequirement, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
     /**
      * Batch check multiple permissions for a user
      *
@@ -120,7 +130,7 @@ export declare class FastUserContextService {
      * @returns Array of permission check results
      */
     checkPermissions(userId: string, requirements: Array<{
-        requirement: any;
+        requirement: PermissionRequirement;
         resolverType?: PermissionResolverType;
     }>, options?: PermissionCheckOptions): Promise<PermissionCheckResult[]>;
     /**
@@ -155,33 +165,9 @@ export declare class FastUserContextService {
         averageResolutionTimeUs: number;
         totalResolutionTimeUs: number;
         resolverStats: {
-            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;
-                };
-            };
+            plain: Record<string, unknown>;
+            wildcard: Record<string, unknown>;
+            expression: Record<string, unknown>;
         };
     };
     /**
@@ -213,4 +199,5 @@ export declare class FastUserContextService {
      */
     private recordAuditTrail;
 }
+export {};
 //# sourceMappingURL=FastUserContextService.d.ts.map

package/build/middlewares/guards/services/FastUserContextService.js

@@ -41,6 +41,7 @@ const PlainPermissionResolver_1 = require("../resolvers/PlainPermissionResolver"
 const WildcardPermissionResolver_1 = require("../resolvers/WildcardPermissionResolver");
 const ExpressionPermissionResolver_1 = require("../resolvers/ExpressionPermissionResolver");
 const PermissionResolver_1 = require("../resolvers/PermissionResolver");
+const NoopCacheAdapter_1 = require("../cache/NoopCacheAdapter");
 /**
  * Fast User Context Service Implementation
  */
@@ -66,9 +67,19 @@ let FastUserContextService = class FastUserContextService {
         this._permissionRegistry = permissionRegistry;
         // Initialize permission resolvers
         this.plainResolver = new PlainPermissionResolver_1.PlainPermissionResolver();
-        this.wildcardResolver = new WildcardPermissionResolver_1.WildcardPermissionResolver(config.security.permissionResolutionStrategy, this._permissionRegistry, cache);
+        this.wildcardResolver = new WildcardPermissionResolver_1.WildcardPermissionResolver(config.security.permissionResolutionStrategy ??
+            GuardConfiguration_1.PermissionResolutionStrategy.PRE_EXPANSION, this._permissionRegistry, cache);
         this.expressionResolver = new ExpressionPermissionResolver_1.ExpressionPermissionResolver(cache);
     }
+    /**
+     * Check if caching is effectively disabled
+     *
+     * @returns true if caching is disabled (either by environment variable or NoopCacheAdapter)
+     */
+    isCachingDisabled() {
+        return (!GuardConfiguration_1.GuardConfiguration.isCachingEnabled() ||
+            this.cache instanceof NoopCacheAdapter_1.NoopCacheAdapter);
+    }
     /**
      * Get or load user context with permissions
      *
@@ -83,8 +94,9 @@ let FastUserContextService = class FastUserContextService {
         const startTime = process.hrtime.bigint();
         this.contextLoads++;
         try {
-            // Check cache first unless forced refresh
-            if (!forceRefresh) {
+            const cachingDisabled = this.isCachingDisabled();
+            // Check cache first unless forced refresh or caching is disabled
+            if (!forceRefresh && !cachingDisabled) {
                 const cachedContext = await this.loadFromCache(userId);
                 if (cachedContext) {
                     this.cacheHits++;
@@ -99,8 +111,10 @@ let FastUserContextService = class FastUserContextService {
             }
             // Build user context
             const context = await this.buildUserContext(userId, userData);
-            // Cache the context
-            await this.saveToCache(context);
+            // Cache the context only if caching is enabled
+            if (!cachingDisabled) {
+                await this.saveToCache(context);
+            }
             return context;
         }
         finally {

package/build/middlewares/headerVariablesMiddleware.d.ts

@@ -1,8 +1,126 @@
 import { BaseMiddleware, Context } from '../core';
+/**
+ * Middleware class that validates the presence of required HTTP headers.
+ * Throws a ValidationError if any required header is missing or empty.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * API key authentication via headers:
+ * ```typescript
+ * import { Handler, HeaderVariablesMiddleware } from '@noony-serverless/core';
+ *
+ * const requiredHeaders = ['authorization', 'x-api-key', 'content-type'];
+ *
+ * const secureApiHandler = new Handler()
+ *   .use(new HeaderVariablesMiddleware(requiredHeaders))
+ *   .handle(async (context) => {
+ *     const authHeader = context.req.headers.authorization;
+ *     const apiKey = context.req.headers['x-api-key'];
+ *
+ *     // Headers are guaranteed to exist after middleware validation
+ *     console.log('Auth header:', authHeader);
+ *     console.log('API key:', apiKey);
+ *
+ *     return { success: true, authenticated: true };
+ *   });
+ * ```
+ *
+ * @example
+ * Content negotiation requirements:
+ * ```typescript
+ * const contentHeaders = ['accept', 'content-type', 'accept-language'];
+ *
+ * const internationalApiHandler = new Handler()
+ *   .use(new HeaderVariablesMiddleware(contentHeaders))
+ *   .handle(async (context) => {
+ *     const acceptLang = context.req.headers['accept-language'];
+ *     const contentType = context.req.headers['content-type'];
+ *
+ *     const language = Array.isArray(acceptLang) ? acceptLang[0] : acceptLang;
+ *     const responseData = getLocalizedContent(language);
+ *
+ *     return { success: true, data: responseData, language };
+ *   });
+ * ```
+ *
+ * @example
+ * Custom business headers validation:
+ * ```typescript
+ * const businessHeaders = ['x-tenant-id', 'x-request-id', 'x-client-version'];
+ *
+ * const multiTenantHandler = new Handler()
+ *   .use(new HeaderVariablesMiddleware(businessHeaders))
+ *   .handle(async (context) => {
+ *     const tenantId = context.req.headers['x-tenant-id'];
+ *     const requestId = context.req.headers['x-request-id'];
+ *     const clientVersion = context.req.headers['x-client-version'];
+ *
+ *     console.log(`Processing request ${requestId} for tenant ${tenantId} with client ${clientVersion}`);
+ *
+ *     const tenantData = await getTenantData(tenantId as string);
+ *     return { success: true, tenant: tenantData };
+ *   });
+ * ```
+ */
 export declare class HeaderVariablesMiddleware implements BaseMiddleware {
     private requiredHeaders;
     constructor(requiredHeaders: string[]);
     before(context: Context): Promise<void>;
 }
+/**
+ * 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
+ * Simple header validation:
+ * ```typescript
+ * import { Handler, headerVariablesMiddleware } from '@noony-serverless/core';
+ *
+ * const authHandler = new Handler()
+ *   .use(headerVariablesMiddleware(['authorization']))
+ *   .handle(async (context) => {
+ *     const token = context.req.headers.authorization;
+ *     // Proceed with authentication logic
+ *     return { success: true, message: 'Authenticated' };
+ *   });
+ * ```
+ *
+ * @example
+ * Multiple required headers:
+ * ```typescript
+ * const webhookHandler = new Handler()
+ *   .use(headerVariablesMiddleware([
+ *     'x-webhook-signature',
+ *     'x-webhook-timestamp',
+ *     'content-type'
+ *   ]))
+ *   .handle(async (context) => {
+ *     const signature = context.req.headers['x-webhook-signature'];
+ *     const timestamp = context.req.headers['x-webhook-timestamp'];
+ *
+ *     // Validate webhook authenticity
+ *     const isValid = validateWebhookSignature(signature, timestamp, context.req.body);
+ *     return { success: isValid };
+ *   });
+ * ```
+ *
+ * @example
+ * API versioning through headers:
+ * ```typescript
+ * const versionedApiHandler = new Handler()
+ *   .use(headerVariablesMiddleware(['x-api-version', 'accept']))
+ *   .handle(async (context) => {
+ *     const apiVersion = context.req.headers['x-api-version'];
+ *     const accept = context.req.headers.accept;
+ *
+ *     const handler = getHandlerForVersion(apiVersion as string);
+ *     return handler.process(context.req.body);
+ *   });
+ * ```
+ */
 export declare const headerVariablesMiddleware: (requiredHeaders: string[]) => BaseMiddleware;
 //# sourceMappingURL=headerVariablesMiddleware.d.ts.map

package/build/middlewares/headerVariablesMiddleware.js

@@ -11,6 +11,70 @@ const validateHeaders = (requiredHeaders, headers) => {
         }
     }
 };
+/**
+ * Middleware class that validates the presence of required HTTP headers.
+ * Throws a ValidationError if any required header is missing or empty.
+ *
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * API key authentication via headers:
+ * ```typescript
+ * import { Handler, HeaderVariablesMiddleware } from '@noony-serverless/core';
+ *
+ * const requiredHeaders = ['authorization', 'x-api-key', 'content-type'];
+ *
+ * const secureApiHandler = new Handler()
+ *   .use(new HeaderVariablesMiddleware(requiredHeaders))
+ *   .handle(async (context) => {
+ *     const authHeader = context.req.headers.authorization;
+ *     const apiKey = context.req.headers['x-api-key'];
+ *
+ *     // Headers are guaranteed to exist after middleware validation
+ *     console.log('Auth header:', authHeader);
+ *     console.log('API key:', apiKey);
+ *
+ *     return { success: true, authenticated: true };
+ *   });
+ * ```
+ *
+ * @example
+ * Content negotiation requirements:
+ * ```typescript
+ * const contentHeaders = ['accept', 'content-type', 'accept-language'];
+ *
+ * const internationalApiHandler = new Handler()
+ *   .use(new HeaderVariablesMiddleware(contentHeaders))
+ *   .handle(async (context) => {
+ *     const acceptLang = context.req.headers['accept-language'];
+ *     const contentType = context.req.headers['content-type'];
+ *
+ *     const language = Array.isArray(acceptLang) ? acceptLang[0] : acceptLang;
+ *     const responseData = getLocalizedContent(language);
+ *
+ *     return { success: true, data: responseData, language };
+ *   });
+ * ```
+ *
+ * @example
+ * Custom business headers validation:
+ * ```typescript
+ * const businessHeaders = ['x-tenant-id', 'x-request-id', 'x-client-version'];
+ *
+ * const multiTenantHandler = new Handler()
+ *   .use(new HeaderVariablesMiddleware(businessHeaders))
+ *   .handle(async (context) => {
+ *     const tenantId = context.req.headers['x-tenant-id'];
+ *     const requestId = context.req.headers['x-request-id'];
+ *     const clientVersion = context.req.headers['x-client-version'];
+ *
+ *     console.log(`Processing request ${requestId} for tenant ${tenantId} with client ${clientVersion}`);
+ *
+ *     const tenantData = await getTenantData(tenantId as string);
+ *     return { success: true, tenant: tenantData };
+ *   });
+ * ```
+ */
 class HeaderVariablesMiddleware {
     requiredHeaders;
     constructor(requiredHeaders) {
@@ -22,6 +86,60 @@ class HeaderVariablesMiddleware {
     }
 }
 exports.HeaderVariablesMiddleware = HeaderVariablesMiddleware;
+/**
+ * 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
+ * Simple header validation:
+ * ```typescript
+ * import { Handler, headerVariablesMiddleware } from '@noony-serverless/core';
+ *
+ * const authHandler = new Handler()
+ *   .use(headerVariablesMiddleware(['authorization']))
+ *   .handle(async (context) => {
+ *     const token = context.req.headers.authorization;
+ *     // Proceed with authentication logic
+ *     return { success: true, message: 'Authenticated' };
+ *   });
+ * ```
+ *
+ * @example
+ * Multiple required headers:
+ * ```typescript
+ * const webhookHandler = new Handler()
+ *   .use(headerVariablesMiddleware([
+ *     'x-webhook-signature',
+ *     'x-webhook-timestamp',
+ *     'content-type'
+ *   ]))
+ *   .handle(async (context) => {
+ *     const signature = context.req.headers['x-webhook-signature'];
+ *     const timestamp = context.req.headers['x-webhook-timestamp'];
+ *
+ *     // Validate webhook authenticity
+ *     const isValid = validateWebhookSignature(signature, timestamp, context.req.body);
+ *     return { success: isValid };
+ *   });
+ * ```
+ *
+ * @example
+ * API versioning through headers:
+ * ```typescript
+ * const versionedApiHandler = new Handler()
+ *   .use(headerVariablesMiddleware(['x-api-version', 'accept']))
+ *   .handle(async (context) => {
+ *     const apiVersion = context.req.headers['x-api-version'];
+ *     const accept = context.req.headers.accept;
+ *
+ *     const handler = getHandlerForVersion(apiVersion as string);
+ *     return handler.process(context.req.body);
+ *   });
+ * ```
+ */
 const headerVariablesMiddleware = (requiredHeaders) => ({
     async before(context) {
         context.req.headers = context.req.headers || {};

package/build/middlewares/httpAttributesMiddleware.d.ts

@@ -1,10 +1,245 @@
 import { Context } from '../core/core';
 import { BaseMiddleware } from '../core/handler';
 import { ZodSchema } from '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 };
+ *   });
+ * ```
+ */
 export declare class PathParametersMiddleware implements BaseMiddleware {
     before(context: Context): Promise<void>;
 }
+/**
+ * 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 };
+ *   });
+ * ```
+ */
 export declare const pathParameters: () => BaseMiddleware;
+/**
+ * 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 };
+ *   });
+ * ```
+ */
 export declare const headerVariablesValidator: (requiredHeaders: string[]) => BaseMiddleware;
+/**
+ * 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 };
+ *   });
+ * ```
+ */
 export declare const validatedQueryParameters: (schema: ZodSchema) => BaseMiddleware;
 //# sourceMappingURL=httpAttributesMiddleware.d.ts.map