@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/sdk/server/apis/renderer.js

@@ -0,0 +1,33 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import node_fs from "node:fs";
+import { createRequire } from "module";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+const renderer_require = createRequire(import.meta.url);
+class RendererAPI extends BaseAPI {
+    async entryHtml() {
+        const { server, res } = this.ctx;
+        const clientHtmlPath = server.innerClientPath ? server.innerClientPath : renderer_require.resolve('@rsdoctor/client');
+        const clientHtml = node_fs.readFileSync(clientHtmlPath, 'utf-8');
+        res.setHeader('Content-Type', 'text/html');
+        res.setHeader('Cache-Control', 'no-store');
+        return clientHtml;
+    }
+}
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.EntryHtml),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], RendererAPI.prototype, "entryHtml", null);
+export { RendererAPI };

package/dist/sdk/server/apis/resolver.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class ResolverAPI extends BaseAPI {
+    getResolverFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileTree>>;
+    getResolverFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>>;
+}

package/dist/sdk/server/apis/resolver.js

@@ -0,0 +1,38 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class ResolverAPI extends BaseAPI {
+    async getResolverFileTree() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetResolverFileTree);
+    }
+    async getResolverFileDetails() {
+        const { req } = this.ctx;
+        const { filepath } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetResolverFileDetails, {
+            filepath
+        });
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetResolverFileTree),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ResolverAPI.prototype, "getResolverFileTree", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetResolverFileDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], ResolverAPI.prototype, "getResolverFileDetails", null);
+export { ResolverAPI };

package/dist/sdk/server/client.d.ts

@@ -0,0 +1,3 @@
+export declare const resolveClientHtmlPath: (innerClientPath?: string) => string;
+export declare const resolveClientDistPath: (innerClientPath?: string) => string;
+export declare const resolveClientDiffHtmlPath: (innerClientPath?: string) => string;

package/dist/sdk/server/client.js

@@ -0,0 +1,8 @@
+import "node:module";
+import path from "path";
+import { createRequire } from "module";
+const client_require = createRequire(import.meta.url);
+const resolveClientHtmlPath = (innerClientPath)=>innerClientPath || client_require.resolve('@rsdoctor/client');
+const resolveClientDistPath = (innerClientPath)=>path.dirname(resolveClientHtmlPath(innerClientPath));
+const resolveClientDiffHtmlPath = (innerClientPath)=>path.resolve(resolveClientDistPath(innerClientPath), 'diff.html');
+export { resolveClientDiffHtmlPath, resolveClientDistPath, resolveClientHtmlPath };

package/dist/sdk/server/fakeServer.d.ts

@@ -0,0 +1,9 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { RsdoctorServer } from './index.js';
+export declare class RsdoctorFakeServer extends RsdoctorServer {
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number);
+    bootstrap(): Promise<void>;
+    openClientPage(): Promise<void>;
+    dispose: () => Promise<void>;
+}

package/dist/sdk/server/fakeServer.js

@@ -0,0 +1,12 @@
+import "node:module";
+import { Server } from "../../build-utils/index.js";
+import { RsdoctorServer } from "./index.js";
+class RsdoctorFakeServer extends RsdoctorServer {
+    async bootstrap() {}
+    async openClientPage() {}
+    constructor(sdk, port = Server.defaultPort){
+        super(sdk, port), this.sdk = sdk, this.dispose = async ()=>{};
+        this.sdk = sdk;
+    }
+}
+export { RsdoctorFakeServer };

package/dist/sdk/server/index.d.ts

@@ -0,0 +1,44 @@
+import { Common, SDK, Thirdparty, Client } from '@rsdoctor/shared/types';
+export * from './utils.js';
+export type ISocketType = {
+    port: number;
+    socketUrl: string;
+    token: string;
+};
+export type RsdoctorServerOptions = {
+    innerClientPath?: string;
+    printServerUrl?: boolean;
+    cors?: SDK.RsdoctorServerConfig['cors'];
+};
+export declare class RsdoctorServer implements SDK.RsdoctorServerInstance {
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    private _server;
+    port: number;
+    private _socket?;
+    private disposed;
+    private _router;
+    private _innerClientPath;
+    private _printServerUrl;
+    private _cors;
+    private _socketToken;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number, config?: RsdoctorServerOptions);
+    get app(): SDK.RsdoctorServerInstance['app'];
+    get host(): string;
+    get origin(): string;
+    get socketUrl(): ISocketType;
+    get innerClientPath(): string;
+    private createInnerServer;
+    private resolveCorsOptions;
+    bootstrap(): Promise<void>;
+    protected wrapNextHandleFunction(method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): Thirdparty.connect.NextHandleFunction;
+    proxy(api: SDK.ServerAPI.API, method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): void;
+    get: SDK.RsdoctorServerInstance['get'];
+    post: SDK.RsdoctorServerInstance['post'];
+    getClientUrl(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): string;
+    getClientUrl(route?: 'homepage'): string;
+    openClientPage(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): Promise<void>;
+    openClientPage(route?: 'homepage'): Promise<void>;
+    sendAPIDataToClient<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+    broadcast(): Promise<void>;
+    dispose: (exitCode?: number) => Promise<void>;
+}

