@zintrust/core 0.1.18 → 0.1.20

package/src/http/middleware/BodyParsingMiddleware.js

@@ -0,0 +1,251 @@
+/**
+ * Content Type Detection & Body Parsing Middleware
+ * Detects content-type and parses non-JSON request bodies
+ */
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { MultipartParser } from '../parsers/MultipartParser.js';
+/**
+ * Get content-type from request headers
+ */
+const getContentType = (req) => {
+    const contentType = req.getHeader('content-type');
+    if (typeof contentType === 'string')
+        return contentType.split(';')[0].toLowerCase().trim();
+    if (Array.isArray(contentType) && typeof contentType[0] === 'string') {
+        return contentType[0].split(';')[0].toLowerCase().trim();
+    }
+    return '';
+};
+const shouldReadRequestBody = (req) => {
+    const method = (req.getMethod?.() ?? 'GET').toUpperCase();
+    if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS')
+        return false;
+    return true;
+};
+const toBuffer = (chunk) => {
+    if (Buffer.isBuffer(chunk))
+        return chunk;
+    if (typeof chunk === 'string')
+        return Buffer.from(chunk);
+    if (chunk instanceof Uint8Array)
+        return Buffer.from(chunk);
+    if (chunk instanceof ArrayBuffer)
+        return Buffer.from(new Uint8Array(chunk));
+    return Buffer.from(String(chunk));
+};
+const validateSize = (bytes, maxBytes) => {
+    if (bytes.length > maxBytes) {
+        return { ok: false, statusCode: 413, message: 'Payload Too Large' };
+    }
+    return null;
+};
+const handleMockedStringBody = (body, maxBytes) => {
+    const bytes = Buffer.from(body);
+    const sizeError = validateSize(bytes, maxBytes);
+    if (sizeError)
+        return sizeError;
+    return { ok: true, bytes, text: body };
+};
+const handleMockedBufferBody = (body, maxBytes) => {
+    const sizeError = validateSize(body, maxBytes);
+    if (sizeError)
+        return sizeError;
+    return { ok: true, bytes: body, text: body.toString('utf-8') };
+};
+const handleMockedObjectBody = (body, maxBytes) => {
+    try {
+        const text = JSON.stringify(body);
+        const bytes = Buffer.from(text, 'utf-8');
+        const sizeError = validateSize(bytes, maxBytes);
+        if (sizeError)
+            return sizeError;
+        return { ok: true, bytes, text };
+    }
+    catch {
+        return { ok: false, statusCode: 400, message: 'Invalid request body' };
+    }
+};
+const handleMockedBody = (mockedBody, maxBytes) => {
+    if (typeof mockedBody === 'string') {
+        return handleMockedStringBody(mockedBody, maxBytes);
+    }
+    if (Buffer.isBuffer(mockedBody)) {
+        return handleMockedBufferBody(mockedBody, maxBytes);
+    }
+    if (typeof mockedBody === 'object' && mockedBody !== null) {
+        return handleMockedObjectBody(mockedBody, maxBytes);
+    }
+    return null;
+};
+const readStreamBody = async (raw, maxBytes) => {
+    const chunks = [];
+    let totalSize = 0;
+    try {
+        for await (const chunk of raw) {
+            const buf = toBuffer(chunk);
+            totalSize += buf.length;
+            if (totalSize > maxBytes) {
+                try {
+                    raw.destroy?.();
+                }
+                catch {
+                    // best-effort
+                }
+                return { ok: false, statusCode: 413, message: 'Payload Too Large' };
+            }
+            chunks.push(buf);
+        }
+    }
+    catch {
+        return { ok: false, statusCode: 400, message: 'Invalid request body' };
+    }
+    if (chunks.length === 0)
+        return { ok: true, bytes: Buffer.from(''), text: '' };
+    const bytes = Buffer.concat(chunks);
+    return { ok: true, bytes, text: bytes.toString('utf-8') };
+};
+const readRawBody = async (req, maxBytes) => {
+    const raw = req.getRaw();
+    // Support tests/mocks that stuff a body directly on the raw request.
+    const mockedBody = raw.body;
+    const mockedResult = handleMockedBody(mockedBody, maxBytes);
+    if (mockedResult) {
+        return mockedResult;
+    }
+    // Read from actual stream
+    return readStreamBody(raw, maxBytes);
+};
+const convertExistingToRawResult = (existingBytes, existingText) => {
+    if (Buffer.isBuffer(existingBytes)) {
+        return { ok: true, bytes: existingBytes, text: existingBytes.toString('utf-8') };
+    }
+    if (typeof existingText === 'string') {
+        return { ok: true, bytes: Buffer.from(existingText, 'utf-8'), text: existingText };
+    }
+    // Should be unreachable (guarded by `hasExisting`), but keep a safe fallback.
+    return { ok: true, bytes: Buffer.from('', 'utf-8'), text: '' };
+};
+const parseJsonBody = (text, contentType, res) => {
+    try {
+        return text === '' ? null : JSON.parse(text);
+    }
+    catch {
+        Logger.debug('[Body Parser] Invalid JSON body', {
+            contentType,
+            byteLength: Buffer.byteLength(text),
+            rawBodyPreview: text.slice(0, 256),
+        });
+        res.setStatus(400).json({ error: 'Invalid JSON body' });
+        return null;
+    }
+};
+const setRequestBody = (req, rawResult, contentType) => {
+    const isUrlEncoded = contentType.includes('application/x-www-form-urlencoded');
+    const isText = contentType.startsWith('text/') || contentType.includes('application/xml');
+    if (isUrlEncoded) {
+        req.setBody(parseUrlEncodedBody(rawResult.text));
+    }
+    else if (isText) {
+        req.setBody(rawResult.text);
+    }
+    else if (contentType !== '') {
+        req.setBody(rawResult.bytes);
+    }
+};
+const parseUrlEncodedBody = (text) => {
+    const out = {};
+    const params = new URLSearchParams(text);
+    for (const [key, value] of params.entries()) {
+        const existing = out[key];
+        if (existing === undefined) {
+            out[key] = value;
+            continue;
+        }
+        if (Array.isArray(existing)) {
+            existing.push(value);
+            continue;
+        }
+        out[key] = [existing, value];
+    }
+    return out;
+};
+const processBodyParsing = async (req, res, contentType, maxBytes) => {
+    const rawResult = await readRawBody(req, maxBytes);
+    if (rawResult.ok === false) {
+        res.setStatus(rawResult.statusCode).json({ error: rawResult.message });
+        return false;
+    }
+    // Store raw body for downstream consumers
+    req.context['rawBodyBytes'] = rawResult.bytes;
+    req.context['rawBodyText'] = rawResult.text;
+    // Parse and set body based on content type
+    try {
+        const isJson = contentType.includes('application/json');
+        if (isJson) {
+            const parsed = parseJsonBody(rawResult.text, contentType, res);
+            if (parsed === null && res.getStatus() === 400) {
+                return false; // JSON parsing failed, response already sent
+            }
+            req.setBody(parsed);
+        }
+        else {
+            setRequestBody(req, rawResult, contentType);
+        }
+        if (Env.getBool('ZIN_DEBUG_BODY_PARSING', false)) {
+            Logger.debug('[Body Parser] Parsed request body', {
+                contentType,
+                byteLength: rawResult.bytes.length,
+                parsedType: typeof req.getBody?.(),
+            });
+        }
+    }
+    catch (error) {
+        Logger.error('[Body Parser] Unexpected error during body parsing', error);
+    }
+    return true;
+};
+/**
+ * Body parsing middleware
+ * Automatically detects content-type and parses non-JSON bodies
+ */
+export const bodyParsingMiddleware = async (req, res, next) => {
+    const contentType = getContentType(req);
+    // Early exit if body already set
+    const existingBody = req.getBody?.();
+    if (existingBody !== null && existingBody !== undefined) {
+        await next();
+        return;
+    }
+    // Early exit for multipart (handled by upload middleware)
+    if (MultipartParser.isMultipart(contentType)) {
+        await next();
+        return;
+    }
+    // Early exit for methods that don't have bodies
+    if (!shouldReadRequestBody(req)) {
+        await next();
+        return;
+    }
+    // Determine if we have existing raw body from adapter
+    const existingBytes = req.context['rawBodyBytes'];
+    const existingText = req.context['rawBodyText'];
+    const hasExisting = Buffer.isBuffer(existingBytes) || typeof existingText === 'string';
+    // Calculate size limit based on content type
+    const isJson = contentType.includes('application/json');
+    const maxJsonSize = Env.getInt('MAX_JSON_SIZE', 1024 * 1024);
+    const maxBytes = isJson ? maxJsonSize : Env.MAX_BODY_SIZE;
+    // Read or reuse raw body
+    if (hasExisting) {
+        const rawResult = convertExistingToRawResult(existingBytes, existingText);
+        if (rawResult.ok) {
+            req.context['rawBodyBytes'] = rawResult.bytes;
+            req.context['rawBodyText'] = rawResult.text;
+        }
+    }
+    else {
+        await processBodyParsing(req, res, contentType, maxBytes);
+    }
+    await next();
+};
+export default bodyParsingMiddleware;

package/src/http/middleware/FileUploadMiddleware.d.ts

@@ -0,0 +1,12 @@
+/**
+ * File Upload Middleware
+ * Processes multipart/form-data requests and makes files available on request
+ */
+import type { Middleware } from '../../middleware/MiddlewareStack';
+/**
+ * File upload middleware
+ * Automatically parses multipart/form-data and makes files available
+ */
+export declare const fileUploadMiddleware: Middleware;
+export default fileUploadMiddleware;
+//# sourceMappingURL=FileUploadMiddleware.d.ts.map

package/src/http/middleware/FileUploadMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileUploadMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/http/middleware/FileUploadMiddleware.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAW9D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,UA8DlC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

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;AAqGD;;;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"}