@zintrust/core 0.4.17 → 0.4.19

package/src/http/middleware/BodyParsingMiddleware.ts

@@ -1,316 +0,0 @@
-/**
- * Content Type Detection & Body Parsing Middleware
- * Detects content-type and parses non-JSON request bodies
- */
-
-import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import type { IRequest } from '@http/Request';
-import type { IResponse } from '@http/Response';
-import { MultipartParser } from '@http/parsers/MultipartParser';
-import type { Middleware } from '@middleware/MiddlewareStack';
-
-type ReadBodyResult =
-  | { ok: true; bytes: Buffer; text?: string }
-  | { ok: false; statusCode: 400 | 413; message: string };
-
-/**
- * Get content-type from request headers
- */
-const getContentType = (req: IRequest): string => {
-  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: IRequest): boolean => {
-  const method = (req.getMethod?.() ?? 'GET').toUpperCase();
-  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return false;
-  return true;
-};
-
-const toBuffer = (chunk: unknown): Buffer => {
-  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: Buffer, maxBytes: number): ReadBodyResult | null => {
-  if (bytes.length > maxBytes) {
-    return { ok: false, statusCode: 413, message: 'Payload Too Large' };
-  }
-  return null;
-};
-
-const handleMockedStringBody = (body: string, maxBytes: number): ReadBodyResult | null => {
-  const bytes = Buffer.from(body);
-  const sizeError = validateSize(bytes, maxBytes);
-  if (sizeError) return sizeError;
-  return { ok: true, bytes, text: body };
-};
-
-const handleMockedBufferBody = (body: Buffer, maxBytes: number): ReadBodyResult | null => {
-  const sizeError = validateSize(body, maxBytes);
-  if (sizeError) return sizeError;
-  return { ok: true, bytes: body, text: body.toString('utf-8') };
-};
-
-const handleMockedObjectBody = (body: object, maxBytes: number): ReadBodyResult | null => {
-  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: unknown, maxBytes: number): ReadBodyResult | null => {
-  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: unknown, maxBytes: number): Promise<ReadBodyResult> => {
-  const chunks: Buffer[] = [];
-  let totalSize = 0;
-
-  try {
-    for await (const chunk of raw as AsyncIterable<unknown>) {
-      const buf = toBuffer(chunk);
-      totalSize += buf.length;
-
-      if (totalSize > maxBytes) {
-        try {
-          (raw as { destroy?: () => void }).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: IRequest, maxBytes: number): Promise<ReadBodyResult> => {
-  const raw = req.getRaw();
-
-  // Support tests/mocks that stuff a body directly on the raw request.
-  const mockedBody = (raw as unknown as { body?: unknown }).body;
-  const mockedResult = handleMockedBody(mockedBody, maxBytes);
-  if (mockedResult) {
-    return mockedResult;
-  }
-
-  // Read from actual stream
-  return readStreamBody(raw, maxBytes);
-};
-
-const shouldStoreRawText = (contentType: string): boolean => {
-  if (contentType.includes('application/json')) return true;
-  if (contentType.includes('application/x-www-form-urlencoded')) return true;
-  if (contentType.startsWith('text/')) return true;
-  if (contentType.includes('application/xml')) return true;
-  return false;
-};
-
-const getTextFromRaw = (rawResult: ReadBodyResult & { ok: true }): string => {
-  if (typeof rawResult.text === 'string') return rawResult.text;
-  return rawResult.bytes.toString('utf-8');
-};
-
-const convertExistingToRawResult = (
-  existingBytes: unknown,
-  existingText: unknown
-): ReadBodyResult => {
-  if (Buffer.isBuffer(existingBytes)) {
-    return { ok: true, bytes: existingBytes };
-  }
-
-  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: string, contentType: string, res: IResponse): unknown => {
-  try {
-    return text === '' ? null : (JSON.parse(text) as unknown);
-  } 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: IRequest,
-  rawResult: ReadBodyResult & { ok: true },
-  contentType: string
-): void => {
-  const isUrlEncoded = contentType.includes('application/x-www-form-urlencoded');
-  const isText = contentType.startsWith('text/') || contentType.includes('application/xml');
-  const text = getTextFromRaw(rawResult);
-
-  if (isUrlEncoded) {
-    req.setBody(parseUrlEncodedBody(text));
-  } else if (isText) {
-    req.setBody(text);
-  } else if (contentType !== '') {
-    req.setBody(rawResult.bytes);
-  }
-};
-
-const parseUrlEncodedBody = (text: string): Record<string, string | string[]> => {
-  const out: Record<string, string | string[]> = {};
-  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: IRequest,
-  res: IResponse,
-  contentType: string,
-  maxBytes: number
-): Promise<boolean> => {
-  const rawResult: ReadBodyResult = 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;
-  if (shouldStoreRawText(contentType)) {
-    req.context['rawBodyText'] = getTextFromRaw(rawResult);
-  } else {
-    req.context['rawBodyText'] = undefined;
-  }
-
-  // Parse and set body based on content type
-  try {
-    const isJson = contentType.includes('application/json');
-    if (isJson) {
-      const parsed = parseJsonBody(getTextFromRaw(rawResult), 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: Middleware = async (
-  req: IRequest,
-  res: IResponse,
-  next: () => Promise<void>
-): Promise<void> => {
-  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;
-      if (shouldStoreRawText(contentType)) {
-        req.context['rawBodyText'] = getTextFromRaw(rawResult);
-      } else {
-        req.context['rawBodyText'] = undefined;
-      }
-    }
-  } else {
-    await processBodyParsing(req, res, contentType, maxBytes);
-  }
-
-  await next();
-};
-
-export default bodyParsingMiddleware;

package/src/http/middleware/FileUploadMiddleware.ts

@@ -1,91 +0,0 @@
-/**
- * File Upload Middleware
- * Processes multipart/form-data requests and makes files available on request
- */
-
-import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import { MultipartParser } from '@http/parsers/MultipartParser';
-import { MultipartParserRegistry } from '@http/parsers/MultipartParserRegistry';
-import type { IRequest } from '@http/Request';
-import type { IResponse } from '@http/Response';
-import type { Middleware } from '@middleware/MiddlewareStack';
-
-/**
- * Extract content-type header safely
- */
-const getContentType = (req: IRequest): string => {
-  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: Middleware = async (
-  req: IRequest,
-  res: IResponse,
-  next: () => Promise<void>
-): Promise<void> => {
-  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.ts

@@ -1,188 +0,0 @@
-/**
- * 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;
-}
-
-/**
- * URL-encoded form data parser
- * Content-Type: application/x-www-form-urlencoded
- */
-const FormDataParser: IBodyParser = {
-  canParse: (contentType: string): boolean =>
-    contentType.includes('application/x-www-form-urlencoded'),
-
-  parse: (body: string | Buffer): BodyParserResult => {
-    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: Record<string, unknown> = {};
-
-      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: IBodyParser = {
-  canParse: (contentType: string): boolean => contentType.includes('text/plain'),
-
-  parse: (body: string | Buffer): BodyParserResult => {
-    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: string): string[] => {
-  const result: string[] = [];
-  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: IBodyParser = {
-  canParse: (contentType: string): boolean => contentType.includes('text/csv'),
-
-  parse: (body: string | Buffer): BodyParserResult => {
-    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: Record<string, unknown>[] = [];
-      let headers: string[] | undefined;
-      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: Record<string, unknown> = {};
-        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(): IBodyParser[] {
-    return [this.FormDataParser, this.TextParser, this.CSVParser];
-  },
-
-  /**
-   * Find parser for content-type
-   */
-  findParser(contentType: string): IBodyParser | undefined {
-    return this.getAll().find((parser) => parser.canParse(contentType));
-  },
-
-  /**
-   * Parse body based on content-type
-   */
-  parse(contentType: string, body: string | Buffer): BodyParserResult {
-    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;