@zintrust/core 0.4.17 → 0.4.19

package/src/http/middleware/FileUploadMiddleware.js

@@ -0,0 +1,74 @@
+/**
+ * File Upload Middleware
+ * Processes multipart/form-data requests and makes files available on request
+ */
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { MultipartParser } from '../parsers/MultipartParser.js';
+import { MultipartParserRegistry } from '../parsers/MultipartParserRegistry.js';
+/**
+ * Extract content-type header safely
+ */
+const getContentType = (req) => {
+    const contentType = req.getHeader('content-type');
+    if (typeof contentType === 'string')
+        return contentType.toLowerCase().trim();
+    return '';
+};
+/**
+ * File upload middleware
+ * Automatically parses multipart/form-data and makes files available
+ */
+export const fileUploadMiddleware = async (req, res, next) => {
+    const contentType = getContentType(req);
+    // Only process multipart/form-data requests
+    if (!MultipartParser.isMultipart(contentType)) {
+        await next();
+        return;
+    }
+    // Phase 4 default behavior: multipart requires external streaming parser.
+    const provider = MultipartParserRegistry.get();
+    if (provider === null) {
+        res.setStatus(415).json({
+            error: 'multipart/form-data not supported. Install @zintrust/storage to enable uploads.',
+        });
+        return;
+    }
+    try {
+        const maxFileSizeBytes = Env.getInt('MAX_FILE_SIZE', 50 * 1024 * 1024);
+        const maxFiles = Env.getInt('MAX_FILES', 20);
+        const maxFields = Env.getInt('MAX_FIELDS', 200);
+        const maxFieldSizeBytes = Env.getInt('MAX_FIELD_SIZE', 128 * 1024);
+        const parsed = await provider({
+            req: req.getRaw(),
+            contentType,
+            limits: {
+                maxFileSizeBytes,
+                maxFiles,
+                maxFields,
+                maxFieldSizeBytes,
+            },
+        });
+        const currentBody = req.getBody?.();
+        const updatedBody = typeof currentBody === 'object' && currentBody !== null ? currentBody : {};
+        // Merge fields directly into the request body for ergonomics.
+        // Files remain under __files for FileUpload helper compatibility.
+        req.setBody({
+            ...updatedBody,
+            ...parsed.fields,
+            __files: parsed.files,
+        });
+        if (Env.getBool('ZIN_DEBUG_FILE_UPLOAD', false)) {
+            Logger.debug('[File Upload] Successfully parsed multipart data', {
+                fieldsCount: Object.keys(parsed.fields).length,
+                filesCount: Object.keys(parsed.files).length,
+            });
+        }
+    }
+    catch (error) {
+        Logger.error('[File Upload] Error parsing multipart data', error);
+        // Continue with unparsed body
+    }
+    await next();
+};
+export default fileUploadMiddleware;

package/src/http/parsers/BodyParsers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Body Parsers - Content-Type specific parsing
+ * Handles form-data, plain text, CSV, and other non-JSON formats
+ */
+interface BodyParserResult {
+    ok: boolean;
+    data?: Record<string, unknown> | string | unknown[];
+    error?: string;
+}
+interface IBodyParser {
+    canParse(contentType: string): boolean;
+    parse(body: string | Buffer): BodyParserResult;
+}
+export declare const BodyParsers: Readonly<{
+    FormDataParser: IBodyParser;
+    TextParser: IBodyParser;
+    CSVParser: IBodyParser;
+    /**
+     * Get all registered parsers
+     */
+    getAll(): IBodyParser[];
+    /**
+     * Find parser for content-type
+     */
+    findParser(contentType: string): IBodyParser | undefined;
+    /**
+     * Parse body based on content-type
+     */
+    parse(contentType: string, body: string | Buffer): BodyParserResult;
+}>;
+export default BodyParsers;
+//# sourceMappingURL=BodyParsers.d.ts.map

package/src/http/parsers/BodyParsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BodyParsers.d.ts","sourceRoot":"","sources":["../../../../src/http/parsers/BodyParsers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,UAAU,gBAAgB;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,CAAC;CAChD;AA6ID,eAAO,MAAM,WAAW;;;;IAKtB;;OAEG;cACO,WAAW,EAAE;IAIvB;;OAEG;4BACqB,MAAM,GAAG,WAAW,GAAG,SAAS;IAIxD;;OAEG;uBACgB,MAAM,QAAQ,MAAM,GAAG,MAAM,GAAG,gBAAgB;EAQnE,CAAC;AAEH,eAAe,WAAW,CAAC"}

