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

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

@@ -0,0 +1,48 @@
+import { Common, SDK } from '@rsdoctor/shared/types';
+import type { Server } from 'http';
+import WebSocket, { WebSocketServer } from 'ws';
+import { SocketAPILoader } from './api.js';
+interface SocketOptions {
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+    server: Server;
+    port: number;
+    token: string;
+}
+type Subscription = {
+    api: SDK.ServerAPI.API;
+    body: Common.PlainObject | null;
+};
+type SubscriptionRecord = Subscription & {
+    count: number;
+};
+type ClientMessage = {
+    type?: string;
+    id?: string;
+    api?: SDK.ServerAPI.API;
+    body?: Common.PlainObject | null;
+};
+export declare class Socket {
+    protected options: SocketOptions;
+    protected server?: WebSocketServer;
+    protected clients: Set<WebSocket>;
+    protected loader: SocketAPILoader;
+    protected map: Map<string, SubscriptionRecord>;
+    protected clientSubscriptions: Map<WebSocket, Set<string>>;
+    constructor(options: SocketOptions);
+    bootstrap(): void;
+    attachClient(client: WebSocket): void;
+    handleClientMessage(raw: string, client?: WebSocket): Promise<void>;
+    protected handleAPIRequestMessage(message: ClientMessage, client?: WebSocket): Promise<void>;
+    getSubscriptions(): Subscription[];
+    protected saveRequestToMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null, client?: WebSocket): void;
+    protected removeRequestFromMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null, client?: WebSocket): void;
+    protected removeClientSubscriptions(client: WebSocket): void;
+    protected removeSubscriptionKey(key: string): void;
+    protected getSubscriptionKey(api: SDK.ServerAPI.API, body: Common.PlainObject | null): string;
+    protected getAPIResponse<T extends SDK.ServerAPI.API>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>): Promise<SDK.ServerAPI.SocketResponseType<SDK.ServerAPI.API>>;
+    protected timer: NodeJS.Immediate | undefined;
+    broadcast(): Promise<void>;
+    sendAPIData<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, payload: SDK.ServerAPI.SocketResponseType<T>): void;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,166 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import ws, { WebSocketServer } from "ws";
+import { SocketAPILoader } from "./api.js";
+import { isAllowedRequestHost } from "../security.js";
+function isAllowedSocketToken(url, token) {
+    if (!url) return false;
+    return new URL(url, 'http://localhost').searchParams.get('token') === token;
+}
+class Socket {
+    bootstrap() {
+        this.server = new WebSocketServer({
+            server: this.options.server,
+            verifyClient: ({ req })=>{
+                const host = req.headers.host || req.headers[':authority'];
+                return isAllowedRequestHost(host) && isAllowedSocketToken(req.url, this.options.token);
+            }
+        });
+        this.server.on('connection', (client)=>{
+            this.attachClient(client);
+        });
+    }
+    attachClient(client) {
+        this.clients.add(client);
+        if ('function' == typeof client.on) {
+            client.on('message', (message)=>{
+                this.handleClientMessage(message.toString(), client);
+            });
+            client.on('close', ()=>{
+                this.clients.delete(client);
+                this.removeClientSubscriptions(client);
+            });
+        }
+    }
+    async handleClientMessage(raw, client) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        } catch  {
+            return;
+        }
+        if (!message.api || !Object.values(SDK.ServerAPI.API).includes(message.api)) return;
+        if ('request' === message.type) return void await this.handleAPIRequestMessage(message, client);
+        if ('subscribe' === message.type) return void this.saveRequestToMap(message.api, message.body ?? null, client);
+        if ('unsubscribe' === message.type) this.removeRequestFromMap(message.api, message.body ?? null, client);
+    }
+    async handleAPIRequestMessage(message, client) {
+        if (!message.id || !client || client.readyState !== ws.OPEN) return;
+        try {
+            const response = await this.getAPIResponse(message.api, message.body);
+            client.send(JSON.stringify({
+                type: 'response',
+                id: message.id,
+                payload: response.res
+            }));
+        } catch (err) {
+            client.send(JSON.stringify({
+                type: 'response',
+                id: message.id,
+                error: err instanceof Error ? err.message : String(err)
+            }));
+        }
+    }
+    getSubscriptions() {
+        return [
+            ...this.map.values()
+        ].map(({ api, body })=>({
+                api,
+                body
+            }));
+    }
+    saveRequestToMap(api, body = null, client) {
+        const key = this.getSubscriptionKey(api, body);
+        if (client) {
+            if (!this.clientSubscriptions.has(client)) this.clientSubscriptions.set(client, new Set());
+            const subscriptions = this.clientSubscriptions.get(client);
+            if (subscriptions.has(key)) return;
+            subscriptions.add(key);
+        }
+        const record = this.map.get(key);
+        if (record) {
+            record.count += 1;
+            return;
+        }
+        this.map.set(key, {
+            api,
+            body,
+            count: 1
+        });
+    }
+    removeRequestFromMap(api, body = null, client) {
+        const key = this.getSubscriptionKey(api, body);
+        if (client) {
+            const subscriptions = this.clientSubscriptions.get(client);
+            if (!subscriptions?.has(key)) return;
+            subscriptions.delete(key);
+            if (0 === subscriptions.size) this.clientSubscriptions.delete(client);
+        }
+        this.removeSubscriptionKey(key);
+    }
+    removeClientSubscriptions(client) {
+        const subscriptions = this.clientSubscriptions.get(client);
+        if (!subscriptions) return;
+        subscriptions.forEach((key)=>this.removeSubscriptionKey(key));
+        this.clientSubscriptions.delete(client);
+    }
+    removeSubscriptionKey(key) {
+        const record = this.map.get(key);
+        if (!record) return;
+        record.count -= 1;
+        if (record.count <= 0) this.map.delete(key);
+    }
+    getSubscriptionKey(api, body) {
+        return `${api}:${JSON.stringify(body ?? null)}`;
+    }
+    async getAPIResponse(api, body) {
+        const data = await this.loader.loadAPIData(api, body);
+        const response = {
+            req: {
+                api,
+                body
+            },
+            res: data
+        };
+        return response;
+    }
+    async broadcast() {
+        clearImmediate(this.timer);
+        this.timer = setImmediate(async ()=>{
+            const promises = [];
+            this.map.forEach(({ api, body })=>{
+                promises.push((async ()=>{
+                    const res = await this.getAPIResponse(api, body);
+                    this.sendAPIData(api, res);
+                })());
+            });
+            await Promise.all(promises);
+        });
+    }
+    sendAPIData(api, payload) {
+        const message = JSON.stringify({
+            api,
+            payload
+        });
+        this.clients.forEach((client)=>{
+            if (client.readyState === ws.OPEN) client.send(message);
+        });
+    }
+    dispose() {
+        this.clients.forEach((client)=>{
+            client.close();
+        });
+        this.clients.clear();
+        this.server?.close();
+    }
+    constructor(options){
+        this.options = options;
+        this.clients = new Set();
+        this.map = new Map();
+        this.clientSubscriptions = new Map();
+        this.loader = new SocketAPILoader({
+            sdk: options.sdk
+        });
+    }
+}
+export { Socket };

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

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+export declare function getDataByPagination<T>(data: T[], pagination: SDK.ServerAPI.PaginationRequest): {
+    data: T[];
+    pagination: SDK.ServerAPI.PaginationResponse;
+};
+export declare function getLocalIpAddress(): string;

