@rsdoctor/sdk 0.0.2-beta.0

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

@@ -0,0 +1,184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  DoctorServer: () => DoctorServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_types = require("@rsdoctor/types");
+var import_build = require("@rsdoctor/utils/build");
+var import_common = require("@rsdoctor/utils/common");
+var import_assert = __toESM(require("assert"));
+var import_body_parser = __toESM(require("body-parser"));
+var import_open = __toESM(require("open"));
+var import_ip = __toESM(require("ip"));
+var import_cors = __toESM(require("cors"));
+var import_stream = require("stream");
+var import_socket = require("./socket");
+var import_router = require("./router");
+var APIs = __toESM(require("./apis"));
+__reExport(server_exports, require("./utils"), module.exports);
+class DoctorServer {
+  constructor(sdk, port = import_build.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();
+      }
+    };
+    (0, import_assert.default)(typeof port === "number");
+    this.port = port;
+    this._router = new import_router.Router({ sdk, server: this, apis: Object.values(APIs) });
+  }
+  get app() {
+    return this._server.app;
+  }
+  get origin() {
+    const host = import_ip.default.address();
+    return `http://${host}:${this.port}`;
+  }
+  get socketUrl() {
+    return `ws://${import_ip.default.address()}:${this.port}`;
+  }
+  async bootstrap() {
+    if (!this.disposed) {
+      return;
+    }
+    const port = import_build.Server.getPortSync(this.port);
+    this.port = port;
+    this._server = await import_build.Server.createServer(port);
+    this._socket = new import_socket.Socket({
+      sdk: this.sdk,
+      server: this._server.server,
+      port: this.port
+    });
+    await this._socket.bootstrap();
+    this.disposed = false;
+    this.app.use((0, import_cors.default)());
+    this.app.use(import_body_parser.default.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 import_stream.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}${import_types.SDK.ServerAPI.API.EntryHtml}`;
+    switch (route) {
+      case import_types.Client.DoctorClientRoutes.BundleDiff: {
+        const [baseline, current] = args;
+        const qs = import_common.Bundle.getBundleDiffPageQueryString([baseline, current]);
+        return `${url}${qs}#${import_types.Client.DoctorClientRoutes.BundleDiff}`;
+      }
+      default:
+        return url;
+    }
+  }
+  async openClientPage(...args) {
+    const url = this.getClientUrl(
+      ...args
+    );
+    await (0, import_open.default)(url);
+    console.log(`Rsdoctor analyze run at: ${url}`);
+  }
+  sendAPIDataToClient(api, msg) {
+    this._socket?.sendAPIData(api, msg);
+  }
+  async broadcast() {
+    await this._socket?.broadcast();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DoctorServer,
+  ...require("./utils")
+});

package/dist/cjs/sdk/server/router.js

@@ -0,0 +1,116 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var router_exports = {};
+__export(router_exports, {
+  Router: () => Router
+});
+module.exports = __toCommonJS(router_exports);
+const _Router = class _Router {
+  constructor(options) {
+    this.options = options;
+  }
+  static get(pathname) {
+    return (target, propertyKey, descriptor) => {
+      const routes = _Router.routes.get;
+      if (!routes.has(target.constructor)) {
+        routes.set(target.constructor, []);
+      }
+      routes.get(target.constructor).push([propertyKey, pathname]);
+      return descriptor;
+    };
+  }
+  static post(pathname) {
+    return (target, propertyKey, descriptor) => {
+      const routes = _Router.routes.post;
+      if (!routes.has(target.constructor)) {
+        routes.set(target.constructor, []);
+      }
+      routes.get(target.constructor).push([propertyKey, pathname]);
+      return descriptor;
+    };
+  }
+  async setup() {
+    const { apis, sdk, server } = this.options;
+    apis.forEach((API) => {
+      const obj = new API(sdk, server);
+      _Router.routes.get.forEach((v, cons) => {
+        v.forEach(([key, pathname]) => {
+          if (cons === API) {
+            server.get(pathname, this.wrapAPIFunction(obj, key));
+          }
+        });
+      });
+      _Router.routes.post.forEach((v, cons) => {
+        v.forEach(([key, pathname]) => {
+          if (cons === API) {
+            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, key2, receiver) {
+          switch (key2) {
+            case "ctx":
+              return ctx;
+            default:
+              return Reflect.get(target, key2, receiver);
+          }
+        },
+        set(target, key2, value, receiver) {
+          return Reflect.set(target, key2, value, receiver);
+        },
+        defineProperty(target, p, attrs) {
+          return Reflect.defineProperty(target, p, attrs);
+        }
+      });
+      const fn = api[key];
+      const result = await fn.call(trap, trap);
+      if (typeof result === "string") {
+        return Buffer.from(result, "utf-8");
+      }
+      if (result && typeof result === "object") {
+        return Buffer.from(JSON.stringify(result), "utf-8");
+      }
+      return result;
+    };
+  }
+};
+_Router.routes = {
+  /**
+   * - `key` is the constuctor of object which used to match the API class
+   */
+  get: /* @__PURE__ */ new Map(),
+  post: /* @__PURE__ */ new Map()
+};
+let Router = _Router;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router
+});

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

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+__export(api_exports, {
+  SocketAPILoader: () => SocketAPILoader
+});
+module.exports = __toCommonJS(api_exports);
+var import_common = require("@rsdoctor/utils/common");
+class SocketAPILoader {
+  constructor(options) {
+    this.options = options;
+    this.dataLoader = new import_common.Data.APIDataLoader(this);
+  }
+  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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketAPILoader
+});

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

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var socket_exports = {};
+__export(socket_exports, {
+  Socket: () => Socket
+});
+module.exports = __toCommonJS(socket_exports);
+var import_types = require("@rsdoctor/types");
+var import_socket = require("socket.io");
+var import_util = require("util");
+var import_api = require("./api");
+class Socket {
+  constructor(options) {
+    this.options = options;
+    this.map = /* @__PURE__ */ new Map();
+    this.loader = new import_api.SocketAPILoader({ sdk: options.sdk });
+  }
+  bootstrap() {
+    this.io = new import_socket.Server(this.options.server, {
+      cors: {
+        origin: "*"
+      },
+      ...this.options.socketOptions
+    });
+    this.io.on("connection", (socket) => {
+      this.setupSocket(socket);
+    });
+  }
+  setupSocket(socket) {
+    Object.values(import_types.SDK.ServerAPI.API).forEach((api) => {
+      socket.on(api, async (body, callback) => {
+        this.saveRequestToMap(api, body);
+        callback(await this.getAPIResponse(api, body));
+      });
+    });
+  }
+  saveRequestToMap(api, body = null) {
+    if (!this.map.has(api)) {
+      this.map.set(api, []);
+    }
+    const list = this.map.get(api);
+    if (!list.some((e) => e === body || (0, import_util.isDeepStrictEqual)(e, body))) {
+      list.push(body);
+    }
+  }
+  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((bodies, api) => {
+        bodies.forEach((body) => {
+          promises.push(
+            (async () => {
+              const res = await this.getAPIResponse(api, body);
+              this.io.emit(api, res);
+            })()
+          );
+        });
+      });
+      await Promise.all(promises);
+    });
+  }
+  sendAPIData(api, msg) {
+    this.io.sockets.emit(api, msg);
+  }
+  dispose() {
+    this.io.disconnectSockets();
+    this.io.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Socket
+});