package/src/http/parsers/BodyParsers.js

@@ -0,0 +1,159 @@
+/**
+ * Body Parsers - Content-Type specific parsing
+ * Handles form-data, plain text, CSV, and other non-JSON formats
+ */
+/**
+ * URL-encoded form data parser
+ * Content-Type: application/x-www-form-urlencoded
+ */
+const FormDataParser = {
+    canParse: (contentType) => contentType.includes('application/x-www-form-urlencoded'),
+    parse: (body) => {
+        try {
+            const text = typeof body === 'string' ? body : body.toString('utf-8');
+            if (!text.trim())
+                return { ok: true, data: {} };
+            const params = new URLSearchParams(text);
+            const result = {};
+            for (const [key, value] of params.entries()) {
+                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                    // Handle multiple values with same key
+                    const existing = result[key];
+                    if (Array.isArray(existing)) {
+                        existing.push(value);
+                    }
+                    else {
+                        result[key] = [existing, value];
+                    }
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+            return { ok: true, data: result };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            return { ok: false, error: `Failed to parse form data: ${errorMsg}` };
+        }
+    },
+};
+/**
+ * Plain text parser
+ * Content-Type: text/plain
+ */
+const TextParser = {
+    canParse: (contentType) => contentType.includes('text/plain'),
+    parse: (body) => {
+        try {
+            const text = typeof body === 'string' ? body : body.toString('utf-8');
+            return { ok: true, data: text };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            return { ok: false, error: `Failed to parse text: ${errorMsg}` };
+        }
+    },
+};
+/**
+ * CSV parser implementation helper
+ */
+const parseCSVLine = (line) => {
+    const result = [];
+    let current = '';
+    let inQuotes = false;
+    let i = 0;
+    while (i < line.length) {
+        const char = line[i];
+        if (char === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                current += '"';
+                i += 2;
+                continue;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+        }
+        else if (char === ',' && !inQuotes) {
+            result.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+        i++;
+    }
+    result.push(current.trim());
+    return result;
+};
+/**
+ * CSV parser
+ * Content-Type: text/csv
+ */
+const CSVParser = {
+    canParse: (contentType) => contentType.includes('text/csv'),
+    parse: (body) => {
+        try {
+            const text = typeof body === 'string' ? body : body.toString('utf-8');
+            if (text.length === 0)
+                return { ok: true, data: [] };
+            // Stream-like processing: iterate lines without creating an array of all lines
+            const rows = [];
+            let headers;
+            let cursor = 0;
+            while (cursor < text.length) {
+                let lineEnd = text.indexOf('\n', cursor);
+                if (lineEnd === -1)
+                    lineEnd = text.length;
+                const line = text.slice(cursor, lineEnd).trim();
+                cursor = lineEnd + 1;
+                if (line.length === 0)
+                    continue;
+                const values = parseCSVLine(line);
+                if (!headers) {
+                    headers = values;
+                    continue;
+                }
+                const row = {};
+                for (let j = 0; j < headers.length; j++) {
+                    row[headers[j]] = values[j] ?? '';
+                }
+                rows.push(row);
+            }
+            return { ok: true, data: rows };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            return { ok: false, error: `Failed to parse CSV: ${errorMsg}` };
+        }
+    },
+};
+export const BodyParsers = Object.freeze({
+    FormDataParser,
+    TextParser,
+    CSVParser,
+    /**
+     * Get all registered parsers
+     */
+    getAll() {
+        return [this.FormDataParser, this.TextParser, this.CSVParser];
+    },
+    /**
+     * Find parser for content-type
+     */
+    findParser(contentType) {
+        return this.getAll().find((parser) => parser.canParse(contentType));
+    },
+    /**
+     * Parse body based on content-type
+     */
+    parse(contentType, body) {
+        const parser = this.findParser(contentType);
+        if (parser === undefined) {
+            return { ok: false, error: `No parser found for content-type: ${contentType}` };
+        }
+        return parser.parse(body);
+    },
+});
+export default BodyParsers;

package/src/http/parsers/MultipartParser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Multipart Form-Data Parser
+ * Parses multipart/form-data requests for file uploads and form fields
+ */
+import type { UploadedFile } from '../FileUpload';
+interface ParsedMultipartData {
+    fields: Record<string, string | string[]>;
+    files: Record<string, UploadedFile[]>;
+}
+/**
+ * Parse multipart/form-data body
+ * Note: This is a simplified parser. For production use a proper multipart library
+ */
+export declare const parseMultipartFormData: (body: Buffer | string, boundary: string) => ParsedMultipartData;
+/**
+ * Parse multipart/form-data from request
+ */
+export declare const MultipartParser: Readonly<{
+    /**
+     * Check if content-type is multipart/form-data
+     */
+    isMultipart(contentType: string): boolean;
+    /**
+     * Get boundary from content-type header
+     */
+    getBoundary(contentType: string): string | undefined;
+    /**
+     * Parse multipart body
+     */
+    parse(body: Buffer | string, boundary: string): ParsedMultipartData;
+}>;
+export default MultipartParser;
+//# sourceMappingURL=MultipartParser.d.ts.map

package/src/http/parsers/MultipartParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultipartParser.d.ts","sourceRoot":"","sources":["../../../../src/http/parsers/MultipartParser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,UAAU,mBAAmB;IAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;CACvC;AAwJD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,GAAG,MAAM,EACrB,UAAU,MAAM,KACf,mBAaF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;6BACsB,MAAM,GAAG,OAAO;IAIzC;;OAEG;6BACsB,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpD;;OAEG;gBACS,MAAM,GAAG,MAAM,YAAY,MAAM,GAAG,mBAAmB;EAGnE,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/http/parsers/MultipartParser.js

@@ -0,0 +1,156 @@
+/**
+ * Multipart Form-Data Parser
+ * Parses multipart/form-data requests for file uploads and form fields
+ */
+const MAX_PARTS = 1000;
+const MAX_HEADER_SIZE = 16 * 1024; // 16KB
+/**
+ * Simple multipart boundary extractor
+ */
+const getBoundary = (contentType) => {
+    const match = /boundary=([^;\s]+)/.exec(contentType);
+    if (match?.[1] === undefined)
+        return undefined;
+    return match[1].replaceAll('"', '');
+};
+const stripTrailingNewline = (buffer, start, end) => {
+    if (end <= start)
+        return end;
+    if (end - start >= 2 && buffer[end - 2] === 13 && buffer[end - 1] === 10) {
+        return end - 2;
+    }
+    if (end - start >= 1 && buffer[end - 1] === 10) {
+        return end - 1;
+    }
+    return end;
+};
+/**
+ * Extract parts from multipart body by boundary
+ */
+const extractParts = (bodyBuffer, boundary) => {
+    const parts = [];
+    if (!boundary)
+        return parts;
+    const boundaryBuffer = Buffer.from(`--${boundary}`);
+    let currentPos = 0;
+    while (currentPos < bodyBuffer.length) {
+        if (parts.length >= MAX_PARTS)
+            break;
+        const boundaryPos = bodyBuffer.indexOf(boundaryBuffer, currentPos);
+        if (boundaryPos === -1)
+            break;
+        const start = currentPos + (currentPos === 0 ? 0 : 2); // Skip CRLF before boundary
+        const end = stripTrailingNewline(bodyBuffer, start, boundaryPos);
+        if (start < end) {
+            parts.push(bodyBuffer.subarray(start, end));
+        }
+        currentPos = boundaryPos + boundaryBuffer.length;
+    }
+    return parts;
+};
+/**
+ * Parse a single multipart part
+ */
+const getHeaderInfo = (part) => {
+    // Find headers/body separator (double CRLF or double LF)
+    const headerEndIdx = part.indexOf(Buffer.from('\r\n\r\n'));
+    const headerEndIdx2 = part.indexOf(Buffer.from('\n\n'));
+    const headerEnd = headerEndIdx >= 0 ? headerEndIdx : headerEndIdx2;
+    if (headerEnd === -1)
+        return undefined;
+    if (headerEnd > MAX_HEADER_SIZE)
+        return undefined; // Header too large, ignore part
+    const headerSection = part.subarray(0, headerEnd).toString('utf-8');
+    const bodyStart = headerEnd + (headerEndIdx >= 0 ? 4 : 2);
+    return { headerSection, bodyStart };
+};
+const getContentDisposition = (headerSection) => {
+    const match = /Content-Disposition: form-data; name="([^"]+)"(?:; filename="([^"]*)")?/i.exec(headerSection);
+    if (!match)
+        return undefined;
+    return { fieldName: match[1] ?? '', fileName: match[2] };
+};
+const addFile = (part, headerSection, bodyStart, fieldName, fileName, result) => {
+    const contentTypeMatch = /Content-Type: ([^\r\n]+)/i.exec(headerSection);
+    const mimeType = contentTypeMatch?.[1] ?? 'application/octet-stream';
+    // CRITICAL: Use buffer subarray directly for zero-copy and to prevent binary corruption via trim()
+    const buffer = part.subarray(bodyStart);
+    const file = {
+        fieldName,
+        originalName: fileName,
+        mimeType,
+        buffer,
+        size: buffer.length,
+    };
+    result.files[fieldName] ??= [];
+    result.files[fieldName].push(file);
+};
+const addField = (partBody, fieldName, result) => {
+    const fieldValue = result.fields[fieldName];
+    if (fieldValue === undefined) {
+        result.fields[fieldName] = partBody;
+    }
+    else if (Array.isArray(fieldValue)) {
+        fieldValue.push(partBody);
+    }
+    else {
+        result.fields[fieldName] = [fieldValue, partBody];
+    }
+};
+const parsePart = (part, result) => {
+    if (part.length === 0)
+        return;
+    const headerInfo = getHeaderInfo(part);
+    if (!headerInfo)
+        return;
+    // OPTIMIZATION: Do not convert body to string yet, as it might be a binary file
+    const disposition = getContentDisposition(headerInfo.headerSection);
+    if (!disposition)
+        return;
+    if (disposition.fileName !== undefined && disposition.fileName !== null) {
+        addFile(part, headerInfo.headerSection, headerInfo.bodyStart, disposition.fieldName, disposition.fileName, result);
+        return;
+    }
+    // Regular form field - safe to convert to string and trim
+    const partBody = part.subarray(headerInfo.bodyStart).toString('utf-8').trim();
+    addField(partBody, disposition.fieldName, result);
+};
+/**
+ * Parse multipart/form-data body
+ * Note: This is a simplified parser. For production use a proper multipart library
+ */
+export const parseMultipartFormData = (body, boundary) => {
+    const result = { fields: {}, files: {} };
+    if (!boundary)
+        return result;
+    const bodyBuffer = typeof body === 'string' ? Buffer.from(body) : body;
+    const parts = extractParts(bodyBuffer, boundary);
+    for (const part of parts) {
+        parsePart(part, result);
+    }
+    return result;
+};
+/**
+ * Parse multipart/form-data from request
+ */
+export const MultipartParser = Object.freeze({
+    /**
+     * Check if content-type is multipart/form-data
+     */
+    isMultipart(contentType) {
+        return contentType.includes('multipart/form-data');
+    },
+    /**
+     * Get boundary from content-type header
+     */
+    getBoundary(contentType) {
+        return getBoundary(contentType);
+    },
+    /**
+     * Parse multipart body
+     */
+    parse(body, boundary) {
+        return parseMultipartFormData(body, boundary);
+    },
+});
+export default MultipartParser;

package/src/http/parsers/MultipartParserRegistry.d.ts

@@ -0,0 +1,34 @@
+import type { UploadedFile } from '../FileUpload';
+import type { IncomingMessage } from '../../node-singletons/http';
+export type MultipartFieldValue = string | string[];
+export type ParsedMultipartData = {
+    fields: Record<string, MultipartFieldValue>;
+    files: Record<string, UploadedFile[]>;
+};
+export type MultipartParseInput = {
+    req: IncomingMessage;
+    contentType: string;
+    /**
+     * Limits are enforced by the parser implementation.
+     * Core provides defaults via env vars, but the parser may choose stricter behavior.
+     */
+    limits: {
+        maxFileSizeBytes: number;
+        maxFiles: number;
+        maxFields: number;
+        maxFieldSizeBytes: number;
+    };
+};
+export type MultipartParserProvider = (input: MultipartParseInput) => Promise<ParsedMultipartData>;
+declare function register(next: MultipartParserProvider): void;
+declare function get(): MultipartParserProvider | null;
+declare function has(): boolean;
+declare function clear(): void;
+export declare const MultipartParserRegistry: Readonly<{
+    register: typeof register;
+    get: typeof get;
+    has: typeof has;
+    clear: typeof clear;
+}>;
+export default MultipartParserRegistry;
+//# sourceMappingURL=MultipartParserRegistry.d.ts.map

package/src/http/parsers/MultipartParserRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultipartParserRegistry.d.ts","sourceRoot":"","sources":["../../../../src/http/parsers/MultipartParserRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAEpD,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,eAAe,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,MAAM,EAAE;QACN,gBAAgB,EAAE,MAAM,CAAC;QACzB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAInG,iBAAS,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAErD;AAED,iBAAS,GAAG,IAAI,uBAAuB,GAAG,IAAI,CAE7C;AAED,iBAAS,GAAG,IAAI,OAAO,CAEtB;AAED,iBAAS,KAAK,IAAI,IAAI,CAErB;AAED,eAAO,MAAM,uBAAuB;;;;;EAKlC,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/src/http/parsers/MultipartParserRegistry.js

@@ -0,0 +1,20 @@
+let provider = null;
+function register(next) {
+    provider = next;
+}
+function get() {
+    return provider;
+}
+function has() {
+    return provider !== null;
+}
+function clear() {
+    provider = null;
+}
+export const MultipartParserRegistry = Object.freeze({
+    register,
+    get,
+    has,
+    clear,
+});
+export default MultipartParserRegistry;

package/src/http/validated.d.ts

@@ -0,0 +1,12 @@
+import type { IRequest } from './Request';
+export declare const validatedBody: <TBody = Record<string, unknown>>(req: IRequest) => TBody | undefined;
+export declare const validatedQuery: <TQuery = Record<string, unknown>>(req: IRequest) => TQuery | undefined;
+export declare const validatedParams: <TParams = Record<string, unknown>>(req: IRequest) => TParams | undefined;
+export declare const validatedHeaders: <THeaders = Record<string, unknown>>(req: IRequest) => THeaders | undefined;
+export declare const Validated: Readonly<{
+    body: <TBody = Record<string, unknown>>(req: IRequest) => TBody | undefined;
+    query: <TQuery = Record<string, unknown>>(req: IRequest) => TQuery | undefined;
+    params: <TParams = Record<string, unknown>>(req: IRequest) => TParams | undefined;
+    headers: <THeaders = Record<string, unknown>>(req: IRequest) => THeaders | undefined;
+}>;
+//# sourceMappingURL=validated.d.ts.map

package/src/http/validated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validated.d.ts","sourceRoot":"","sources":["../../../src/http/validated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAa9C,eAAO,MAAM,aAAa,GAAI,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,KAAK,QAAQ,KACZ,KAAK,GAAG,SAKV,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,KAAK,QAAQ,KACZ,MAAM,GAAG,SAKX,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,KAAK,QAAQ,KACZ,OAAO,GAAG,SAKZ,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,KAAK,QAAQ,KACZ,QAAQ,GAAG,SAKb,CAAC;AAEF,eAAO,MAAM,SAAS;WApCQ,KAAK,iCAC5B,QAAQ,KACZ,KAAK,GAAG,SAAS;YAOW,MAAM,iCAC9B,QAAQ,KACZ,MAAM,GAAG,SAAS;aAOW,OAAO,iCAChC,QAAQ,KACZ,OAAO,GAAG,SAAS;cAOW,QAAQ,iCAClC,QAAQ,KACZ,QAAQ,GAAG,SAAS;EAYrB,CAAC"}

package/src/http/validated.js

@@ -0,0 +1,41 @@
+const getValidated = (req) => {
+    return req.validated;
+};
+export const validatedBody = (req) => {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.body === undefined)
+        return undefined;
+    return validated.body;
+};
+export const validatedQuery = (req) => {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.query === undefined)
+        return undefined;
+    return validated.query;
+};
+export const validatedParams = (req) => {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.params === undefined)
+        return undefined;
+    return validated.params;
+};
+export const validatedHeaders = (req) => {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.headers === undefined)
+        return undefined;
+    return validated.headers;
+};
+export const Validated = Object.freeze({
+    body: validatedBody,
+    query: validatedQuery,
+    params: validatedParams,
+    headers: validatedHeaders,
+});