package/dist/sdk/server/utils.js

@@ -0,0 +1,19 @@
+import "node:module";
+import os from "os";
+function getDataByPagination(data, pagination) {
+    const { page = 1, pageSize = 1000 } = pagination;
+    return {
+        data: data.slice((page - 1) * pageSize, page * pageSize),
+        pagination: {
+            page,
+            pageSize,
+            hasNextPage: page <= 0 ? false : page * pageSize < data.length
+        }
+    };
+}
+function getLocalIpAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const iface of Object.values(interfaces))for (const alias of iface)if ('IPv4' === alias.family && !alias.internal) return alias.address;
+    return '127.0.0.1';
+}
+export { getDataByPagination, getLocalIpAddress };

package/dist/sdk/utils/base.d.ts

@@ -0,0 +1 @@
+export declare function findRoot(startDir?: string): string | null;

package/dist/sdk/utils/base.js

@@ -0,0 +1,22 @@
+import "node:module";
+import path from "path";
+import fs from "fs";
+function findRoot(startDir = process.cwd()) {
+    let dir = startDir;
+    let firstPkgDir = null;
+    while(dir !== path.parse(dir).root){
+        if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml'))) return dir;
+        if (fs.existsSync(path.join(dir, 'yarn.lock'))) return dir;
+        if (fs.existsSync(path.join(dir, 'lerna.json'))) return dir;
+        const pkgPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            if (!firstPkgDir) firstPkgDir = dir;
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.workspaces) return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    if (firstPkgDir) return firstPkgDir;
+    return null;
+}
+export { findRoot };

