@noony-serverless/core 0.1.0

package/build/middlewares/bodyParserMiddleware.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyParser = exports.BodyParserMiddleware = void 0;
+const core_1 = require("../core");
+// Enhanced base64 validation with stricter security checks
+const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+const MAX_BASE64_PADDING = 2;
+const MIN_BASE64_LENGTH = 4; // Base64 minimum valid length
+// Type guard to check if the body is a PubSub message - optimized version
+const isPubSubMessage = (body) => {
+    return (!!body &&
+        typeof body === 'object' &&
+        'message' in body &&
+        typeof body.message === 'object' &&
+        'data' in body.message);
+};
+// Performance constants
+const MAX_JSON_SIZE = 1024 * 1024; // 1MB default limit
+const MAX_BASE64_SIZE = 1024 * 1024 * 1.5; // 1.5MB for base64 (accounts for encoding overhead)
+/**
+ * Async JSON parsing using worker threads for large payloads
+ * Falls back to synchronous parsing for small payloads
+ */
+const parseJsonAsync = async (jsonString) => {
+    // Performance optimization: Use sync parsing for small payloads
+    if (jsonString.length < 10000) {
+        // 10KB threshold
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch (error) {
+            throw new core_1.ValidationError('Invalid JSON body', error.message);
+        }
+    }
+    // For larger payloads, use async parsing to avoid blocking
+    return new Promise((resolve, reject) => {
+        // Use setImmediate to make JSON parsing non-blocking
+        setImmediate(() => {
+            try {
+                const result = JSON.parse(jsonString);
+                resolve(result);
+            }
+            catch (error) {
+                reject(new core_1.ValidationError('Invalid JSON body', error.message));
+            }
+        });
+    });
+};
+/**
+ * Enhanced base64 validation with comprehensive security checks
+ */
+const validateBase64Format = (base64Data) => {
+    // Check minimum length
+    if (base64Data.length < MIN_BASE64_LENGTH) {
+        throw new core_1.ValidationError('Base64 data too short');
+    }
+    // Validate base64 alphabet and padding
+    if (!BASE64_REGEX.test(base64Data)) {
+        throw new core_1.ValidationError('Invalid base64 format in Pub/Sub message');
+    }
+    // Validate padding is only at the end
+    const paddingIndex = base64Data.indexOf('=');
+    if (paddingIndex !== -1) {
+        const paddingCount = base64Data.length - paddingIndex;
+        if (paddingCount > MAX_BASE64_PADDING) {
+            throw new core_1.ValidationError('Invalid base64 padding');
+        }
+        // Ensure no non-padding characters after padding starts
+        const paddingPart = base64Data.substring(paddingIndex);
+        if (!/^=+$/.test(paddingPart)) {
+            throw new core_1.ValidationError('Invalid characters after base64 padding');
+        }
+    }
+    // Validate length is multiple of 4 (base64 requirement)
+    if (base64Data.length % 4 !== 0) {
+        throw new core_1.ValidationError('Invalid base64 length - must be multiple of 4');
+    }
+};
+/**
+ * Secure base64 decoding with comprehensive validation and size limits
+ */
+const decodeBase64Async = async (base64Data) => {
+    // Perform comprehensive base64 validation
+    validateBase64Format(base64Data);
+    // Check size limits to prevent memory exhaustion
+    if (base64Data.length > MAX_BASE64_SIZE) {
+        throw new core_1.TooLargeError('Pub/Sub message too large');
+    }
+    // For small messages, use sync decoding
+    if (base64Data.length < 1000) {
+        try {
+            const decoded = Buffer.from(base64Data, 'base64').toString('utf8');
+            // Validate decoded content is valid UTF-8
+            if (decoded.includes('\uFFFD')) {
+                throw new core_1.ValidationError('Invalid UTF-8 content in decoded base64');
+            }
+            return decoded;
+        }
+        catch (error) {
+            if (error instanceof core_1.ValidationError) {
+                throw error;
+            }
+            throw new core_1.ValidationError('Failed to decode base64 data');
+        }
+    }
+    // For larger messages, use async decoding to avoid blocking
+    return new Promise((resolve, reject) => {
+        setImmediate(() => {
+            try {
+                const decoded = Buffer.from(base64Data, 'base64').toString('utf8');
+                // Validate decoded content is valid UTF-8
+                if (decoded.includes('\uFFFD')) {
+                    reject(new core_1.ValidationError('Invalid UTF-8 content in decoded base64'));
+                    return;
+                }
+                resolve(decoded);
+            }
+            catch (error) {
+                reject(new core_1.ValidationError('Failed to decode base64 Pub/Sub message'));
+            }
+        });
+    });
+};
+// Enhanced async body parser with performance optimizations
+const parseBody = async (body) => {
+    // Early return for already parsed objects
+    if (typeof body === 'object' && body !== null && !isPubSubMessage(body)) {
+        return body;
+    }
+    if (typeof body === 'string') {
+        // Size check to prevent DoS attacks
+        if (body.length > MAX_JSON_SIZE) {
+            throw new core_1.TooLargeError('Request body too large');
+        }
+        return await parseJsonAsync(body);
+    }
+    if (isPubSubMessage(body)) {
+        try {
+            const decoded = await decodeBase64Async(body.message.data);
+            return await parseJsonAsync(decoded);
+        }
+        catch (error) {
+            if (error instanceof core_1.ValidationError || error instanceof core_1.TooLargeError) {
+                throw error;
+            }
+            throw new core_1.ValidationError('Invalid Pub/Sub message', error.message);
+        }
+    }
+    return body;
+};
+/**
+ * Enhanced BodyParserMiddleware with async parsing and performance optimizations.
+ *
+ * Features:
+ * - Async JSON parsing for large payloads
+ * - Size limits to prevent DoS attacks
+ * - Base64 decoding for Pub/Sub messages
+ * - Non-blocking parsing using setImmediate
+ *
+ * @template T - The expected type of the parsed body. Defaults to unknown if not specified.
+ * @implements {BaseMiddleware}
+ */
+class BodyParserMiddleware {
+    maxSize;
+    constructor(maxSize = MAX_JSON_SIZE) {
+        this.maxSize = maxSize;
+    }
+    async before(context) {
+        // Check content-length early to avoid processing oversized requests
+        const headers = context.req.headers || {};
+        const contentLength = headers['content-length'];
+        if (contentLength) {
+            const length = Array.isArray(contentLength)
+                ? contentLength[0]
+                : contentLength;
+            if (length && parseInt(length) > this.maxSize) {
+                throw new core_1.TooLargeError('Request body too large');
+            }
+        }
+        context.req.parsedBody = await parseBody(context.req.body);
+    }
+}
+exports.BodyParserMiddleware = BodyParserMiddleware;
+/**
+ * Enhanced middleware function for parsing the request body in specific HTTP methods.
+ *
+ * Performance optimizations:
+ * - Early method validation
+ * - Async parsing for large payloads
+ * - Size validation
+ *
+ * @template T - The expected type of the parsed request body.
+ * @returns {BaseMiddleware} A middleware object containing a `before` hook.
+ */
+const bodyParser = (maxSize = MAX_JSON_SIZE) => ({
+    before: async (context) => {
+        const { method, body } = context.req;
+        // Performance optimization: Early return for methods that don't typically have bodies
+        if (!method || !['POST', 'PUT', 'PATCH'].includes(method)) {
+            return;
+        }
+        // Check content-length early
+        const headers = context.req.headers || {};
+        const contentLength = headers['content-length'];
+        if (contentLength) {
+            const length = Array.isArray(contentLength)
+                ? contentLength[0]
+                : contentLength;
+            if (length && parseInt(length) > maxSize) {
+                throw new core_1.TooLargeError('Request body too large');
+            }
+        }
+        context.req.parsedBody = await parseBody(body);
+    },
+});
+exports.bodyParser = bodyParser;
+//# sourceMappingURL=bodyParserMiddleware.js.map

