@morojs/moro 1.6.8 → 1.7.0

package/dist/core/grpc/types.d.ts

@@ -0,0 +1,233 @@
+import type { HttpRequest, HttpResponse } from '../http/index.js';
+/**
+ * gRPC service call object
+ * Represents an incoming RPC call with request data and metadata
+ */
+export interface GrpcCall<TRequest = any> {
+    request: TRequest;
+    metadata: GrpcMetadata;
+    cancelled: boolean;
+    getPeer(): string;
+    sendMetadata(metadata: GrpcMetadata): void;
+    write?(data: any): void;
+    end?(): void;
+    on?(event: string, handler: (...args: any[]) => void): void;
+}
+/**
+ * gRPC callback for unary and client streaming calls
+ */
+export interface GrpcCallback<TResponse = any> {
+    (error: GrpcError | null, response?: TResponse): void;
+}
+/**
+ * gRPC metadata (headers)
+ */
+export interface GrpcMetadata {
+    get(key: string): string | string[] | undefined;
+    set(key: string, value: string | Buffer): void;
+    add(key: string, value: string | Buffer): void;
+    remove(key: string): void;
+    getMap(): Record<string, string | Buffer>;
+}
+/**
+ * gRPC error with status code
+ */
+export interface GrpcError extends Error {
+    code: GrpcStatusCode;
+    details?: string;
+    metadata?: GrpcMetadata;
+}
+/**
+ * Standard gRPC status codes
+ */
+export declare enum GrpcStatusCode {
+    OK = 0,
+    CANCELLED = 1,
+    UNKNOWN = 2,
+    INVALID_ARGUMENT = 3,
+    DEADLINE_EXCEEDED = 4,
+    NOT_FOUND = 5,
+    ALREADY_EXISTS = 6,
+    PERMISSION_DENIED = 7,
+    RESOURCE_EXHAUSTED = 8,
+    FAILED_PRECONDITION = 9,
+    ABORTED = 10,
+    OUT_OF_RANGE = 11,
+    UNIMPLEMENTED = 12,
+    INTERNAL = 13,
+    UNAVAILABLE = 14,
+    DATA_LOSS = 15,
+    UNAUTHENTICATED = 16
+}
+/**
+ * gRPC credentials for TLS/SSL
+ */
+export interface GrpcCredentials {
+    rootCerts?: Buffer;
+    privateKey?: Buffer;
+    certChain?: Buffer;
+    checkServerIdentity?: boolean;
+}
+/**
+ * gRPC server options
+ */
+export interface GrpcOptions {
+    port?: number;
+    host?: string;
+    adapter?: 'grpc-js' | 'grpc-web' | string;
+    protoPath?: string;
+    protoFiles?: string[];
+    credentials?: GrpcCredentials;
+    enableReflection?: boolean;
+    enableHealthCheck?: boolean;
+    maxReceiveMessageLength?: number;
+    maxSendMessageLength?: number;
+    maxConcurrentCalls?: number;
+    keepaliveTimeMs?: number;
+    keepaliveTimeoutMs?: number;
+    keepalivePermitWithoutCalls?: boolean;
+    compression?: boolean;
+    channelOptions?: Record<string, any>;
+}
+/**
+ * gRPC service method handler types
+ */
+export type UnaryHandler<TRequest = any, TResponse = any> = (call: GrpcCall<TRequest>, callback: GrpcCallback<TResponse>) => void | Promise<void>;
+export type ServerStreamingHandler<TRequest = any, TResponse = any> = (call: GrpcCall<TRequest>) => void | Promise<void>;
+export type ClientStreamingHandler<TRequest = any, TResponse = any> = (call: GrpcCall<TRequest>, callback: GrpcCallback<TResponse>) => void | Promise<void>;
+export type BidirectionalStreamingHandler<TRequest = any, TResponse = any> = (call: GrpcCall<TRequest>) => void | Promise<void>;
+export type GrpcHandler = UnaryHandler | ServerStreamingHandler | ClientStreamingHandler | BidirectionalStreamingHandler;
+/**
+ * Moro middleware-compatible gRPC handler
+ * Allows using Moro middleware with gRPC
+ */
+export type MoroGrpcHandler = (req: HttpRequest, res: HttpResponse) => void | Promise<void>;
+/**
+ * Service implementation
+ * Maps method names to their handlers
+ */
+export interface ServiceImplementation {
+    [methodName: string]: GrpcHandler | GrpcHandler[];
+}
+/**
+ * Service definition from proto file
+ */
+export interface ServiceDefinition {
+    serviceName: string;
+    packageName?: string;
+    methods: Record<string, MethodDefinition>;
+}
+/**
+ * Method definition from proto file
+ */
+export interface MethodDefinition {
+    path: string;
+    requestStream: boolean;
+    responseStream: boolean;
+    requestType: any;
+    responseType: any;
+    originalName?: string;
+}
+/**
+ * gRPC client options
+ */
+export interface GrpcClientOptions {
+    address: string;
+    credentials?: GrpcCredentials;
+    deadline?: number;
+    maxReceiveMessageLength?: number;
+    maxSendMessageLength?: number;
+    interceptors?: GrpcInterceptor[];
+    channelOptions?: Record<string, any>;
+}
+/**
+ * gRPC client interface
+ */
+export interface GrpcClient {
+    [methodName: string]: ((...args: any[]) => Promise<any>) | (() => void);
+    close(): void;
+}
+/**
+ * gRPC interceptor (middleware for gRPC)
+ */
+export interface GrpcInterceptor {
+    (call: GrpcCall, next: (call: GrpcCall) => Promise<any>): Promise<any>;
+}
+/**
+ * Health check status
+ */
+export declare enum HealthCheckStatus {
+    UNKNOWN = 0,
+    SERVING = 1,
+    NOT_SERVING = 2,
+    SERVICE_UNKNOWN = 3
+}
+/**
+ * Health check response
+ */
+export interface HealthCheckResponse {
+    status: HealthCheckStatus;
+}
+/**
+ * Server reflection options
+ */
+export interface ReflectionOptions {
+    services?: string[];
+}
+/**
+ * gRPC statistics
+ */
+export interface GrpcStats {
+    totalCalls: number;
+    activeCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    averageLatency: number;
+    byMethod: Record<string, {
+        calls: number;
+        errors: number;
+        averageLatency: number;
+    }>;
+}
+/**
+ * Streaming call state
+ */
+export interface StreamState {
+    isWritable: boolean;
+    isReadable: boolean;
+    isPaused: boolean;
+    isEnded: boolean;
+}
+/**
+ * Proto file loading options
+ */
+export interface ProtoLoadOptions {
+    keepCase?: boolean;
+    longs?: any;
+    enums?: any;
+    bytes?: any;
+    defaults?: boolean;
+    arrays?: boolean;
+    objects?: boolean;
+    oneofs?: boolean;
+    json?: boolean;
+    includeDirs?: string[];
+}
+/**
+ * gRPC server instance
+ */
+export interface GrpcServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    forceShutdown(): void;
+    getPort(): number;
+    getStats(): GrpcStats;
+}
+/**
+ * Service registration result
+ */
+export interface ServiceRegistration {
+    serviceName: string;
+    methods: string[];
+    protoPath?: string;
+}