package/dist/sdk/utils/constant.d.ts

@@ -0,0 +1 @@
+export declare const CLOUD_DIR: string;

package/dist/sdk/utils/constant.js

@@ -0,0 +1,4 @@
+import "node:module";
+import dayjs from "dayjs";
+const CLOUD_DIR = `rsdoctor/manifests/${dayjs().format('YYYYMMDD')}`;
+export { CLOUD_DIR };

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

@@ -0,0 +1,3 @@
+export * from './constant.js';
+export * from './base.js';
+export * from './upload.js';

package/dist/sdk/utils/index.js

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "./constant.js";
+export * from "./base.js";
+export * from "./upload.js";

package/dist/sdk/utils/openBrowser.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Reads the BROWSER environment variable and decides what to do with it.
+ */
+export declare function openBrowser(url: string, needEncodeURI?: boolean): Promise<boolean | undefined>;

package/dist/sdk/utils/openBrowser.js

@@ -0,0 +1,53 @@
+import "node:module";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "../../logger.js";
+import { join } from "node:path";
+const execAsync = promisify(exec);
+const supportedChromiumBrowsers = [
+    'Google Chrome Canary',
+    'Google Chrome Dev',
+    'Google Chrome Beta',
+    'Google Chrome',
+    'Microsoft Edge',
+    'Brave Browser',
+    'Vivaldi',
+    'Chromium'
+];
+const getTargetBrowser = async ()=>{
+    let targetBrowser = process.env.BROWSER;
+    if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+        const { stdout: ps } = await execAsync('ps cax');
+        targetBrowser = supportedChromiumBrowsers.find((b)=>ps.includes(b));
+    }
+    return targetBrowser;
+};
+const openWithDefaultBrowser = async (url)=>{
+    try {
+        const { default: open } = await import("open");
+        await open(url);
+        return true;
+    } catch (err) {
+        logger.error('Failed to open Rsdoctor URL.');
+        logger.error(err);
+        return false;
+    }
+};
+async function openBrowser(url, needEncodeURI = true) {
+    const shouldTryOpenChromeWithAppleScript = 'darwin' === process.platform;
+    if (shouldTryOpenChromeWithAppleScript) try {
+        const targetBrowser = await getTargetBrowser();
+        if (targetBrowser) {
+            await execAsync(`osascript openChrome.applescript "${needEncodeURI ? encodeURI(url) : url}" "${targetBrowser}"`, {
+                cwd: join(__dirname, '../static')
+            });
+            return true;
+        }
+        logger.debug('Failed to find the target browser.');
+    } catch (err) {
+        logger.debug("Failed to open Rsdoctor URL with apple script.");
+        logger.debug(err);
+    }
+    return openWithDefaultBrowser(url);
+}
+export { openBrowser };

package/dist/sdk/utils/upload.d.ts