package/build/middlewares/bodyValidationMiddleware.d.ts

@@ -0,0 +1,12 @@
+import { BaseMiddleware } from '../core/handler';
+import { Context } from '../core/core';
+import { z } from 'zod';
+export declare class BodyValidationMiddleware<T = unknown> implements BaseMiddleware {
+    private readonly schema;
+    constructor(schema: z.ZodSchema<T>);
+    before(context: Context): Promise<void>;
+}
+export declare const bodyValidatorMiddleware: <T>(schema: z.ZodType<T>) => {
+    before: (context: Context) => Promise<void>;
+};
+//# sourceMappingURL=bodyValidationMiddleware.d.ts.map

package/build/middlewares/bodyValidationMiddleware.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyValidatorMiddleware = exports.BodyValidationMiddleware = void 0;
+const zod_1 = require("zod");
+const errors_1 = require("../core/errors");
+const validateBody = async (schema, data) => {
+    try {
+        return await schema.parseAsync(data);
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            throw new errors_1.ValidationError('Validation error', error.errors);
+        }
+        throw error;
+    }
+};
+class BodyValidationMiddleware {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    async before(context) {
+        context.req.validatedBody = await validateBody(this.schema, context.req.parsedBody);
+    }
+}
+exports.BodyValidationMiddleware = BodyValidationMiddleware;
+// Modified to fix type instantiation error
+const bodyValidatorMiddleware = (schema) => ({
+    before: async (context) => {
+        context.req.parsedBody = await validateBody(schema, context.req.body);
+    },
+});
+exports.bodyValidatorMiddleware = bodyValidatorMiddleware;
+//# sourceMappingURL=bodyValidationMiddleware.js.map

