@rsdoctor/core 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/sdk/server/index.js

@@ -1,292 +0,0 @@
-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.js

@@ -1,150 +0,0 @@
-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.js

@@ -1,83 +0,0 @@
-import "node:module";
-const normalizeAPIKey = (key)=>{
-    if (key && 'object' == typeof key && 'name' in key) return key.name;
-    return key;
-};
-class Router {
-    static get(pathname) {
-        return (target, propertyKey, descriptor)=>{
-            const routes = Router.routes.get;
-            const constructor = target.constructor;
-            if (!routes.has(constructor)) routes.set(constructor, []);
-            routes.get(constructor).push([
-                normalizeAPIKey(propertyKey),
-                pathname
-            ]);
-            return descriptor;
-        };
-    }
-    static post(pathname) {
-        return (target, propertyKey, descriptor)=>{
-            const routes = Router.routes.post;
-            const constructor = target.constructor;
-            if (!routes.has(constructor)) routes.set(constructor, []);
-            routes.get(constructor).push([
-                normalizeAPIKey(propertyKey),
-                pathname
-            ]);
-            return descriptor;
-        };
-    }
-    async setup() {
-        const { apis, sdk, server } = this.options;
-        apis.forEach((API)=>{
-            const obj = new API(sdk, server);
-            Router.routes.get.get(API)?.forEach(([key, pathname])=>{
-                server.get(pathname, this.wrapAPIFunction(obj, key));
-            });
-            Router.routes.post.get(API)?.forEach(([key, pathname])=>{
-                server.post(pathname, this.wrapAPIFunction(obj, key));
-            });
-        });
-    }
-    wrapAPIFunction(api, key) {
-        const { sdk, server } = this.options;
-        return async (req, res)=>{
-            const ctx = {
-                req,
-                res,
-                sdk,
-                server
-            };
-            const trap = new Proxy(api, {
-                get (target, key, receiver) {
-                    switch(key){
-                        case 'ctx':
-                            return ctx;
-                        default:
-                            return Reflect.get(target, key, receiver);
-                    }
-                },
-                set (target, key, value, receiver) {
-                    return Reflect.set(target, key, value, receiver);
-                },
-                defineProperty (target, p, attrs) {
-                    return Reflect.defineProperty(target, p, attrs);
-                }
-            });
-            const fn = api[key];
-            const result = await fn.call(trap, trap);
-            if ('string' == typeof result) return Buffer.from(result, 'utf-8');
-            if (result && 'object' == typeof result) return Buffer.from(JSON.stringify(result), 'utf-8');
-            return result;
-        };
-    }
-    constructor(options){
-        this.options = options;
-    }
-}
-Router.routes = {
-    get: new Map(),
-    post: new Map()
-};
-export { Router };

package/dist/sdk/server/security.js

@@ -1,47 +0,0 @@
-import "node:module";
-import { isIP } from "node:net";
-import { timingSafeEqual } from "node:crypto";
-const DEFAULT_ALLOWED_CORS_ORIGINS = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
-const LOCAL_HOSTNAMES = /^(?:localhost|[^:]+\.localhost)$/;
-function isAllowedRequestOrigin(origin) {
-    if (void 0 === origin) return true;
-    return 'string' == typeof origin && DEFAULT_ALLOWED_CORS_ORIGINS.test(origin);
-}
-function getHostnameFromOrigin(origin) {
-    try {
-        const hostname = new URL(origin).hostname.toLowerCase();
-        return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
-    } catch  {
-        return '';
-    }
-}
-function isIpAddress(hostname) {
-    return 0 !== isIP(hostname);
-}
-function getHostnameFromHost(host) {
-    if (host.startsWith('[')) {
-        const endIndex = host.indexOf(']');
-        return -1 === endIndex ? '' : host.slice(1, endIndex);
-    }
-    return host.split(':')[0];
-}
-function isAllowedRequestHost(host) {
-    if ('string' != typeof host) return false;
-    const hostname = getHostnameFromHost(host).toLowerCase();
-    return LOCAL_HOSTNAMES.test(hostname) || isIpAddress(hostname);
-}
-function isAllowedCorsRequest(origin, host) {
-    if (void 0 === origin) return true;
-    if ('string' != typeof origin || 'string' != typeof host || !isAllowedRequestOrigin(origin)) return false;
-    const originHostname = getHostnameFromOrigin(origin);
-    const hostHostname = getHostnameFromHost(host).toLowerCase();
-    if (originHostname.endsWith('.localhost')) return originHostname === hostHostname;
-    return true;
-}
-function isAllowedOpenInEditorToken(token, expectedToken) {
-    if ('string' != typeof token || !expectedToken) return false;
-    const tokenBuffer = Buffer.from(token);
-    const expectedTokenBuffer = Buffer.from(expectedToken);
-    return tokenBuffer.length === expectedTokenBuffer.length && timingSafeEqual(tokenBuffer, expectedTokenBuffer);
-}
-export { DEFAULT_ALLOWED_CORS_ORIGINS, isAllowedCorsRequest, isAllowedOpenInEditorToken, isAllowedRequestHost, isAllowedRequestOrigin };

package/dist/sdk/server/socket/api.js

@@ -1,22 +0,0 @@
-import "node:module";
-import { Data } from "../../../common/index.js";
-class SocketAPILoader {
-    async loadManifest() {
-        return this.options.sdk.getManifestData();
-    }
-    async loadData(key) {
-        const data = this.options.sdk.getStoreData();
-        const sep = '.';
-        let res = data[key];
-        if (key.includes(sep)) res = key.split(sep).reduce((t, k)=>t[k], data);
-        return res;
-    }
-    get loadAPIData() {
-        return this.dataLoader.loadAPI;
-    }
-    constructor(options){
-        this.options = options;
-        this.dataLoader = new Data.APIDataLoader(this);
-    }
-}
-export { SocketAPILoader };