@zintrust/core 0.1.19 → 0.1.21

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,
+});

package/src/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Zintrust Framework - Production-Grade TypeScript Backend
+ * ZinTrust Framework - Production-Grade TypeScript Backend
  * Built for performance, type safety, and exceptional developer experience
  */
 declare const ZintrustApplication: Readonly<{
@@ -53,11 +53,21 @@ declare const ZintrustSignedRequest: Readonly<{
 export { Server } from './boot/Server';
 export { ServiceContainer } from './container/ServiceContainer';
 export { Controller } from './http/Controller';
+export { FileUpload } from './http/FileUpload';
+export type { FileUploadOptions, IFileUploadHandler, UploadedFile } from './http/FileUpload';
 export { Kernel } from './http/Kernel';
+export { bodyParsingMiddleware } from './http/middleware/BodyParsingMiddleware';
+export { fileUploadMiddleware } from './http/middleware/FileUploadMiddleware';
+export { BodyParsers } from './http/parsers/BodyParsers';
+export { MultipartParser } from './http/parsers/MultipartParser';
+export { MultipartParserRegistry } from './http/parsers/MultipartParserRegistry';
+export type { MultipartFieldValue, MultipartParseInput, MultipartParserProvider, ParsedMultipartData, } from './http/parsers/MultipartParserRegistry';
 export { Request } from './http/Request';
-export type { IRequest } from './http/Request';
+export type { IRequest, ValidatedRequest } from './http/Request';
+export { RequestContext } from './http/RequestContext';
 export { Response } from './http/Response';
 export type { IResponse } from './http/Response';
+export { getValidatedBody, getValidatedHeaders, getValidatedParams, getValidatedQuery, hasValidatedBody, requireValidatedBody, ValidationHelper, } from './http/ValidationHelper';
 export { CsrfMiddleware } from './middleware/CsrfMiddleware';
 export { ErrorHandlerMiddleware } from './middleware/ErrorHandlerMiddleware';
 export { LoggingMiddleware } from './middleware/LoggingMiddleware';
@@ -66,32 +76,47 @@ export type { Middleware } from './middleware/MiddlewareStack';
 export { RateLimiter } from './middleware/RateLimiter';
 export { SecurityMiddleware } from './middleware/SecurityMiddleware';
 export { SessionMiddleware } from './middleware/SessionMiddleware';
+export { ValidationMiddleware } from './middleware/ValidationMiddleware';
 export { MySQLAdapter } from './orm/adapters/MySQLAdapter';
 export { PostgreSQLAdapter } from './orm/adapters/PostgreSQLAdapter';
 export { SQLiteAdapter } from './orm/adapters/SQLiteAdapter';
 export { SQLServerAdapter } from './orm/adapters/SQLServerAdapter';
-export { Database, resetDatabase, useDatabase } from './orm/Database';
+export { Database, resetDatabase, useDatabase, useEnsureDbConnected } from './orm/Database';
+export type { IDatabase } from './orm/Database';
 export { Model } from './orm/Model';
 export type { IModel, ModelConfig, ModelStatic } from './orm/Model';
 export { QueryBuilder } from './orm/QueryBuilder';
+export type { InsertResult, IQueryBuilder } from './orm/QueryBuilder';
 export type { IRelationship } from './orm/Relationships';
 export { ZintrustApplication as Application };
+export { DateTime } from './time/DateTime';
+export type { IDateTime } from './time/DateTime';
+export { Schema as MigrationSchema, type Blueprint } from './migrations/schema';
+export { OpenApiGenerator } from './openapi/OpenApiGenerator';
+export type { OpenApiGeneratorOptions } from './openapi/OpenApiGenerator';
 export { DatabaseAdapterRegistry } from './orm/DatabaseAdapterRegistry';
 export { Router } from './routing/Router';
 export type { IRouter } from './routing/Router';
+export { normalizeRouteMeta, RouteRegistry } from './routing/RouteRegistry';
+export type { RouteMeta, RouteMetaInput, RouteRegistration } from './routing/RouteRegistry';
+export { generateSecureJobId, generateUuid, getString, Utilities, type UtilitiesType, } from './common/utility';
 export { delay, ensureDirSafe } from './common/index';
-export { generateSecureJobId, generateUuid } from './common/uuid';
 export { ZintrustAwsSigV4 as AwsSigV4 };
 export { collect, Collection } from './collections/index';
 export type { ICollection, PrimitiveKey } from './collections/index';
 export { HttpClient } from './tools/http/Http';
 export type { IHttpRequest, IHttpResponse } from './tools/http/Http';
-export type { DatabaseConfig, ID1Database } from './orm/DatabaseAdapter';
+export type { DatabaseConfig, ID1Database, IDatabaseAdapter, QueryResult, } from './orm/DatabaseAdapter';
 export { MemoryProfiler } from './profiling/MemoryProfiler';
 export { N1Detector } from './profiling/N1Detector';
 export { QueryLogger } from './profiling/QueryLogger';
 export { RequestProfiler } from './profiling/RequestProfiler';
 export type { MemoryDelta, MemorySnapshot, N1Pattern, ProfileReport, QueryLogEntry, } from './profiling/types';
+export { GenerationCache, LazyLoader, Memoize, ParallelGenerator, PerformanceOptimizer, runAll, runBatch, } from './performance/Optimizer';
+export type { IGenerationCache, ILazyLoader, IPerformanceOptimizer } from './performance/Optimizer';
+export { OpenTelemetry } from './observability/OpenTelemetry';
+export { PrometheusMetrics } from './observability/PrometheusMetrics';
+export type { ObserveDbQueryInput, ObserveHttpRequestInput, } from './observability/PrometheusMetrics';
 export { ValidationError } from './validation/ValidationError';
 export type { FieldError } from './validation/ValidationError';
 export { Schema, Validator } from './validation/Validator';
@@ -105,6 +130,8 @@ export { JwtManager } from './security/JwtManager';
 export type { IJwtManager, JwtAlgorithm, JwtManagerType, JwtOptions, JwtPayload, } from './security/JwtManager';
 export { PasswordResetTokenBroker } from './security/PasswordResetTokenBroker';
 export type { IPasswordResetTokenBroker, IPasswordResetTokenStore, PasswordResetTokenBrokerOptions, PasswordResetTokenBrokerType, PasswordResetTokenRecord, } from './security/PasswordResetTokenBroker';
+export { createSanitizer, Sanitizer, type SanitizerType } from './security/Sanitizer';
+export { TokenRevocation } from './security/TokenRevocation';
 export { Xss } from './security/Xss';
 export { XssProtection } from './security/XssProtection';
 export { ZintrustSignedRequest as SignedRequest };
@@ -119,31 +146,45 @@ export type * from './config/type';
 export { appConfig } from './config/app';
 export type { AppConfig } from './config/app';
 export { cacheConfig } from './config/cache';
-export type { CacheConfig } from './config/cache';
+export type { CacheConfig, CacheConfigOverrides } from './config/cache';
+export { Cache, cache } from './cache/Cache';
+export type { CacheDriver } from './cache/CacheDriver';
 export { registerCachesFromRuntimeConfig } from './cache/CacheRuntimeRegistration';
 export { CacheDriverRegistry } from './cache/CacheDriverRegistry';
 export { databaseConfig } from './config/database';
-export type { DatabaseConfig as DatabaseRuntimeConfig } from './config/database';
+export type { DatabaseConfigOverrides, DatabaseConfig as DatabaseRuntimeConfig, } from './config/database';
 export { registerDatabasesFromRuntimeConfig } from './orm/DatabaseRuntimeRegistration';
 export { microservicesConfig } from './config/microservices';
 export type { MicroservicesConfig } from './config/microservices';
-export { middlewareConfig } from './config/middleware';
+export { MicroserviceBootstrap } from './microservices/MicroserviceBootstrap';
+export type { IMicroserviceBootstrap, ServiceConfig } from './microservices/MicroserviceBootstrap';
+export { MicroserviceManager } from './microservices/MicroserviceManager';
+export type { IMicroserviceManager, MicroserviceConfig } from './microservices/MicroserviceManager';
+export { RequestTracingMiddleware } from './microservices/RequestTracingMiddleware';
+export { ServiceAuthMiddleware } from './microservices/ServiceAuthMiddleware';
+export { HealthCheckHandler, ServiceHealthMonitor } from './microservices/ServiceHealthMonitor';
+export type { AggregatedHealthStatus, HealthCheckResult, IServiceHealthMonitor, } from './microservices/ServiceHealthMonitor';
+export { middlewareConfig, MiddlewareKeys } from './config/middleware';
+export type { MiddlewareKey } from './config/middleware';
 export type { MiddlewareConfigType } from './config/type';
 export { queueConfig } from './config/queue';
-export type { QueueConfig } from './config/queue';
+export type { QueueConfig, QueueConfigOverrides } from './config/queue';
 export { default as broadcastConfig } from './config/broadcast';
+export type { BroadcastConfigOverrides } from './config/broadcast';
 export { default as notificationConfig } from './config/notification';
+export type { NotificationConfig, NotificationConfigOverrides } from './config/notification';
 export { securityConfig } from './config/security';
 export { mailConfig } from './config/mail';
-export type { MailConfig } from './config/mail';
+export type { MailConfig, MailConfigOverrides } from './config/mail';
 export { storageConfig } from './config/storage';
-export type { StorageConfig } from './config/storage';
+export type { StorageConfig, StorageConfigOverrides } from './config/storage';
 export { startupConfig } from './config/startup';
 export type { StartupConfig } from './config/startup';
 export { Constants, DEFAULTS, ENV_KEYS, HTTP_HEADERS, MIME_TYPES } from './config/constants';
 export { FeatureFlags } from './config/features';
 export { Cloudflare } from './config/cloudflare';
-export { SecretsManager } from './config/SecretsManager';
+export { getDatabaseCredentials, getJwtSecrets, SECRETS, SecretsManager, } from './config/SecretsManager';
+export type { DatabaseCredentials, JwtSecrets } from './config/SecretsManager';
 export type { MailDriverConfig, MailDriverName, WorkersEnv } from './config/type';
 export { StartupConfigValidator } from './config/StartupConfigValidator';
 export { Mail } from './tools/mail/Mail';
@@ -181,4 +222,24 @@ export { GcsDriver } from './tools/storage/drivers/Gcs';
 export type { GcsConfig } from './tools/storage/drivers/Gcs';
 export { RedisQueue } from './tools/queue/drivers/Redis';
 export { Queue } from './tools/queue/Queue';
+export { SeederLoader } from './seeders/SeederLoader';
+export type { LoadedSeeder, SeederHandler } from './seeders/types';
+export { default as logCleanup } from './schedules/log-cleanup';
+export * as NodeSingletons from './node-singletons/index';
+export { Auth } from './features/Auth';
+export { MicroserviceGenerator } from './microservices/MicroserviceGenerator';
+export type { GenerateServiceOptions, IMicroserviceGenerator, } from './microservices/MicroserviceGenerator';
+export { BaseCommand } from './cli/BaseCommand';
+export type { CommandOptions } from './cli/BaseCommand';
+export { CLI } from './cli/CLI';
+export { ErrorHandler, EXIT_CODES } from './cli/ErrorHandler';
+export { getKernel } from './runtime/getKernel';
+export { RuntimeDetector } from './runtime/RuntimeDetector';
+export { useFileLoader } from './runtime/useFileLoader';
+export { PluginManager } from './runtime/PluginManager';
+export { PluginRegistry } from './runtime/PluginRegistry';
+export { nowIso } from './common/utility';
+export type { SanitizerError } from './exceptions/ZintrustError';
+export { randomBytes } from './node-singletons/crypto';
+export type { MiddlewaresType } from './config/middleware';
 //# sourceMappingURL=index.d.ts.map