package/build/middlewares/dependencyInjectionMiddleware.d.ts

@@ -0,0 +1,14 @@
+import { BaseMiddleware, Context } from '../core';
+export declare class DependencyInjectionMiddleware implements BaseMiddleware {
+    private services;
+    constructor(services: {
+        id: any;
+        value: any;
+    }[]);
+    before(context: Context): Promise<void>;
+}
+export declare const dependencyInjection: (services?: {
+    id: any;
+    value: any;
+}[]) => BaseMiddleware;
+//# sourceMappingURL=dependencyInjectionMiddleware.d.ts.map

package/build/middlewares/dependencyInjectionMiddleware.js

@@ -0,0 +1,48 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyInjection = exports.DependencyInjectionMiddleware = void 0;
+const typedi_1 = require("typedi");
+class DependencyInjectionMiddleware {
+    services;
+    constructor(services) {
+        this.services = services;
+    }
+    async before(context) {
+        this.services.forEach((service) => {
+            typedi_1.Container.set(service.id, service.value);
+        });
+        context.container = typedi_1.Container;
+    }
+}
+exports.DependencyInjectionMiddleware = DependencyInjectionMiddleware;
+const dependencyInjection = (services = []) => ({
+    before: async (context) => {
+        services.forEach((service) => {
+            typedi_1.Container.set(service.id, service.value);
+        });
+        context.container = typedi_1.Container.of();
+    },
+});
+exports.dependencyInjection = dependencyInjection;
+/*
+// Initialize services
+const services = [
+  { id: 'businessData', value: new Map<string, any>() },
+  { id: UserService, value: new UserService(new Map<string, any>()) }
+];
+
+// Create an instance of DependencyInjectionMiddleware with the services
+const diMiddleware = new DependencyInjectionMiddleware(services);
+
+// Example handler using the middleware
+const exampleHandler = new Handler()
+  .use(diMiddleware)
+  .use(errorHandler())
+  .use(responseWrapperMiddleware<any>())
+  .handle(async (context: Context) => {
+    const businessData = context.container?.get('businessData');
+    setResponseData(context, { message: 'Dependency Injection Middleware example', businessData });
+  });
+*/
+//# sourceMappingURL=dependencyInjectionMiddleware.js.map

package/build/middlewares/errorHandlerMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { BaseMiddleware, Context } from '../core';
+export declare class ErrorHandlerMiddleware implements BaseMiddleware {
+    onError(error: Error, context: Context): Promise<void>;
+}
+export declare const errorHandler: () => BaseMiddleware;
+//# sourceMappingURL=errorHandlerMiddleware.d.ts.map

package/build/middlewares/errorHandlerMiddleware.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = exports.ErrorHandlerMiddleware = void 0;
+const core_1 = require("../core");
+const handleError = async (error, context) => {
+    const isDevelopment = process.env.NODE_ENV === 'development' || process.env.DEBUG === 'true';
+    core_1.logger.error('Error processing request', {
+        errorMessage: error?.message,
+        errorStack: error?.stack,
+        requestId: context.requestId,
+        userAgent: context.req.headers?.['user-agent'],
+        ip: context.req.ip || 'unknown',
+    });
+    if (error instanceof core_1.HttpError) {
+        const responsePayload = {
+            success: false,
+            payload: {
+                error: error.message,
+            },
+            timestamp: new Date().toISOString(),
+        };
+        // Only include sensitive details in development
+        if (isDevelopment && error.details) {
+            responsePayload.payload.details = error.details;
+        }
+        // Only include error codes for client errors (4xx), not server errors
+        if (error.code && error.status < 500) {
+            responsePayload.payload.code = error.code;
+        }
+        context.res.status(error.status).json(responsePayload);
+    }
+    else {
+        // For non-HttpError exceptions, provide generic error message in production
+        const errorMessage = isDevelopment
+            ? error.message
+            : 'Internal Server Error';
+        const responsePayload = {
+            error: 'Internal Server Error',
+            success: false,
+            payload: {
+                error: errorMessage,
+            },
+            timestamp: new Date().toISOString(),
+        };
+        // Add stack trace in development for non-HTTP errors
+        if (isDevelopment && error.stack) {
+            responsePayload.payload.stack = error.stack;
+        }
+        context.res.status(500).json(responsePayload);
+    }
+};
+class ErrorHandlerMiddleware {
+    async onError(error, context) {
+        await handleError(error, context);
+    }
+}
+exports.ErrorHandlerMiddleware = ErrorHandlerMiddleware;
+const errorHandler = () => ({
+    onError: async (error, context) => {
+        await handleError(error, context);
+    },
+});
+exports.errorHandler = errorHandler;
+//# sourceMappingURL=errorHandlerMiddleware.js.map