@@ -0,0 +1,2 @@
+import { DataWithUrl } from '../sdk/types.js';
+export declare const transformDataUrls: (d: DataWithUrl[]) => Record<string, string[] | string>;

package/dist/sdk/utils/upload.js

@@ -0,0 +1,6 @@
+import "node:module";
+const transformDataUrls = (d)=>d.reduce((t, item)=>{
+        t[item.name] = Array.isArray(item.files) ? item.files.map((e)=>e.path).concat(t[item.name] || []) : item.files;
+        return t;
+    }, {});
+export { transformDataUrls };

package/dist/sdk.d.ts

@@ -0,0 +1 @@
+export * from './sdk/index.js';

package/dist/sdk.js

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./sdk/index.js";

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './chunks.js';
 export * from './rules.js';
 export * from './loader.js';
 export * from './plugin.js';

package/dist/types/index.js

@@ -1,5 +1,4 @@
 import "node:module";
-export * from "./chunks.js";
 export * from "./rules.js";
 export * from "./loader.js";
 export * from "./plugin.js";

package/dist/types/loader.d.ts

@@ -1,4 +1,4 @@
-import { Loader } from '@rsdoctor/utils/common';
+import { Loader } from '../common/index.js';
 export interface ProxyLoaderInternalOptions {
     cwd: string;
     /**

package/dist/types/plugin.d.ts

@@ -1,6 +1,7 @@
-import type { RsdoctorPrimarySDK } from '@rsdoctor/sdk';
-import type { Linter, Linter as LinterType, Plugin, SDK } from '@rsdoctor/types';
-export interface RsdoctorMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<Plugin.RsdoctorRspackPluginOptions<Rules>, 'sdkInstance'>, Pick<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'stage'> {
+import type { Linter, Linter as LinterType, Plugin, SDK } from '@rsdoctor/shared/types';
+export interface RsdoctorMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<Plugin.RsdoctorRspackPluginOptions<Rules>, 'sdkInstance'>, Pick<{
+    stage?: number;
+}, 'stage'> {
     /**
      * name of builder
      */
@@ -24,28 +25,6 @@ export interface RsdoctorPluginInstance<T extends Plugin.BaseCompiler, Rules ext
     modulesGraph: SDK.ModuleGraphInstance;
     ensureModulesChunksGraphApplied(compiler: T): void;
 }
-export interface RsdoctorRspackPluginInstance<Rules extends LinterType.ExtendRuleData[] = []> extends RsdoctorPluginInstance<Plugin.BaseCompilerType<'rspack'>, Rules> {
-}
-export interface NativePluginConfig {
-    moduleGraph?: boolean;
-    chunkGraph?: boolean;
-}
-export interface RsdoctorRspackPluginExperiments {
-    /**
-     * Whether to enable the native plugin to improve the performance.
-     * @default true
-     */
-    enableNativePlugin?: boolean;
-}
-export interface RsdoctorRspackPluginExperimentsNormalized {
-    enableNativePlugin?: NativePluginConfig;
-}
-export interface RsdoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> extends Plugin.RsdoctorRspackPluginOptions<Rules> {
-    /**
-     * The experiments of the Rsdoctor Rspack plugin.
-     */
-    experiments?: RsdoctorRspackPluginExperiments;
-}
-export type RsdoctorRspackPluginOptionsNormalized<Rules extends Linter.ExtendRuleData[]> = Plugin.RsdoctorPluginOptionsNormalized<Rules> & {
-    experiments?: RsdoctorRspackPluginExperimentsNormalized;
-};
+export type RsdoctorRspackPluginInstance<Rules extends LinterType.ExtendRuleData[] = []> = RsdoctorPluginInstance<Plugin.BaseCompilerType<'rspack'>, Rules>;
+export type RsdoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> = Plugin.RsdoctorRspackPluginOptions<Rules>;
+export type RsdoctorRspackPluginOptionsNormalized<Rules extends Linter.ExtendRuleData[]> = Plugin.RsdoctorPluginOptionsNormalized<Rules>;