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

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

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
 * 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<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
    private readonly requiredParams;
    constructor(requiredParams?: string[]);
    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
 *
 * @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: <TBody = unknown, TUser = unknown>(requiredParams?: string[]) => BaseMiddleware<TBody, TUser>;
//# sourceMappingURL=queryParametersMiddleware.d.ts.map