package/build/middlewares/headerVariablesMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { BaseMiddleware, Context } from '../core';
+export declare class HeaderVariablesMiddleware implements BaseMiddleware {
+    private requiredHeaders;
+    constructor(requiredHeaders: string[]);
+    before(context: Context): Promise<void>;
+}
+export declare const headerVariablesMiddleware: (requiredHeaders: string[]) => BaseMiddleware;
+//# sourceMappingURL=headerVariablesMiddleware.d.ts.map

package/build/middlewares/headerVariablesMiddleware.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headerVariablesMiddleware = exports.HeaderVariablesMiddleware = void 0;
+const core_1 = require("../core");
+const validateHeaders = (requiredHeaders, headers) => {
+    for (const header of requiredHeaders) {
+        const headerValue = headers[header.toLowerCase()];
+        if (!headerValue ||
+            (Array.isArray(headerValue) && headerValue.length === 0)) {
+            throw new core_1.ValidationError(`Missing required header: ${header}`);
+        }
+    }
+};
+class HeaderVariablesMiddleware {
+    requiredHeaders;
+    constructor(requiredHeaders) {
+        this.requiredHeaders = requiredHeaders;
+    }
+    async before(context) {
+        context.req.headers = context.req.headers || {};
+        validateHeaders(this.requiredHeaders, context.req.headers);
+    }
+}
+exports.HeaderVariablesMiddleware = HeaderVariablesMiddleware;
+const headerVariablesMiddleware = (requiredHeaders) => ({
+    async before(context) {
+        context.req.headers = context.req.headers || {};
+        validateHeaders(requiredHeaders, context.req.headers);
+    },
+});
+exports.headerVariablesMiddleware = headerVariablesMiddleware;
+//# sourceMappingURL=headerVariablesMiddleware.js.map

package/build/middlewares/httpAttributesMiddleware.d.ts

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

package/build/middlewares/httpAttributesMiddleware.js

@@ -0,0 +1,71 @@
+"use strict";
+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");
+class PathParametersMiddleware {
+    async before(context) {
+        const host = (Array.isArray(context.req.headers.host)
+            ? context.req.headers.host[0]
+            : context.req.headers.host) || 'localhost';
+        const url = new URL(context.req.url, `http://${host}`);
+        const pathSegments = url.pathname.split('/').filter(Boolean);
+        context.req.params = context.req.params || {};
+        // Extract path parameters based on your routing configuration
+        // This is a simplified example
+        pathSegments.forEach((segment, index) => {
+            if (segment.startsWith(':')) {
+                const paramName = segment.slice(1);
+                if (context.req.params) {
+                    context.req.params[paramName] = pathSegments[index];
+                }
+            }
+        });
+    }
+}
+exports.PathParametersMiddleware = PathParametersMiddleware;
+const pathParameters = () => ({
+    before: async (context) => {
+        const host = (Array.isArray(context.req.headers.host)
+            ? context.req.headers.host[0]
+            : context.req.headers.host) || 'localhost';
+        const url = new URL(context.req.url, `http://${host}`);
+        const pathSegments = url.pathname.split('/').filter(Boolean);
+        context.req.params = { ...context.req.params };
+        pathSegments.forEach((segment, index) => {
+            if (segment.startsWith(':')) {
+                const paramName = segment.slice(1);
+                if (context.req.params) {
+                    context.req.params[paramName] = pathSegments[index];
+                }
+            }
+        });
+    },
+});
+exports.pathParameters = pathParameters;
+const headerVariablesValidator = (requiredHeaders) => ({
+    before: async (context) => {
+        for (const header of requiredHeaders) {
+            if (!context.req.headers?.[header.toLowerCase()]) {
+                throw new errors_1.ValidationError(`Missing required header: ${header}`);
+            }
+        }
+    },
+});
+exports.headerVariablesValidator = headerVariablesValidator;
+const validatedQueryParameters = (schema) => ({
+    before: async (context) => {
+        const queryParams = context.req.query;
+        try {
+            schema.parse(queryParams);
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                throw new errors_1.ValidationError('Validation error', JSON.stringify(error.errors));
+            }
+            throw error;
+        }
+    },
+});
+exports.validatedQueryParameters = validatedQueryParameters;
+//# sourceMappingURL=httpAttributesMiddleware.js.map

