@rsdoctor/sdk 0.0.2-beta.0

package/dist/esm/sdk/server/apis/data.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class DataAPI extends BaseAPI {
+  async loadDataByKey() {
+    const { req } = this.ctx;
+    const { url } = req;
+    let { key } = req.body;
+    if (!key && url) {
+      const uri = new URL(url, "http://127.0.0.1");
+      key = uri.pathname.replace(
+        /^\//,
+        ""
+      );
+    }
+    const data = await this.loadData(key);
+    return data;
+  }
+  async sendMessageToClient() {
+    const { req, server } = this.ctx;
+    const { api, data } = req.body;
+    await server.sendAPIDataToClient(api, data);
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.LoadDataByKey)
+], DataAPI.prototype, "loadDataByKey", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.SendAPIDataToClient)
+], DataAPI.prototype, "sendMessageToClient", 1);
+export {
+  DataAPI
+};

package/dist/esm/sdk/server/apis/fs.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class FileSystemAPI extends BaseAPI {
+  async applyErrorFix() {
+    const { body } = this.ctx.req;
+    const data = body;
+    await this.ctx.sdk.applyErrorFix(data.id);
+    return "success";
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.ApplyErrorFix)
+], FileSystemAPI.prototype, "applyErrorFix", 1);
+export {
+  FileSystemAPI
+};

package/dist/esm/sdk/server/apis/graph.js

@@ -0,0 +1,95 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class GraphAPI extends BaseAPI {
+  async getAssetsSummary() {
+    const { req } = this.ctx;
+    const { withFileContent } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetAssetsSummary, {
+      withFileContent
+    });
+  }
+  async getModuleGraphForAsset() {
+    const { req } = this.ctx;
+    const { assetPath } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetAssetDetails, {
+      assetPath
+    });
+  }
+  async getChunksByModuleId() {
+    const { req } = this.ctx;
+    const { moduleId } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetChunksByModuleId, {
+      moduleId
+    });
+  }
+  async getModuleDetails() {
+    const { req } = this.ctx;
+    const { moduleId } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleDetails, {
+      moduleId
+    });
+  }
+  async getDependencyByResolvedRequest() {
+    const { req } = this.ctx;
+    const { moduleIds = [] } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModulesByModuleIds, {
+      moduleIds
+    });
+  }
+  async getModuleCodeByModuleId() {
+    const { req } = this.ctx;
+    const { moduleId } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleCodeByModuleId, {
+      moduleId
+    });
+  }
+  async getModuleCodeByModuleIds() {
+    const { req } = this.ctx;
+    const { moduleIds } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleCodeByModuleIds, {
+      moduleIds
+    });
+  }
+  async getEntryModulesSummary() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetEntryPoints);
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetAssetsSummary)
+], GraphAPI.prototype, "getAssetsSummary", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetAssetDetails)
+], GraphAPI.prototype, "getModuleGraphForAsset", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetChunksByModuleId)
+], GraphAPI.prototype, "getChunksByModuleId", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetModuleDetails)
+], GraphAPI.prototype, "getModuleDetails", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetModulesByModuleIds)
+], GraphAPI.prototype, "getDependencyByResolvedRequest", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetModuleCodeByModuleId)
+], GraphAPI.prototype, "getModuleCodeByModuleId", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetModuleCodeByModuleIds)
+], GraphAPI.prototype, "getModuleCodeByModuleIds", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetEntryPoints)
+], GraphAPI.prototype, "getEntryModulesSummary", 1);
+export {
+  GraphAPI
+};

package/dist/esm/sdk/server/apis/index.js

@@ -0,0 +1,9 @@
+export * from "./alerts";
+export * from "./data";
+export * from "./fs";
+export * from "./loader";
+export * from "./graph";
+export * from "./plugin";
+export * from "./project";
+export * from "./renderer";
+export * from "./resolver";

