@spikard/node 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -1,67 +1,3 @@
-interface StreamingResponseInit {
-    statusCode?: number;
-    headers?: Record<string, string>;
-}
-declare const STREAM_HANDLE_PROP: "__spikard_stream_handle";
-type StreamChunk = JsonValue | string | Buffer | Uint8Array | ArrayBuffer | ArrayBufferView | null | undefined;
-type ChunkIterator = AsyncIterator<StreamChunk> & AsyncIterable<StreamChunk>;
-type StreamingHandle = {
-    kind: "native";
-    handle: number;
-    init: StreamingResponseInit;
-} | {
-    kind: "js";
-    iterator: ChunkIterator;
-    init: StreamingResponseInit;
-};
-declare class StreamingResponse {
-    readonly [STREAM_HANDLE_PROP]: StreamingHandle;
-    constructor(stream: AsyncIterable<StreamChunk> | AsyncIterator<StreamChunk>, init?: StreamingResponseInit);
-}
-
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonValue[] | {
-    [Key in string]: JsonValue;
-};
-type JsonRecord = Record<string, JsonValue>;
-type MaybePromise<T> = T | Promise<T>;
-interface Base64EncodedBody {
-    __spikard_base64__: string;
-}
-type HandlerBody = JsonValue | Base64EncodedBody | null;
-interface StructuredHandlerResponse {
-    status?: number;
-    statusCode?: number;
-    headers?: Record<string, string>;
-    body?: HandlerBody;
-}
-type HandlerResult = StructuredHandlerResponse | JsonValue | StreamingResponse | undefined;
-type HandlerFunction<TReturn extends HandlerResult = HandlerResult> = (request: Request) => MaybePromise<TReturn>;
-type NativeHandlerFunction<TReturn extends HandlerResult = HandlerResult> = (requestJson: string) => MaybePromise<TReturn | string>;
-type WebSocketHandler = (message: unknown) => MaybePromise<unknown>;
-interface WebSocketOptions {
-    onConnect?: () => MaybePromise<void>;
-    onDisconnect?: () => MaybePromise<void>;
-    messageSchema?: unknown;
-    responseSchema?: unknown;
-    handlerName?: string;
-}
-
-interface Request {
-    method: string;
-    path: string;
-    params: Record<string, string>;
-    pathParams: Record<string, string>;
-    query: Record<string, string>;
-    queryParams: Record<string, string>;
-    headers: Record<string, string>;
-    cookies: Record<string, string>;
-    body: Buffer | null;
-    dependencies: Record<string, unknown> | undefined;
-    json<T = JsonValue>(): T;
-    form(): Record<string, string>;
-}
-
 interface CompressionConfig {
     gzip?: boolean;
     brotli?: boolean;
@@ -117,6 +53,12 @@ interface OpenApiConfig {
     servers?: ServerInfo[];
     securitySchemes?: Record<string, SecuritySchemeInfo>;
 }
+interface JsonRpcConfig {
+    enabled?: boolean;
+    endpointPath?: string;
+    enableBatch?: boolean;
+    maxBatchSize?: number;
+}
 interface StaticFilesConfig {
     directory: string;
     routePrefix: string;
@@ -138,62 +80,7 @@ interface ServerConfig {
     gracefulShutdown?: boolean;
     shutdownTimeout?: number;
     openapi?: OpenApiConfig | null;
-}
-
-interface ServerOptions {
-    host?: string;
-    port?: number;
-}
-declare function runServer(app: SpikardApp, config?: ServerConfig | ServerOptions): void;
-
-type DependencyValue = unknown;
-type DependencyFactory = (dependencies: Record<string, DependencyValue>) => MaybePromise<DependencyValue>;
-interface DependencyOptions {
-    dependsOn?: string[];
-    singleton?: boolean;
-    cacheable?: boolean;
-}
-interface DependencyDescriptor {
-    isFactory: boolean;
-    value?: DependencyValue | undefined;
-    factory?: DependencyFactory | undefined;
-    dependsOn: string[];
-    singleton: boolean;
-    cacheable: boolean;
-}
-type LifecycleHookPayload = Request | StructuredHandlerResponse;
-type LifecycleHookFunction = (payload: LifecycleHookPayload) => MaybePromise<LifecycleHookPayload>;
-interface LifecycleHooks {
-    onRequest: LifecycleHookFunction[];
-    preValidation: LifecycleHookFunction[];
-    preHandler: LifecycleHookFunction[];
-    onResponse: LifecycleHookFunction[];
-    onError: LifecycleHookFunction[];
-}
-declare class Spikard implements SpikardApp {
-    routes: RouteMetadata[];
-    handlers: Record<string, HandlerFunction | NativeHandlerFunction>;
-    websocketRoutes: RouteMetadata[];
-    websocketHandlers: Record<string, Record<string, unknown>>;
-    lifecycleHooks: LifecycleHooks;
-    dependencies: Record<string, DependencyDescriptor>;
-    addRoute(metadata: RouteMetadata, handler: HandlerFunction | NativeHandlerFunction): void;
-    websocket(path: string, handler: WebSocketHandler, options?: WebSocketOptions): void;
-    run(options?: ServerOptions): void;
-    onRequest(hook: LifecycleHookFunction): LifecycleHookFunction;
-    preValidation(hook: LifecycleHookFunction): LifecycleHookFunction;
-    preHandler(hook: LifecycleHookFunction): LifecycleHookFunction;
-    onResponse(hook: LifecycleHookFunction): LifecycleHookFunction;
-    onError(hook: LifecycleHookFunction): LifecycleHookFunction;
-    provide(key: string, valueOrFactory: DependencyValue | DependencyFactory, options?: DependencyOptions): this;
-    getLifecycleHooks(): LifecycleHooks;
-}
-
-declare function run(work: () => void | Promise<void>): void;
-
-declare const background_run: typeof run;
-declare namespace background {
-  export { background_run as run };
+    jsonrpc?: JsonRpcConfig | null;
 }
 
 type GrpcMetadata = Record<string, string>;
@@ -207,9 +94,37 @@ interface GrpcResponse {
     payload: Buffer;
     metadata?: GrpcMetadata;
 }
+interface GrpcClientStreamRequest {
+    serviceName: string;
+    methodName: string;
+    metadata: GrpcMetadata;
+    messages: Buffer[];
+}
+interface GrpcServerStreamResponse {
+    messages: Buffer[];
+}
+interface GrpcBidiStreamRequest {
+    serviceName: string;
+    methodName: string;
+    metadata: GrpcMetadata;
+    messages: Buffer[];
+}
+interface GrpcBidiStreamResponse {
+    messages: Buffer[];
+    metadata?: GrpcMetadata;
+}
 interface GrpcHandler {
     handleRequest(request: GrpcRequest): Promise<GrpcResponse>;
 }
+interface GrpcServerStreamingHandler {
+    handleServerStream(request: GrpcRequest): Promise<GrpcServerStreamResponse>;
+}
+interface GrpcClientStreamingHandler {
+    handleClientStream(request: GrpcClientStreamRequest): Promise<GrpcResponse>;
+}
+interface GrpcBidirectionalStreamingHandler {
+    handleBidiStream(request: GrpcBidiStreamRequest): Promise<GrpcBidiStreamResponse>;
+}
 declare enum GrpcStatusCode {
     OK = 0,
     CANCELLED = 1,
@@ -233,9 +148,29 @@ declare class GrpcError extends Error {
     readonly code: GrpcStatusCode;
     constructor(code: GrpcStatusCode, message: string);
 }
-interface GrpcServiceConfig {
+type GrpcRpcMode = "unary" | "serverStreaming" | "clientStreaming" | "bidirectionalStreaming";
+type GrpcMethodHandler = GrpcHandler | GrpcServerStreamingHandler | GrpcClientStreamingHandler | GrpcBidirectionalStreamingHandler;
+interface GrpcMethodConfig {
     serviceName: string;
-    handler: GrpcHandler;
+    methodName: string;
+    rpcMode: GrpcRpcMode;
+    handler: GrpcMethodHandler;
+}
+declare class GrpcService {
+    private readonly methods;
+    private methodKey;
+    private registerMethod;
+    registerUnary(serviceName: string, methodName: string, handler: GrpcHandler): this;
+    registerServerStreaming(serviceName: string, methodName: string, handler: GrpcServerStreamingHandler): this;
+    registerClientStreaming(serviceName: string, methodName: string, handler: GrpcClientStreamingHandler): this;
+    registerBidirectionalStreaming(serviceName: string, methodName: string, handler: GrpcBidirectionalStreamingHandler): this;
+    unregister(serviceName: string, methodName: string): void;
+    getMethod(serviceName: string, methodName: string): GrpcMethodConfig | undefined;
+    serviceNames(): string[];
+    methodNames(serviceName: string): string[];
+    hasMethod(serviceName: string, methodName: string): boolean;
+    entries(): GrpcMethodConfig[];
+    handleRequest(request: GrpcRequest): Promise<GrpcResponse>;
 }
 type UnaryHandlerResult<TResponse> = TResponse | {
     response: TResponse;
@@ -250,6 +185,128 @@ declare function createUnaryHandler<TRequest, TResponse>(methodName: string, han
 }): GrpcHandler;
 declare function createServiceHandler(methods: Record<string, GrpcHandler>): GrpcHandler;
 
+interface StreamingResponseInit {
+    statusCode?: number;
+    headers?: Record<string, string>;
+}
+declare const STREAM_HANDLE_PROP: "__spikard_stream_handle";
+type StreamChunk = JsonValue | string | Buffer | Uint8Array | ArrayBuffer | ArrayBufferView | null | undefined;
+type ChunkIterator = AsyncIterator<StreamChunk> & AsyncIterable<StreamChunk>;
+type StreamingHandle = {
+    kind: "native";
+    handle: number;
+    init: StreamingResponseInit;
+} | {
+    kind: "js";
+    iterator: ChunkIterator;
+    init: StreamingResponseInit;
+};
+declare class StreamingResponse {
+    readonly [STREAM_HANDLE_PROP]: StreamingHandle;
+    constructor(stream: AsyncIterable<StreamChunk> | AsyncIterator<StreamChunk>, init?: StreamingResponseInit);
+}
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [Key in string]: JsonValue;
+};
+type JsonRecord = Record<string, JsonValue>;
+type MaybePromise<T> = T | Promise<T>;
+interface Base64EncodedBody {
+    __spikard_base64__: string;
+}
+type HandlerBody = JsonValue | Base64EncodedBody | null;
+interface StructuredHandlerResponse {
+    status?: number;
+    statusCode?: number;
+    headers?: Record<string, string>;
+    body?: HandlerBody;
+}
+type HandlerResult = StructuredHandlerResponse | JsonValue | StreamingResponse | undefined;
+type HandlerFunction<TReturn extends HandlerResult = HandlerResult> = (request: Request) => MaybePromise<TReturn>;
+type NativeHandlerFunction<TReturn extends HandlerResult = HandlerResult> = (requestJson: string) => MaybePromise<TReturn | string>;
+type WebSocketHandler = (message: unknown) => MaybePromise<unknown>;
+interface WebSocketOptions {
+    onConnect?: () => MaybePromise<void>;
+    onDisconnect?: () => MaybePromise<void>;
+    messageSchema?: unknown;
+    responseSchema?: unknown;
+    handlerName?: string;
+}
+
+interface Request {
+    method: string;
+    path: string;
+    params: Record<string, string>;
+    pathParams: Record<string, string>;
+    query: Record<string, string>;
+    queryParams: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+    body: Buffer | null;
+    dependencies: Record<string, unknown> | undefined;
+    json<T = JsonValue>(): T;
+    form(): Record<string, string>;
+}
+
+type DependencyValue = unknown;
+type DependencyFactory = (dependencies: Record<string, DependencyValue>) => MaybePromise<DependencyValue>;
+interface DependencyOptions {
+    dependsOn?: string[];
+    singleton?: boolean;
+    cacheable?: boolean;
+}
+interface DependencyDescriptor {
+    isFactory: boolean;
+    value?: DependencyValue | undefined;
+    factory?: DependencyFactory | undefined;
+    dependsOn: string[];
+    singleton: boolean;
+    cacheable: boolean;
+}
+type LifecycleHookPayload = Request | StructuredHandlerResponse;
+type LifecycleHookFunction = (payload: LifecycleHookPayload) => MaybePromise<LifecycleHookPayload>;
+interface LifecycleHooks {
+    onRequest: LifecycleHookFunction[];
+    preValidation: LifecycleHookFunction[];
+    preHandler: LifecycleHookFunction[];
+    onResponse: LifecycleHookFunction[];
+    onError: LifecycleHookFunction[];
+}
+declare class Spikard implements SpikardApp {
+    routes: RouteMetadata[];
+    handlers: Record<string, HandlerFunction | NativeHandlerFunction>;
+    websocketRoutes: RouteMetadata[];
+    websocketHandlers: Record<string, Record<string, unknown>>;
+    grpcMethods: GrpcMethodRegistration[];
+    grpcHandlers: Record<string, Record<string, unknown>>;
+    lifecycleHooks: LifecycleHooks;
+    dependencies: Record<string, DependencyDescriptor>;
+    addRoute(metadata: RouteMetadata, handler: HandlerFunction | NativeHandlerFunction): void;
+    websocket(path: string, handler: WebSocketHandler, options?: WebSocketOptions): void;
+    addGrpcUnary(serviceName: string, methodName: string, handler: GrpcHandler): this;
+    addGrpcServerStreaming(serviceName: string, methodName: string, handler: GrpcServerStreamingHandler): this;
+    addGrpcClientStreaming(serviceName: string, methodName: string, handler: GrpcClientStreamingHandler): this;
+    addGrpcBidirectionalStreaming(serviceName: string, methodName: string, handler: GrpcBidirectionalStreamingHandler): this;
+    private registerGrpcMethod;
+    useGrpc(service: GrpcService): this;
+    run(config?: ServerConfig): void;
+    onRequest(hook: LifecycleHookFunction): LifecycleHookFunction;
+    preValidation(hook: LifecycleHookFunction): LifecycleHookFunction;
+    preHandler(hook: LifecycleHookFunction): LifecycleHookFunction;
+    onResponse(hook: LifecycleHookFunction): LifecycleHookFunction;
+    onError(hook: LifecycleHookFunction): LifecycleHookFunction;
+    provide(key: string, valueOrFactory: DependencyValue | DependencyFactory, options?: DependencyOptions): this;
+    getLifecycleHooks(): LifecycleHooks;
+}
+
+declare function run(work: () => void | Promise<void>): void;
+
+declare const background_run: typeof run;
+declare namespace background {
+  export { background_run as run };
+}
+
 declare function wrapHandler(handler: HandlerFunction): NativeHandlerFunction;
 declare function wrapBodyHandler<TBody = unknown>(handler: (body: TBody, request: Request) => MaybePromise<HandlerResult>): NativeHandlerFunction;
 
@@ -273,6 +330,8 @@ declare function put(path: string, options?: Omit<RouteOptions, "methods">): (ha
 declare function del(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
 declare function patch(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
 
+declare function runServer(app: SpikardApp, config?: ServerConfig): void;
+
 interface NativeTestResponse {
     statusCode: number;
     headers(): Record<string, string>;
@@ -292,6 +351,13 @@ interface WebSocketTestConnection {
     close(): Promise<void>;
 }
 type TestResponse = NativeTestResponse;
+interface GraphQLSubscriptionResult {
+    operationId: string;
+    acknowledged: boolean;
+    event: unknown | null;
+    errors: unknown[];
+    completeReceived: boolean;
+}
 interface MultipartFile {
     name: string;
     filename?: string;
@@ -330,6 +396,7 @@ declare class TestClient {
         headers: string;
         bodyText: string;
     }>;
+    graphqlSubscription(query: string, variables?: Record<string, unknown> | null, operationName?: string | null, path?: string): Promise<GraphQLSubscriptionResult>;
     cleanup(): Promise<void>;
 }
 
@@ -387,14 +454,22 @@ interface RouteMetadata {
     is_async: boolean;
     cors?: CorsConfig | undefined;
 }
+interface GrpcMethodRegistration {
+    serviceName: string;
+    methodName: string;
+    rpcMode: GrpcRpcMode;
+    handlerName: string;
+}
 interface SpikardApp {
     routes: RouteMetadata[];
     handlers: Record<string, HandlerFunction | NativeHandlerFunction>;
     websocketRoutes?: RouteMetadata[];
     websocketHandlers?: Record<string, Record<string, unknown>>;
+    grpcMethods?: GrpcMethodRegistration[];
+    grpcHandlers?: Record<string, Record<string, unknown>>;
     config?: ServerConfig;
     lifecycleHooks?: Partial<LifecycleHooks>;
     dependencies?: Record<string, unknown>;
 }
 
-export { type ApiKeyConfig, type Base64EncodedBody, type Body, type CompressionConfig, type ContactInfo, type CorsConfig, type DependencyFactory, type DependencyOptions, type DependencyValue, type FileParam, GrpcError, type GrpcHandler, type GrpcMetadata, type GrpcRequest, type GrpcResponse, type GrpcServiceConfig, GrpcStatusCode, type HandlerFunction, type HandlerResult, type JsonPrimitive, type JsonRecord, type JsonSchema, type JsonValue, type JwtConfig, type LicenseInfo, type LifecycleHookFunction, type LifecycleHooks, type MaybePromise, type NativeHandlerFunction, type OpenApiConfig, type Path, type Query, QueryDefault, type RateLimitConfig, type Request, type RouteMetadata, type RouteOptions, type SecuritySchemeInfo, type ServerConfig, type ServerInfo, type ServerOptions, Spikard, type SpikardApp, type StaticFilesConfig, StreamingResponse, type StreamingResponseInit, type StructuredHandlerResponse, TestClient, type TestResponse, UploadFile, type WebSocketHandler, type WebSocketOptions, background, createServiceHandler, createUnaryHandler, del, get, patch, post, put, route, runServer, wrapBodyHandler, wrapHandler };
+export { type ApiKeyConfig, type Base64EncodedBody, type Body, type CompressionConfig, type ContactInfo, type CorsConfig, type DependencyFactory, type DependencyOptions, type DependencyValue, type FileParam, type GrpcBidiStreamRequest, type GrpcBidiStreamResponse, type GrpcBidirectionalStreamingHandler, type GrpcClientStreamRequest, type GrpcClientStreamingHandler, GrpcError, type GrpcHandler, type GrpcMetadata, type GrpcMethodConfig, type GrpcMethodHandler, type GrpcMethodRegistration, type GrpcRequest, type GrpcResponse, type GrpcRpcMode, type GrpcServerStreamResponse, type GrpcServerStreamingHandler, GrpcService, GrpcStatusCode, type HandlerFunction, type HandlerResult, type JsonPrimitive, type JsonRecord, type JsonRpcConfig, type JsonSchema, type JsonValue, type JwtConfig, type LicenseInfo, type LifecycleHookFunction, type LifecycleHooks, type MaybePromise, type NativeHandlerFunction, type OpenApiConfig, type Path, type Query, QueryDefault, type RateLimitConfig, type Request, type RouteMetadata, type RouteOptions, type SecuritySchemeInfo, type ServerConfig, type ServerInfo, Spikard, type SpikardApp, type StaticFilesConfig, StreamingResponse, type StreamingResponseInit, type StructuredHandlerResponse, TestClient, type TestResponse, UploadFile, type WebSocketHandler, type WebSocketOptions, background, createServiceHandler, createUnaryHandler, del, get, patch, post, put, route, runServer, wrapBodyHandler, wrapHandler };