package/build/middlewares/index.d.ts

@@ -0,0 +1,14 @@
+export * from './authenticationMiddleware';
+export * from './bodyParserMiddleware';
+export * from './bodyValidationMiddleware';
+export * from './dependencyInjectionMiddleware';
+export * from './errorHandlerMiddleware';
+export * from './headerVariablesMiddleware';
+export * from './httpAttributesMiddleware';
+export * from './queryParametersMiddleware';
+export * from './rateLimitingMiddleware';
+export * from './responseWrapperMiddleware';
+export * from './securityAuditMiddleware';
+export * from './securityHeadersMiddleware';
+export * from './validationMiddleware';
+//# sourceMappingURL=index.d.ts.map

package/build/middlewares/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./authenticationMiddleware"), exports);
+__exportStar(require("./bodyParserMiddleware"), exports);
+__exportStar(require("./bodyValidationMiddleware"), exports);
+__exportStar(require("./dependencyInjectionMiddleware"), exports);
+__exportStar(require("./errorHandlerMiddleware"), exports);
+__exportStar(require("./headerVariablesMiddleware"), exports);
+__exportStar(require("./httpAttributesMiddleware"), exports);
+__exportStar(require("./queryParametersMiddleware"), exports);
+__exportStar(require("./rateLimitingMiddleware"), exports);
+__exportStar(require("./responseWrapperMiddleware"), exports);
+__exportStar(require("./securityAuditMiddleware"), exports);
+__exportStar(require("./securityHeadersMiddleware"), exports);
+__exportStar(require("./validationMiddleware"), exports);
+//# sourceMappingURL=index.js.map

package/build/middlewares/queryParametersMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { BaseMiddleware, Context } from '../core';
+export declare class QueryParametersMiddleware implements BaseMiddleware {
+    private readonly requiredParams;
+    constructor(requiredParams?: string[]);
+    before(context: Context): Promise<void>;
+}
+export declare const queryParametersMiddleware: (requiredParams?: string[]) => BaseMiddleware;
+//# sourceMappingURL=queryParametersMiddleware.d.ts.map

package/build/middlewares/queryParametersMiddleware.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryParametersMiddleware = exports.QueryParametersMiddleware = void 0;
+const core_1 = require("../core");
+const validateQueryParameters = (requiredParams, query) => {
+    for (const param of requiredParams) {
+        if (!query[param]) {
+            throw new core_1.ValidationError(`Missing required query parameter: ${param}`);
+        }
+    }
+};
+const convertQueryToRecord = (query) => {
+    const result = {};
+    for (const key in query) {
+        if (query[key] !== undefined) {
+            result[key] = Array.isArray(query[key])
+                ? query[key].map(String)
+                : String(query[key]);
+        }
+    }
+    return result;
+};
+class QueryParametersMiddleware {
+    requiredParams;
+    constructor(requiredParams = []) {
+        this.requiredParams = requiredParams;
+    }
+    async before(context) {
+        const host = (Array.isArray(context.req.headers.host)
+            ? context.req.headers.host[0]
+            : context.req.headers.host) || 'localhost';
+        const url = new URL(context.req.url, `http://${host}`);
+        context.req.query = Object.fromEntries(url.searchParams);
+        const query = convertQueryToRecord(context.req.query);
+        validateQueryParameters(this.requiredParams, query);
+    }
+}
+exports.QueryParametersMiddleware = QueryParametersMiddleware;
+const queryParametersMiddleware = (requiredParams = []) => ({
+    async before(context) {
+        const host = (Array.isArray(context.req.headers.host)
+            ? context.req.headers.host[0]
+            : context.req.headers.host) || 'localhost';
+        const url = new URL(context.req.url, `http://${host}`);
+        context.req.query = Object.fromEntries(url.searchParams);
+        const query = convertQueryToRecord(context.req.query);
+        validateQueryParameters(requiredParams, query);
+    },
+});
+exports.queryParametersMiddleware = queryParametersMiddleware;
+//# sourceMappingURL=queryParametersMiddleware.js.map