package/dist/esm/sdk/server/apis/loader.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class LoaderAPI extends BaseAPI {
+  async reportLoader() {
+    const { req, sdk } = this.ctx;
+    const { body } = req;
+    sdk.reportLoader(body);
+    return "ok";
+  }
+  async reportSourceMap() {
+    const {
+      req: { body },
+      sdk
+    } = this.ctx;
+    sdk.reportSourceMap(body);
+    return "ok";
+  }
+  async getLoaderNames() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderNames);
+  }
+  async getLoaderChartData() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderChartData);
+  }
+  async getLoaderFileTree() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileTree);
+  }
+  async getLoaderFileDetails() {
+    const { req } = this.ctx;
+    const { path } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileDetails, {
+      path
+    });
+  }
+  async getLoaderFolderStatistics() {
+    const { req } = this.ctx;
+    const { folder } = req.body;
+    return this.dataLoader.loadAPI(
+      SDK.ServerAPI.API.GetLoaderFolderStatistics,
+      { folder }
+    );
+  }
+  async getLoaderFileFirstInput() {
+    const { req } = this.ctx;
+    const { file } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileFirstInput, {
+      file
+    });
+  }
+  async getLoaderFileInputAndOutput() {
+    const { req } = this.ctx;
+    const { file, loader, loaderIndex } = req.body;
+    return this.dataLoader.loadAPI(
+      SDK.ServerAPI.API.GetLoaderFileInputAndOutput,
+      { file, loader, loaderIndex }
+    );
+  }
+  async getTileReportHtml() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetTileReportHtml, {});
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.ReportLoader)
+], LoaderAPI.prototype, "reportLoader", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.ReportSourceMap)
+], LoaderAPI.prototype, "reportSourceMap", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderNames)
+], LoaderAPI.prototype, "getLoaderNames", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderChartData)
+], LoaderAPI.prototype, "getLoaderChartData", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderFileTree)
+], LoaderAPI.prototype, "getLoaderFileTree", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderFileDetails)
+], LoaderAPI.prototype, "getLoaderFileDetails", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderFolderStatistics)
+], LoaderAPI.prototype, "getLoaderFolderStatistics", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderFileFirstInput)
+], LoaderAPI.prototype, "getLoaderFileFirstInput", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetLoaderFileInputAndOutput)
+], LoaderAPI.prototype, "getLoaderFileInputAndOutput", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetTileReportHtml)
+], LoaderAPI.prototype, "getTileReportHtml", 1);
+export {
+  LoaderAPI
+};

package/dist/esm/sdk/server/apis/plugin.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class PluginAPI extends BaseAPI {
+  async getPluginSummary() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPluginSummary);
+  }
+  async getPluginData() {
+    const { req } = this.ctx;
+    const { hooks = [], tapNames = [] } = req.body;
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPluginData, {
+      hooks,
+      tapNames
+    });
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetPluginSummary)
+], PluginAPI.prototype, "getPluginSummary", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetPluginData)
+], PluginAPI.prototype, "getPluginData", 1);
+export {
+  PluginAPI
+};

package/dist/esm/sdk/server/apis/project.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import ip from "ip";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class ProjectAPI extends BaseAPI {
+  async env() {
+    const { server } = this.ctx;
+    return {
+      ip: ip.address(),
+      port: server.port
+    };
+  }
+  async manifest() {
+    const { sdk } = this.ctx;
+    const data = sdk.getManifestData();
+    return JSON.stringify(data);
+  }
+  async getProjectInfo() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetProjectInfo);
+  }
+  async getClientRoutes() {
+    return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetClientRoutes);
+  }
+}
+__decorateClass([
+  Router.get(SDK.ServerAPI.API.Env)
+], ProjectAPI.prototype, "env", 1);
+__decorateClass([
+  Router.get(SDK.ServerAPI.API.Manifest)
+], ProjectAPI.prototype, "manifest", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetProjectInfo)
+], ProjectAPI.prototype, "getProjectInfo", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetClientRoutes)
+], ProjectAPI.prototype, "getClientRoutes", 1);
+export {
+  ProjectAPI
+};

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

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import serve from "serve-static";
+import path from "path";
+import { File } from "@rsdoctor/utils/build";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class RendererAPI extends BaseAPI {
+  constructor() {
+    super(...arguments);
+    this.isClientServed = false;
+  }
+  async entryHtml() {
+    const { server, res } = this.ctx;
+    const clientHtmlPath = require.resolve("@rsdoctor/client");
+    if (!this.isClientServed) {
+      this.isClientServed = true;
+      const clientDistPath = path.resolve(clientHtmlPath, "..");
+      server.app.use(serve(clientDistPath));
+    }
+    const clientHtml = await File.fse.readFile(clientHtmlPath, "utf-8");
+    res.setHeader("Content-Type", "text/html");
+    res.setHeader("Cache-Control", "no-store");
+    return clientHtml;
+  }
+}
+__decorateClass([
+  Router.get(SDK.ServerAPI.API.EntryHtml)
+], RendererAPI.prototype, "entryHtml", 1);
+export {
+  RendererAPI
+};

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

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+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
+    });
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetResolverFileTree)
+], ResolverAPI.prototype, "getResolverFileTree", 1);
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetResolverFileDetails)
+], ResolverAPI.prototype, "getResolverFileDetails", 1);
+export {
+  ResolverAPI
+};