package/dist/cjs/sdk/server/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getDataByPagination: () => getDataByPagination
+});
+module.exports = __toCommonJS(utils_exports);
+function getDataByPagination(data, pagination) {
+  const { page = 1, pageSize = 1e3 } = pagination;
+  return {
+    data: data.slice((page - 1) * pageSize, page * pageSize),
+    pagination: {
+      page,
+      pageSize,
+      hasNextPage: page <= 0 ? false : page * pageSize < data.length
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDataByPagination
+});

package/dist/cjs/sdk/utils/constant.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constant_exports = {};
+__export(constant_exports, {
+  CLOUD_DIR: () => CLOUD_DIR
+});
+module.exports = __toCommonJS(constant_exports);
+var import_dayjs = __toESM(require("dayjs"));
+const CLOUD_DIR = `rsdoctor/manifests/${(0, import_dayjs.default)().format(
+  "YYYYMMDD"
+)}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOUD_DIR
+});

package/dist/cjs/sdk/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./constant"), module.exports);
+__reExport(utils_exports, require("./upload"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./constant"),
+  ...require("./upload")
+});

package/dist/cjs/sdk/utils/upload.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upload_exports = {};
+__export(upload_exports, {
+  transformDataUrls: () => transformDataUrls
+});
+module.exports = __toCommonJS(upload_exports);
+const transformDataUrls = (d) => {
+  return d.reduce((t, item) => {
+    t[item.name] = Array.isArray(item.files) ? item.files.map((e) => e.path) : item.files;
+    return t;
+  }, {});
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformDataUrls
+});

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from "./sdk";

package/dist/esm/sdk/index.js

@@ -0,0 +1,2 @@
+export * from "./sdk";
+export * from "./multiple";

package/dist/esm/sdk/multiple/controller.js

@@ -0,0 +1,48 @@
+import { DoctorSlaveSDK } from "./slave";
+class DoctorSDKController {
+  constructor(root = process.cwd()) {
+    this.slaves = [];
+    this.root = "";
+    this.root = root;
+  }
+  get master() {
+    return this.slaves[0];
+  }
+  getLastSdk() {
+    return this.slaves[this.slaves.length - 1];
+  }
+  hasName(name) {
+    return Boolean(this.slaves.find((item) => item.name === name));
+  }
+  getSeriesData(serverUrl = false) {
+    return this.slaves.map((item) => {
+      const data = {
+        name: item.name,
+        path: item.diskManifestPath,
+        stage: item.stage
+      };
+      if (serverUrl) {
+        data.origin = item.server.origin;
+      }
+      return data;
+    });
+  }
+  createSlave({
+    name,
+    stage,
+    extraConfig
+  }) {
+    const slave = new DoctorSlaveSDK({
+      name,
+      stage,
+      controller: this,
+      extraConfig
+    });
+    this.slaves.push(slave);
+    this.slaves.sort((a, b) => a.stage - b.stage);
+    return slave;
+  }
+}
+export {
+  DoctorSDKController
+};

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

@@ -0,0 +1,2 @@
+export * from "./controller";
+export * from "./slave";

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

@@ -0,0 +1,17 @@
+import { Server } from "@rsdoctor/utils/build";
+import { DoctorServer } from "../server";
+class DoctorSlaveServer extends DoctorServer {
+  constructor(sdk, port = Server.defaultPort) {
+    super(sdk, port);
+    this.sdk = sdk;
+  }
+  async openClientPage(...args) {
+    if (this.sdk.isMaster) {
+      return super.openClientPage(...args);
+    }
+    return Promise.resolve();
+  }
+}
+export {
+  DoctorSlaveServer
+};