@d3vtool/kazejs/dist/types/kaze.d.ts

A flexible Node.js web framework built with TypeScript, focusing on dependency injection, routing, middleware, and schema validation. Supports dynamic routes, global middleware, static files, and customizable error handling for scalable apps.

import http from "node:http";
import { getMimeType } from "@d3vtool/utils";
import { DerivedRouters, DynamicRouteInfo, HttpMethods, Router } from "./kaze-router";
import { KazeValidationError } from "./kaze-errors";
import { Cookie, CookieOptions, parseCookies } from "./kaze-cookies";
import { fileUpload, FileUploadOptions, KazeFile } from "./kaze-fileupload";
import { parseBody } from "./kaze-body";
import { TConstructor } from "./kaze-route-decorators";
interface KazeRequest<Query, Params, Body> extends http.IncomingMessage {
    secure: boolean;
    cookies?: Cookie;
    query?: Partial<Query>;
    params?: Partial<Params>;
    body?: Body;
    files?: KazeFile[];
}
interface KazeResponse extends Omit<http.ServerResponse, "statusCode" | "setHeader"> {
    send: (data: string) => void;
    statusCode: (code: number) => void;
    html: (htmlSource: string) => void;
    json: (jsonObj: Record<any, any>) => void;
    sendFile: (path: string) => Promise<void>;
    render: (file: string, data?: Record<string, any>) => Promise<void>;
    setHeader: http.ServerResponse["setHeader"];
    addHeader: (key: keyof http.IncomingHttpHeaders, value: string | string[]) => void;
    setCookie: (key: string, value: string, options: CookieOptions) => void;
}
export interface KazeContext<KazeDependencies = any, Query = any, Params = any, Body = any> {
    req: KazeRequest<Query, Params, Body>;
    res: KazeResponse;
    dependencies?: KazeDependencies;
}
export type KazeHttpMethod = "GET" | "POST" | "PUT" | "HEAD" | "PATCH" | "DELETE" | "TRACE" | "OPTIONS" | "CONNECT" | "LINK" | "UNLINK";
export type KazeRoute = string;
export type KazeNextFunction = () => void;
export type KazeRouteHandler = (ctx: KazeContext<any>, next: KazeNextFunction) => void | Promise<void>;
export type RouteMap = Map<KazeRoute, KazeRouteHandler[]>;
export type DynamicSegmentLength = number;
export type DynamicRouteMap = Map<DynamicSegmentLength, DynamicRouteInfo>;
export type RequestHandle = (request: http.IncomingMessage, response: http.ServerResponse) => void;
export type ErrorHandlerFn = (ctx: KazeContext<any>, error: unknown) => void | Promise<void>;
export type ValidationFailedFn = (ctx: KazeContext<any>, error: KazeValidationError) => void | Promise<void>;
export declare const AcceptedMethods: Set<KazeHttpMethod>;
export type StaticFile = {
    data: Buffer;
    mimeType: ReturnType<typeof getMimeType>;
};
export type KazeOptions<KazeDependencies> = {
    router?: DerivedRouters;
    class?: boolean;
    dependencies?: KazeDependencies;
};
export type ListenCallback = (err?: NodeJS.ErrnoException | null, address?: string | {
    address: string;
    family: string;
    port: number;
}) => void;
type HTMLSource = string;
export type KazeRendererContext = {
    filepath: string;
    renderEngineDirPath: string;
};
export type KazeRenderEngine = (rctx: KazeRendererContext, template: string, data?: Record<string, any>) => HTMLSource | Promise<HTMLSource>;
export type KazeRenderEngineOptions = {
    fileExtension: string;
};
export declare class Kaze<KazeDependencies> implements HttpMethods {
    #private;
    static routerClass: DerivedRouters;
    constructor(options?: KazeOptions<KazeDependencies>);
    static Router(router?: DerivedRouters): Router;
    static parseCookie(): typeof parseCookies;
    static parseBody(): ReturnType<typeof parseBody>;
    static fileUpload(options?: FileUploadOptions): ReturnType<typeof fileUpload>;
    static(directoryPath: string): void;
    renderEngine(engine: KazeRenderEngine, directoryPath: string, options: KazeRenderEngineOptions): void;
    addGlobalMiddleware(middleware: KazeRouteHandler | KazeRouteHandler[]): void;
    globalErrorHandler(fn: ErrorHandlerFn): void;
    globalVErrorHandler(fn: ValidationFailedFn): void;
    get(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    post(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    put(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    delete(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    patch(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    head(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    options(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    trace(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    connect(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    link(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    unlink(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    all(route: KazeRoute, ...reqHandler: KazeRouteHandler[]): void;
    routeGrp(parentRoute: KazeRoute, router: Router): void;
    controller(controller: TConstructor): void;
    getHandle(isHttps: boolean): RequestHandle;
    port(): number;
    close(): void;
    listen(port: number, listeningListener?: ListenCallback): void;
}
export {};