package/dist/esm/sdk/server/fakeServer.js

@@ -0,0 +1,14 @@
+import { Server } from "@rsdoctor/utils/build";
+import { DoctorServer } from ".";
+class DoctorFakeServer extends DoctorServer {
+  constructor(sdk, port = Server.defaultPort) {
+    super(sdk, port);
+    this.sdk = sdk;
+    this.sdk = sdk;
+  }
+  async openClientPage() {
+  }
+}
+export {
+  DoctorFakeServer
+};

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

@@ -0,0 +1,148 @@
+import { SDK, Client } from "@rsdoctor/types";
+import { Server } from "@rsdoctor/utils/build";
+import { Bundle } from "@rsdoctor/utils/common";
+import assert from "assert";
+import bodyParser from "body-parser";
+import open from "open";
+import ip from "ip";
+import cors from "cors";
+import { PassThrough } from "stream";
+import { Socket } from "./socket";
+import { Router } from "./router";
+import * as APIs from "./apis";
+export * from "./utils";
+class DoctorServer {
+  constructor(sdk, port = Server.defaultPort) {
+    this.sdk = sdk;
+    this.disposed = true;
+    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 () => {
+      if (this.disposed)
+        return;
+      this.disposed = true;
+      if (this._server) {
+        await this._server.close();
+      }
+      if (this._socket) {
+        this._socket.dispose();
+      }
+    };
+    assert(typeof port === "number");
+    this.port = port;
+    this._router = new Router({ sdk, server: this, apis: Object.values(APIs) });
+  }
+  get app() {
+    return this._server.app;
+  }
+  get origin() {
+    const host = ip.address();
+    return `http://${host}:${this.port}`;
+  }
+  get socketUrl() {
+    return `ws://${ip.address()}:${this.port}`;
+  }
+  async bootstrap() {
+    if (!this.disposed) {
+      return;
+    }
+    const port = Server.getPortSync(this.port);
+    this.port = port;
+    this._server = await Server.createServer(port);
+    this._socket = new Socket({
+      sdk: this.sdk,
+      server: this._server.server,
+      port: this.port
+    });
+    await this._socket.bootstrap();
+    this.disposed = false;
+    this.app.use(cors());
+    this.app.use(bodyParser.json({ limit: "500mb" }));
+    await this._router.setup();
+    process.once("exit", this.dispose);
+    process.once("SIGINT", this.dispose);
+    process.once("SIGTERM", this.dispose);
+    process.once("unhandledRejection", this.dispose);
+    process.once("uncaughtException", this.dispose);
+  }
+  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.setHeader("Access-Control-Allow-Origin", "*");
+          res.setHeader("Access-Control-Allow-Credentials", "true");
+          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 && typeof body === "object") {
+            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 (idx === -1) {
+      idx = this.app.stack.length - 1;
+    }
+    this.app.stack.splice(idx, 0, {
+      route: api,
+      handle: this.wrapNextHandleFunction(method, cb)
+    });
+  }
+  getClientUrl(route = "homepage", ...args) {
+    const url = `${this.origin}${SDK.ServerAPI.API.EntryHtml}`;
+    switch (route) {
+      case Client.DoctorClientRoutes.BundleDiff: {
+        const [baseline, current] = args;
+        const qs = Bundle.getBundleDiffPageQueryString([baseline, current]);
+        return `${url}${qs}#${Client.DoctorClientRoutes.BundleDiff}`;
+      }
+      default:
+        return url;
+    }
+  }
+  async openClientPage(...args) {
+    const url = this.getClientUrl(
+      ...args
+    );
+    await open(url);
+    console.log(`Rsdoctor analyze run at: ${url}`);
+  }
+  sendAPIDataToClient(api, msg) {
+    this._socket?.sendAPIData(api, msg);
+  }
+  async broadcast() {
+    await this._socket?.broadcast();
+  }
+}
+export {
+  DoctorServer
+};