package/dist/core/grpc/types.js

@@ -0,0 +1,36 @@
+// gRPC Type Definitions for Moro Framework
+// Comprehensive TypeScript interfaces for gRPC support
+/**
+ * Standard gRPC status codes
+ */
+export var GrpcStatusCode;
+(function (GrpcStatusCode) {
+    GrpcStatusCode[GrpcStatusCode["OK"] = 0] = "OK";
+    GrpcStatusCode[GrpcStatusCode["CANCELLED"] = 1] = "CANCELLED";
+    GrpcStatusCode[GrpcStatusCode["UNKNOWN"] = 2] = "UNKNOWN";
+    GrpcStatusCode[GrpcStatusCode["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
+    GrpcStatusCode[GrpcStatusCode["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
+    GrpcStatusCode[GrpcStatusCode["NOT_FOUND"] = 5] = "NOT_FOUND";
+    GrpcStatusCode[GrpcStatusCode["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
+    GrpcStatusCode[GrpcStatusCode["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+    GrpcStatusCode[GrpcStatusCode["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
+    GrpcStatusCode[GrpcStatusCode["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
+    GrpcStatusCode[GrpcStatusCode["ABORTED"] = 10] = "ABORTED";
+    GrpcStatusCode[GrpcStatusCode["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
+    GrpcStatusCode[GrpcStatusCode["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
+    GrpcStatusCode[GrpcStatusCode["INTERNAL"] = 13] = "INTERNAL";
+    GrpcStatusCode[GrpcStatusCode["UNAVAILABLE"] = 14] = "UNAVAILABLE";
+    GrpcStatusCode[GrpcStatusCode["DATA_LOSS"] = 15] = "DATA_LOSS";
+    GrpcStatusCode[GrpcStatusCode["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+})(GrpcStatusCode || (GrpcStatusCode = {}));
+/**
+ * Health check status
+ */
+export var HealthCheckStatus;
+(function (HealthCheckStatus) {
+    HealthCheckStatus[HealthCheckStatus["UNKNOWN"] = 0] = "UNKNOWN";
+    HealthCheckStatus[HealthCheckStatus["SERVING"] = 1] = "SERVING";
+    HealthCheckStatus[HealthCheckStatus["NOT_SERVING"] = 2] = "NOT_SERVING";
+    HealthCheckStatus[HealthCheckStatus["SERVICE_UNKNOWN"] = 3] = "SERVICE_UNKNOWN";
+})(HealthCheckStatus || (HealthCheckStatus = {}));
+//# sourceMappingURL=types.js.map

package/dist/core/grpc/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/grpc/types.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,uDAAuD;AA8CvD;;GAEG;AACH,MAAM,CAAN,IAAY,cAkBX;AAlBD,WAAY,cAAc;IACxB,+CAAM,CAAA;IACN,6DAAa,CAAA;IACb,yDAAW,CAAA;IACX,2EAAoB,CAAA;IACpB,6EAAqB,CAAA;IACrB,6DAAa,CAAA;IACb,uEAAkB,CAAA;IAClB,6EAAqB,CAAA;IACrB,+EAAsB,CAAA;IACtB,iFAAuB,CAAA;IACvB,0DAAY,CAAA;IACZ,oEAAiB,CAAA;IACjB,sEAAkB,CAAA;IAClB,4DAAa,CAAA;IACb,kEAAgB,CAAA;IAChB,8DAAc,CAAA;IACd,0EAAoB,CAAA;AACtB,CAAC,EAlBW,cAAc,KAAd,cAAc,QAkBzB;AA8HD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,+DAAW,CAAA;IACX,+DAAW,CAAA;IACX,uEAAe,CAAA;IACf,+EAAmB,CAAA;AACrB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B"}

package/dist/core/http/http-server.d.ts

@@ -19,10 +19,6 @@ export declare class MoroHttpServer {
     private static readonly METHOD_HEAD;
     private static readonly METHOD_OPTIONS;
     private static readonly RESPONSE_TEMPLATES;
-    private static readonly BUFFER_SIZES;
-    private static readonly BUFFER_POOLS;
-    private static getOptimalBuffer;
-    private static returnBuffer;
     constructor();
     configurePerformance(config?: {
         compression?: {
@@ -55,6 +51,19 @@ export declare class MoroHttpServer {
     private getMimeType;
     private addCharsetIfNeeded;
     private parseBody;
+    /**
+     * Create a streaming body parser for large payloads
+     * Returns a streaming interface instead of buffering
+     */
+    private createStreamingBodyParser;
+    /**
+     * Streaming JSON parser for large payloads
+     */
+    private streamJsonParse;
+    /**
+     * Streaming form data parser
+     */
+    private streamFormParse;
     private parseMultipart;
     private parseUrlEncoded;
     private parseQueryString;
@@ -128,83 +137,3 @@ export declare class MoroHttpServer {
         };
     };
 }
-export declare const middleware: {
-    cors: (options?: {
-        origin?: string;
-        credentials?: boolean;
-    }) => Middleware;
-    helmet: () => Middleware;
-    compression: (options?: {
-        threshold?: number;
-        level?: number;
-    }) => Middleware;
-    requestLogger: () => Middleware;
-    bodySize: (options?: {
-        limit?: string;
-    }) => Middleware;
-    static: (options: {
-        root: string;
-        maxAge?: number;
-        index?: string[];
-        dotfiles?: "allow" | "deny" | "ignore";
-        etag?: boolean;
-    }) => Middleware;
-    upload: (options?: {
-        dest?: string;
-        maxFileSize?: number;
-        maxFiles?: number;
-        allowedTypes?: string[];
-    }) => Middleware;
-    template: (options: {
-        views: string;
-        engine?: "moro" | "handlebars" | "ejs";
-        cache?: boolean;
-        defaultLayout?: string;
-    }) => Middleware;
-    http2Push: (options?: {
-        resources?: Array<{
-            path: string;
-            as: string;
-            type?: string;
-        }>;
-        condition?: (req: any) => boolean;
-    }) => Middleware;
-    sse: (options?: {
-        heartbeat?: number;
-        retry?: number;
-        cors?: boolean;
-    }) => Middleware;
-    range: (options?: {
-        acceptRanges?: string;
-        maxRanges?: number;
-    }) => Middleware;
-    csrf: (options?: {
-        secret?: string;
-        tokenLength?: number;
-        cookieName?: string;
-        headerName?: string;
-        ignoreMethods?: string[];
-        sameSite?: boolean;
-    }) => Middleware;
-    csp: (options?: {
-        directives?: {
-            defaultSrc?: string[];
-            scriptSrc?: string[];
-            styleSrc?: string[];
-            imgSrc?: string[];
-            connectSrc?: string[];
-            fontSrc?: string[];
-            objectSrc?: string[];
-            mediaSrc?: string[];
-            frameSrc?: string[];
-            childSrc?: string[];
-            workerSrc?: string[];
-            formAction?: string[];
-            upgradeInsecureRequests?: boolean;
-            blockAllMixedContent?: boolean;
-        };
-        reportOnly?: boolean;
-        reportUri?: string;
-        nonce?: boolean;
-    }) => Middleware;
-};