@spikard/wasm 0.6.2 → 0.7.0

package/dist/index.d.ts

@@ -0,0 +1,365 @@
+declare const STREAM_HANDLE_PROP: unique symbol;
+type StreamChunk = JsonValue | string | Uint8Array | ArrayBuffer | ArrayBufferView | null | undefined;
+type AsyncIteratorLike<T> = AsyncIterator<T> & AsyncIterable<T>;
+interface StreamingResponseInit {
+    statusCode?: number;
+    headers?: Record<string, string>;
+}
+declare class StreamingResponse {
+    readonly statusCode: number;
+    readonly headers: Record<string, string>;
+    readonly [STREAM_HANDLE_PROP]: AsyncIteratorLike<StreamChunk>;
+    readonly __spikard_streaming__: true;
+    constructor(stream: AsyncIterable<StreamChunk> | AsyncIterator<StreamChunk>, init?: StreamingResponseInit);
+    collect(): Promise<Uint8Array>;
+}
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [Key in string]: JsonValue;
+};
+type JsonRecord = Record<string, JsonValue>;
+type BinaryLike = ArrayBuffer | ArrayBufferView | Uint8Array | Blob;
+type MaybePromise<T> = T | Promise<T>;
+interface AbortSignalLike {
+    readonly aborted: boolean;
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    } | boolean): void;
+    removeEventListener(type: "abort", listener: () => void): void;
+}
+interface HandlerContext {
+    signal?: AbortSignalLike;
+}
+interface Base64EncodedBody {
+    __spikard_base64__: string;
+}
+type HandlerBody = JsonValue | Base64EncodedBody | null;
+interface StructuredHandlerResponse {
+    status?: number;
+    statusCode?: number;
+    headers?: Record<string, string>;
+    body?: HandlerBody;
+}
+type HandlerPayload = Request$1 | JsonValue | string | BinaryLike | null | undefined;
+type HandlerResult = StructuredHandlerResponse | JsonValue | StreamingResponse | undefined;
+type HandlerFunction<TReturn extends HandlerResult = HandlerResult> = (payload: HandlerPayload, context?: HandlerContext) => MaybePromise<TReturn>;
+interface WebSocketServerSocket {
+    sendText(message: string): MaybePromise<void>;
+    sendJson(payload: JsonValue): MaybePromise<void>;
+    sendBytes?(payload: BinaryLike): MaybePromise<void>;
+    close(code?: number, reason?: string): MaybePromise<void>;
+    broadcast?(payload: JsonValue | string): MaybePromise<void>;
+    isClosed(): boolean;
+}
+interface WebSocketHandler {
+    onOpen?: (socket: WebSocketServerSocket) => MaybePromise<void>;
+    onMessage?: (socket: WebSocketServerSocket, data: JsonValue | string | BinaryLike) => MaybePromise<void>;
+    onClose?: (socket: WebSocketServerSocket, code?: number, reason?: string) => MaybePromise<void>;
+}
+type WebSocketHandlerLike = WebSocketHandler | HandlerFunction;
+
+interface Request$1 {
+    method: string;
+    path: string;
+    queryString: string;
+    params?: Record<string, JsonValue>;
+    pathParams?: Record<string, string>;
+    query?: Record<string, JsonValue>;
+    files?: Array<{
+        name: string;
+        filename?: string;
+        content?: string;
+        contentType?: string;
+    }>;
+    headers: Record<string, string>;
+    body: Buffer | Uint8Array | null;
+    json<T extends JsonValue = JsonValue>(): T;
+    form(): Record<string, string>;
+}
+
+interface CompressionConfig {
+    gzip?: boolean;
+    brotli?: boolean;
+    minSize?: number;
+    quality?: number;
+}
+interface RateLimitConfig {
+    perSecond: number;
+    burst: number;
+    ipBased?: boolean;
+}
+interface JwtConfig {
+    secret: string;
+    algorithm?: string;
+    audience?: string[];
+    issuer?: string;
+    leeway?: number;
+}
+interface ApiKeyConfig {
+    keys: string[];
+    headerName?: string;
+}
+interface ContactInfo {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+interface LicenseInfo {
+    name: string;
+    url?: string;
+}
+interface ServerInfo {
+    url: string;
+    description?: string;
+}
+interface SecuritySchemeInfo {
+    type: "http" | "apiKey";
+    scheme?: string;
+    bearerFormat?: string;
+    location?: "header" | "query" | "cookie";
+    name?: string;
+}
+interface OpenApiConfig {
+    enabled?: boolean;
+    title?: string;
+    version?: string;
+    description?: string;
+    swaggerUiPath?: string;
+    redocPath?: string;
+    openapiJsonPath?: string;
+    contact?: ContactInfo;
+    license?: LicenseInfo;
+    servers?: ServerInfo[];
+    securitySchemes?: Record<string, SecuritySchemeInfo>;
+}
+interface StaticFilesConfig {
+    directory: string;
+    routePrefix: string;
+    indexFile?: boolean;
+    cacheControl?: string;
+}
+interface StaticManifestEntry {
+    route: string;
+    headers: Record<string, string>;
+    body: string;
+}
+interface ServerConfig {
+    host?: string;
+    port?: number;
+    workers?: number;
+    enableRequestId?: boolean;
+    maxBodySize?: number | null;
+    requestTimeout?: number | null;
+    compression?: CompressionConfig | null;
+    rateLimit?: RateLimitConfig | null;
+    jwtAuth?: JwtConfig | null;
+    apiKeyAuth?: ApiKeyConfig | null;
+    staticFiles?: StaticFilesConfig[];
+    __wasmStaticManifest?: StaticManifestEntry[];
+    gracefulShutdown?: boolean;
+    shutdownTimeout?: number;
+    openapi?: OpenApiConfig | null;
+}
+
+interface ServerOptions {
+    host?: string;
+    port?: number;
+}
+type FetchHandler = (request: Request) => Promise<Response>;
+declare function createFetchHandler(app: SpikardApp): FetchHandler;
+declare function runServer(app: SpikardApp, config?: ServerConfig | ServerOptions): void;
+
+type DependencyValue = unknown;
+type DependencyFactory = (...args: unknown[]) => MaybePromise<unknown>;
+interface DependencyOptions {
+    dependsOn?: string[];
+    singleton?: boolean;
+    cacheable?: boolean;
+}
+interface DependencyDescriptor {
+    isFactory: boolean;
+    value?: DependencyValue | undefined;
+    factory?: ((dependenciesJson: string) => Promise<string>) | undefined;
+    dependsOn: string[];
+    singleton: boolean;
+    cacheable: boolean;
+}
+type LifecycleHookFunction = (payload: unknown) => MaybePromise<unknown>;
+interface LifecycleHooks {
+    onRequest: LifecycleHookFunction[];
+    preValidation: LifecycleHookFunction[];
+    preHandler: LifecycleHookFunction[];
+    onResponse: LifecycleHookFunction[];
+    onError: LifecycleHookFunction[];
+}
+declare class Spikard implements SpikardApp {
+    routes: RouteMetadata[];
+    handlers: Record<string, HandlerFunction>;
+    websocketRoutes: RouteMetadata[];
+    websocketHandlers: Record<string, WebSocketHandlerLike>;
+    lifecycleHooks: LifecycleHooks;
+    dependencies: Record<string, DependencyDescriptor>;
+    addRoute(metadata: RouteMetadata, handler: HandlerFunction): void;
+    websocket(path: string, handler: WebSocketHandlerLike, options?: WebSocketOptions): void;
+    run(options?: ServerOptions): void;
+    provide(key: string, valueOrFactory: DependencyValue | DependencyFactory, options?: DependencyOptions): this;
+    onRequest(hook: LifecycleHookFunction): LifecycleHookFunction;
+    preValidation(hook: LifecycleHookFunction): LifecycleHookFunction;
+    preHandler(hook: LifecycleHookFunction): LifecycleHookFunction;
+    onResponse(hook: LifecycleHookFunction): LifecycleHookFunction;
+    onError(hook: LifecycleHookFunction): LifecycleHookFunction;
+    getLifecycleHooks(): LifecycleHooks;
+}
+interface WebSocketOptions {
+    handlerName?: string;
+    messageSchema?: JsonSchema;
+    responseSchema?: JsonSchema;
+}
+
+declare function run(work: () => void | Promise<void>): void;
+
+declare const background_run: typeof run;
+declare namespace background {
+  export { background_run as run };
+}
+
+type Query<T> = T;
+type Path<T> = T;
+type Body<T> = T;
+declare function QueryDefault<T>(value: T): T;
+
+interface RouteOptions {
+    methods?: string | string[];
+    bodySchema?: JsonSchema;
+    responseSchema?: JsonSchema;
+    parameterSchema?: JsonSchema;
+    cors?: CorsConfig;
+}
+type RouteArgument = Request$1 | JsonValue | string | number | boolean | null | undefined;
+type RouteHandler = (...args: RouteArgument[]) => MaybePromise<HandlerResult>;
+declare function route(path: string, options?: RouteOptions): (handler: RouteHandler) => RouteHandler;
+declare function get(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
+declare function post(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
+declare function put(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
+declare function del(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
+declare function patch(path: string, options?: Omit<RouteOptions, "methods">): (handler: RouteHandler) => RouteHandler;
+
+type HeaderMap = Record<string, string>;
+interface MultipartFile {
+    name: string;
+    filename?: string;
+    content: string;
+    contentType?: string;
+}
+interface RequestOptions {
+    headers?: HeaderMap;
+    json?: JsonValue;
+    form?: Record<string, JsonValue> | string;
+    formRaw?: string;
+    multipart?: {
+        fields?: Record<string, JsonValue>;
+        files?: MultipartFile[];
+    };
+    binary?: string;
+}
+declare class TestResponse {
+    private readonly status;
+    private readonly headersMap;
+    private readonly bodyBytes;
+    private decodedBody;
+    constructor(status: number, headersMap: HeaderMap, body: Uint8Array | ArrayBuffer | ArrayLike<number>);
+    get statusCode(): number;
+    headers(): HeaderMap;
+    text(): string;
+    json(): JsonValue | string | null;
+    bytes(): Uint8Array;
+    raw(): Uint8Array;
+    private getDecodedBody;
+    private getHeaderValue;
+}
+declare class TestClient {
+    private readonly routes;
+    private readonly websocketRoutes;
+    readonly websocketHandlers: Record<string, WebSocketHandlerLike>;
+    private readonly nativeClientPromise;
+    constructor(app: SpikardApp);
+    get(path: string, headers?: Record<string, string>): Promise<TestResponse>;
+    delete(path: string, headers?: Record<string, string>): Promise<TestResponse>;
+    head(path: string, headers?: Record<string, string>): Promise<TestResponse>;
+    options(path: string, headers?: Record<string, string>): Promise<TestResponse>;
+    trace(path: string, headers?: Record<string, string>): Promise<TestResponse>;
+    post(path: string, options?: RequestOptions): Promise<TestResponse>;
+    put(path: string, options?: RequestOptions): Promise<TestResponse>;
+    patch(path: string, options?: RequestOptions): Promise<TestResponse>;
+    websocketConnect(path: string): Promise<WebSocketTestConnection>;
+    private responseFromNative;
+    private dispatchWithHeaders;
+    private buildNativeOptions;
+    private buildHeaders;
+    private findRoute;
+    private findWebSocketRoute;
+}
+declare class WebSocketTestConnection {
+    private readonly handler;
+    private readonly pending;
+    private readonly socket;
+    private closed;
+    private constructor();
+    static connect(handler: WebSocketHandlerLike): Promise<WebSocketTestConnection>;
+    sendJson(payload: JsonValue): Promise<void>;
+    sendText(payload: string): Promise<void>;
+    sendBytes(payload: BinaryLike): Promise<void>;
+    receiveJson(): Promise<JsonValue>;
+    receiveText(): Promise<string>;
+    receiveBytes(): Promise<Uint8Array>;
+    close(code?: number, reason?: string): Promise<void>;
+    private dispatchMessage;
+    private shiftMessage;
+    private ensureOpen;
+}
+
+interface JsonSchema {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema | JsonSchema[];
+    enum?: JsonValue[];
+    [key: string]: JsonSchema | JsonSchema[] | JsonValue | JsonValue[] | string | number | boolean | undefined;
+}
+interface CorsConfig {
+    allow_origin?: string | string[];
+    allow_methods?: string[];
+    allow_headers?: string[];
+    allow_credentials?: boolean;
+    max_age?: number;
+}
+interface FileParam {
+    name: string;
+    required?: boolean;
+    max_size?: number;
+    allowed_types?: string[];
+}
+interface RouteMetadata {
+    method: string;
+    path: string;
+    handler_name: string;
+    handler_dependencies?: string[];
+    request_schema?: JsonSchema;
+    response_schema?: JsonSchema;
+    parameter_schema?: JsonSchema;
+    file_params?: FileParam[];
+    is_async: boolean;
+    cors?: CorsConfig;
+}
+interface SpikardApp {
+    routes: RouteMetadata[];
+    handlers: Record<string, HandlerFunction>;
+    websocketRoutes?: RouteMetadata[];
+    websocketHandlers?: Record<string, WebSocketHandlerLike>;
+    config?: ServerConfig;
+    lifecycleHooks?: Partial<LifecycleHooks>;
+    dependencies?: Record<string, unknown>;
+}
+
+export { type ApiKeyConfig, type Base64EncodedBody, type Body, type CompressionConfig, type ContactInfo, type CorsConfig, type FileParam, type HandlerFunction, type HandlerPayload, type HandlerResult, type JsonPrimitive, type JsonRecord, type JsonSchema, type JsonValue, type JwtConfig, type LicenseInfo, type LifecycleHookFunction, type LifecycleHooks, type MaybePromise, type OpenApiConfig, type Path, type Query, QueryDefault, type RateLimitConfig, type Request$1 as Request, type RouteMetadata, type RouteOptions, type SecuritySchemeInfo, type ServerConfig, type ServerInfo, type ServerOptions, Spikard, type SpikardApp, type StaticFilesConfig, StreamingResponse, type StreamingResponseInit, type StructuredHandlerResponse, TestClient, TestResponse, type WebSocketHandler, type WebSocketHandlerLike, type WebSocketServerSocket, background, createFetchHandler, del, get, patch, post, put, route, runServer };