package/dist/sdk/server/index.js

@@ -0,0 +1,292 @@
+import "node:module";
+import { Client, SDK } from "@rsdoctor/shared/types";
+import { Server } from "../../build-utils/index.js";
+import sirv from "sirv";
+import { Bundle, GlobalConfig } from "../../common/index.js";
+import assert from "assert";
+import cors from "cors";
+import { PassThrough } from "stream";
+import { Socket } from "./socket/index.js";
+import { Router } from "./router.js";
+import * as __rspack_external__apis_index_js_275823d6 from "./apis/index.js";
+import { chalk, logger } from "../../logger.js";
+import { openBrowser } from "../utils/openBrowser.js";
+import path from "path";
+import { createRequire } from "module";
+import { randomBytes } from "crypto";
+import { jsonBodyParser } from "./json-body.js";
+import { DEFAULT_ALLOWED_CORS_ORIGINS, isAllowedCorsRequest, isAllowedOpenInEditorToken, isAllowedRequestHost } from "./security.js";
+export * from "./utils.js";
+const server_require = createRequire(import.meta.url);
+const OPEN_IN_EDITOR_PATH = '/__open-in-editor';
+const LISTEN_RETRY_LIMIT = 10;
+const OPEN_IN_EDITOR_EDITORS = new Set(SDK.OPEN_IN_EDITOR_EDITORS);
+const DEFAULT_JSON_BODY_LIMIT = '10mb';
+const LARGE_JSON_BODY_LIMIT = '500mb';
+const LARGE_JSON_BODY_ROUTES = new Set([
+    SDK.ServerAPI.API.ReportLoader,
+    SDK.ServerAPI.API.ReportSourceMap
+]);
+function isAddressInUseError(error) {
+    return 'EADDRINUSE' === error.code;
+}
+function isAllowedOpenInEditorEditor(editor) {
+    return 'string' == typeof editor && OPEN_IN_EDITOR_EDITORS.has(editor);
+}
+class RsdoctorServer {
+    get app() {
+        return this._server.app;
+    }
+    get host() {
+        return Server.defaultHost;
+    }
+    get origin() {
+        return `http://${this.host}:${this.port}`;
+    }
+    get socketUrl() {
+        return {
+            port: this.port,
+            socketUrl: `ws://localhost:${this.port}?token=${this._socketToken}`,
+            token: this._socketToken
+        };
+    }
+    get innerClientPath() {
+        return this._innerClientPath;
+    }
+    async createInnerServer() {
+        let expectedPort = this.port;
+        let lastError;
+        for(let retry = 0; retry < LISTEN_RETRY_LIMIT; retry++){
+            const port = Server.getPortSync(expectedPort, this.host);
+            try {
+                return {
+                    port,
+                    server: await Server.createServer(port, this.host)
+                };
+            } catch (error) {
+                if (!isAddressInUseError(error)) throw error;
+                lastError = error;
+                expectedPort = port + 1;
+            }
+        }
+        throw lastError;
+    }
+    resolveCorsOptions() {
+        if (false === this._cors) return false;
+        if (true === this._cors) return {};
+        if (void 0 === this._cors) return {
+            origin: DEFAULT_ALLOWED_CORS_ORIGINS
+        };
+        return {
+            ...this._cors,
+            origin: void 0 === this._cors.origin ? DEFAULT_ALLOWED_CORS_ORIGINS : this._cors.origin
+        };
+    }
+    async bootstrap() {
+        if (!this.disposed) return;
+        const { port, server } = await this.createInnerServer();
+        const corsOptions = this.resolveCorsOptions();
+        this.port = port;
+        this._server = server;
+        this._socket = new Socket({
+            sdk: this.sdk,
+            server: this._server.server,
+            port: this.port,
+            token: this._socketToken
+        });
+        await this._socket.bootstrap();
+        GlobalConfig.writeMcpPort(this.port, this.sdk.name);
+        logger.debug(`Successfully wrote mcp.json for ${chalk.cyan(this.sdk.name)} builder`);
+        this.disposed = false;
+        this.app.use((req, res, next)=>{
+            const host = req.headers.host || req.headers[':authority'];
+            if (!isAllowedRequestHost(host)) {
+                res.statusCode = 403;
+                res.end();
+                return;
+            }
+            next();
+        });
+        if (false !== corsOptions && corsOptions.origin === DEFAULT_ALLOWED_CORS_ORIGINS) this.app.use((req, res, next)=>{
+            const host = req.headers.host || req.headers[':authority'];
+            if (!isAllowedCorsRequest(req.headers.origin, host)) {
+                res.statusCode = 403;
+                res.end();
+                return;
+            }
+            next();
+        });
+        if (false !== corsOptions) this.app.use(cors(corsOptions));
+        this.app.use(jsonBodyParser({
+            limit: (req)=>{
+                const pathname = new URL(req.url || '/', 'http://localhost').pathname;
+                return LARGE_JSON_BODY_ROUTES.has(pathname) ? LARGE_JSON_BODY_LIMIT : DEFAULT_JSON_BODY_LIMIT;
+            }
+        }));
+        await this._router.setup();
+        const clientHtmlPath = this._innerClientPath ? this._innerClientPath : server_require.resolve('@rsdoctor/client');
+        const clientDistPath = path.resolve(clientHtmlPath, '..');
+        this.app.use(sirv(clientDistPath, {
+            dev: true
+        }));
+        this.app.use(OPEN_IN_EDITOR_PATH, (req, res, next)=>{
+            if ('GET' !== req.method && 'HEAD' !== req.method) return next();
+            const url = new URL(req.url || '', "http://localhost");
+            const file = url.searchParams.get('file');
+            const editor = url.searchParams.get('editor');
+            const token = url.searchParams.get('token');
+            if (!isAllowedOpenInEditorToken(token, this._socketToken)) {
+                res.statusCode = 403;
+                res.end();
+                return;
+            }
+            if (!file) {
+                res.statusCode = 400;
+                res.end('Missing file parameter');
+                return;
+            }
+            if (!isAllowedOpenInEditorEditor(editor)) {
+                res.statusCode = 400;
+                res.end('Unsupported editor parameter');
+                return;
+            }
+            try {
+                const launch = server_require('launch-editor');
+                let responded = false;
+                const safeEnd = (code, body)=>{
+                    if (responded) return;
+                    responded = true;
+                    res.statusCode = code;
+                    res.end(body);
+                };
+                launch(file, editor, (_fileName, errorMessage)=>{
+                    if (errorMessage) safeEnd(500, errorMessage);
+                });
+                setTimeout(()=>{
+                    safeEnd(200, '');
+                }, 200);
+            } catch (err) {
+                if (!res.writableEnded) {
+                    res.statusCode = 500;
+                    res.end(err.message);
+                }
+            }
+        });
+        process.once('exit', ()=>this.dispose());
+        process.once('SIGINT', ()=>this.dispose(0));
+        process.once('SIGTERM', ()=>this.dispose(0));
+        process.once('unhandledRejection', (reason)=>{
+            console.error('Unhandled promise rejection:', reason);
+            this.dispose(1);
+        });
+        process.once('uncaughtException', (err, origin)=>{
+            console.error('Uncaught exception:', err);
+            if (origin) console.error('Exception origin:', origin);
+            this.dispose(1);
+        });
+    }
+    wrapNextHandleFunction(method, cb) {
+        return async (req, res, next)=>{
+            const m = req.method?.toUpperCase();
+            if (m === method) {
+                try {
+                    const body = await cb(req, res, next);
+                    res.statusCode = 200;
+                    if (Buffer.isBuffer(body)) {
+                        res.setHeader('Content-Length', body.byteLength);
+                        const ps = new PassThrough();
+                        ps.write(body);
+                        ps.end();
+                        ps.pipe(res);
+                    } else if (body && 'object' == typeof body) {
+                        res.writeHead(200, {
+                            'Content-Type': 'application/json;utf-8'
+                        });
+                        res.write(JSON.stringify(body));
+                        res.end();
+                    } else res.writeHead(200).end(body);
+                } catch (error) {
+                    res.statusCode = 500;
+                    res.end(error.message);
+                    return next(error);
+                }
+                return;
+            }
+            await next();
+        };
+    }
+    proxy(api, method, cb) {
+        let idx = this.app.stack.findIndex((e)=>e.route === api);
+        if (-1 === idx) idx = this.app.stack.length - 1;
+        this.app.stack.splice(idx, 0, {
+            route: api,
+            handle: this.wrapNextHandleFunction(method, cb)
+        });
+    }
+    getClientUrl(route = 'homepage', ...args) {
+        const relativeUrl = SDK.ServerAPI.API.EntryHtml;
+        switch(route){
+            case Client.RsdoctorClientRoutes.BundleDiff:
+                {
+                    const [baseline, current] = args;
+                    const qs = Bundle.getBundleDiffPageQueryString([
+                        baseline,
+                        current
+                    ]);
+                    return `${relativeUrl}${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
+                }
+            default:
+                return relativeUrl;
+        }
+    }
+    async openClientPage(...args) {
+        const relativeUrl = this.getClientUrl(...args);
+        const needEncodeURI = args[0] === Client.RsdoctorClientRoutes.BundleDiff;
+        const url = `http://${this.host}:${this.port}${relativeUrl}`;
+        const localhostUrl = `http://localhost:${this.port}${relativeUrl}`;
+        await openBrowser(localhostUrl, !needEncodeURI);
+        if (this._printServerUrl) logger.info(`${chalk.green(`${this.sdk.name} compiler's`)} analyzer running on: ${chalk.cyan(url)}`);
+    }
+    sendAPIDataToClient(api, msg) {
+        this._socket?.sendAPIData(api, msg);
+    }
+    async broadcast() {
+        await this._socket?.broadcast();
+    }
+    constructor(sdk, port = Server.defaultPort, config){
+        this.sdk = sdk;
+        this.disposed = true;
+        this._socketToken = randomBytes(16).toString('hex');
+        this.get = (route, cb)=>{
+            const { app } = this;
+            app.use(route, this.wrapNextHandleFunction('GET', cb));
+            return app;
+        };
+        this.post = (route, cb)=>{
+            const { app } = this;
+            app.use(route, this.wrapNextHandleFunction('POST', cb));
+            return app;
+        };
+        this.dispose = async (exitCode)=>{
+            if (this.disposed) {
+                if (void 0 !== exitCode) process.exit(exitCode);
+                return;
+            }
+            this.disposed = true;
+            if (this._server) await this._server.close();
+            if (this._socket) this._socket.dispose();
+            if (void 0 !== exitCode) process.exit(exitCode);
+        };
+        assert('number' == typeof port);
+        this.port = port;
+        this._router = new Router({
+            sdk,
+            server: this,
+            apis: Object.values(__rspack_external__apis_index_js_275823d6)
+        });
+        this._innerClientPath = config?.innerClientPath || '';
+        this._printServerUrl = config?.printServerUrl ?? true;
+        this._cors = config?.cors;
+    }
+}
+export { RsdoctorServer };

package/dist/sdk/server/json-body.d.ts

@@ -0,0 +1,6 @@
+import type { Thirdparty } from '@rsdoctor/shared/types';
+interface JsonBodyParserOptions {
+    limit?: number | string | ((req: Thirdparty.connect.IncomingMessage) => number | string);
+}
+export declare function jsonBodyParser(options?: JsonBodyParserOptions): Thirdparty.connect.NextHandleFunction;
+export {};

package/dist/sdk/server/json-body.js

@@ -0,0 +1,150 @@
+import "node:module";
+import raw_body from "raw-body";
+import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+const JSON_CONTENT_TYPE = 'application/json';
+const DEFAULT_CHARSET = 'utf-8';
+function createHttpError(status, message, type) {
+    return Object.assign(new Error(message), {
+        status,
+        statusCode: status,
+        type
+    });
+}
+function hasBody(req) {
+    return void 0 !== req.headers['transfer-encoding'] || !Number.isNaN(Number(req.headers['content-length']));
+}
+function getContentType(req) {
+    const contentType = req.headers['content-type'];
+    if ('string' != typeof contentType) return;
+    return contentType;
+}
+function shouldParse(req) {
+    const contentType = getContentType(req);
+    if (!contentType) return false;
+    return contentType.split(';', 1)[0].trim().toLowerCase() === JSON_CONTENT_TYPE;
+}
+function getCharset(req) {
+    const contentType = getContentType(req);
+    const match = contentType?.match(/(?:^|;)\s*charset\s*=\s*(?:"([^"]+)"|([^;\s]+))/i);
+    return (match?.[1] || match?.[2] || DEFAULT_CHARSET).toLowerCase();
+}
+function getContentStream(req) {
+    const contentEncoding = req.headers['content-encoding'];
+    const encoding = 'string' == typeof contentEncoding ? contentEncoding.toLowerCase() : 'identity';
+    if ('identity' === encoding) return {
+        stream: req,
+        length: req.headers['content-length']
+    };
+    let stream;
+    switch(encoding){
+        case 'gzip':
+            stream = createGunzip();
+            break;
+        case 'deflate':
+            stream = createInflate();
+            break;
+        case 'br':
+            stream = createBrotliDecompress();
+            break;
+        default:
+            throw createHttpError(415, `unsupported content encoding "${encoding}"`, 'encoding.unsupported');
+    }
+    const cleanup = ()=>{
+        req.removeListener('aborted', onAborted);
+        req.removeListener('close', onClose);
+        req.removeListener('error', onError);
+        stream.removeListener('close', cleanup);
+    };
+    const destroy = (error)=>{
+        if (!stream.destroyed) stream.destroy(error);
+    };
+    const onAborted = ()=>{
+        destroy(createHttpError(400, 'request aborted', 'request.aborted'));
+    };
+    const onClose = ()=>{
+        if (false === req.complete) onAborted();
+    };
+    const onError = (error)=>{
+        destroy(error);
+    };
+    req.once('aborted', onAborted);
+    req.once('close', onClose);
+    req.once('error', onError);
+    stream.once('close', cleanup);
+    req.pipe(stream);
+    return {
+        stream,
+        cleanup,
+        decompressor: stream
+    };
+}
+function parseJson(body) {
+    if (0 === body.length) return {};
+    let value;
+    try {
+        value = JSON.parse(body);
+    } catch (error) {
+        throw createHttpError(400, error.message, 'entity.parse.failed');
+    }
+    if (null === value || 'object' != typeof value) throw createHttpError(400, 'JSON body must be an object or array', 'entity.parse.failed');
+    return value;
+}
+function normalizeReadError(error, charset) {
+    if (error instanceof Error && 'status' in error && 'number' == typeof error.status) {
+        if (charset && 'type' in error && 'encoding.unsupported' === error.type) return createHttpError(415, `unsupported charset "${charset.toUpperCase()}"`, 'charset.unsupported');
+        return error;
+    }
+    return createHttpError(400, error instanceof Error ? error.message : 'failed to read request body', 'request.invalid');
+}
+function jsonBodyParser(options = {}) {
+    return (req, _res, next)=>{
+        const request = req;
+        if (!('body' in request)) request.body = void 0;
+        if (!hasBody(req) || !shouldParse(req)) return void next();
+        const charset = getCharset(req);
+        if (!charset.startsWith('utf-')) {
+            req.resume();
+            next(createHttpError(415, `unsupported charset "${charset.toUpperCase()}"`, 'charset.unsupported'));
+            return;
+        }
+        let content;
+        try {
+            content = getContentStream(req);
+        } catch (error) {
+            req.resume();
+            next(normalizeReadError(error));
+            return;
+        }
+        const handleError = (error)=>{
+            content.cleanup?.();
+            if (content.decompressor) {
+                req.unpipe(content.decompressor);
+                content.decompressor.destroy();
+            }
+            req.resume();
+            next(normalizeReadError(error, charset));
+        };
+        let limit;
+        try {
+            limit = 'function' == typeof options.limit ? options.limit(req) : options.limit;
+        } catch (error) {
+            handleError(error);
+            return;
+        }
+        raw_body(content.stream, {
+            encoding: charset,
+            length: content.length,
+            limit
+        }).then((body)=>{
+            try {
+                request.body = parseJson(body);
+            } catch (error) {
+                handleError(error);
+                return;
+            }
+            content.cleanup?.();
+            next();
+        }, handleError);
+    };
+}
+export { jsonBodyParser };

package/dist/sdk/server/router.d.ts

@@ -0,0 +1,24 @@
+import type { ServerResponse } from 'http';
+import { Common, SDK, Thirdparty } from '@rsdoctor/shared/types';
+import { BaseAPI } from './apis/base.js';
+interface RouterOptions {
+    apis: Common.Constructor<typeof BaseAPI>[];
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+    server: SDK.RsdoctorServerInstance;
+}
+export declare class Router {
+    protected options: RouterOptions;
+    static routes: {
+        /**
+         * - `key` is the constructor of object which used to match the API class
+         */
+        get: Map<new (sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance) => BaseAPI, [apiKey: PropertyKey, pathname: string][]>;
+        post: Map<new (sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance) => BaseAPI, [apiKey: PropertyKey, pathname: string][]>;
+    };
+    static get(pathname: string): MethodDecorator;
+    static post(pathname: string): MethodDecorator;
+    constructor(options: RouterOptions);
+    setup(): Promise<void>;
+    wrapAPIFunction<T extends BaseAPI>(api: T, key: PropertyKey): (req: Thirdparty.connect.IncomingMessage, res: ServerResponse) => Promise<unknown>;
+}
+export {};