@wocker/ws 1.0.1

package/lib/controllers/ProjectController.js

@@ -0,0 +1,561 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProjectController = void 0;
+var _cliTable = _interopRequireDefault(require("cli-table3"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var Path = _interopRequireWildcard(require("path"));
+var _asyncMutex = require("async-mutex");
+var _env = require("../env");
+var _makes = require("../makes");
+var _models = require("../models");
+var _utils = require("../utils");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class ProjectController extends _makes.Controller {
+  constructor(appConfigService, appEventsService, projectService) {
+    super();
+    this.appConfigService = appConfigService;
+    this.appEventsService = appEventsService;
+    this.projectService = projectService;
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("init").help({
+      description: "Init project"
+    }).option("name", {
+      type: "string",
+      description: "Ім'я контейнеру",
+      alias: "n"
+    }).option("type", {
+      type: "string",
+      description: "Тип запуску контейнеру"
+    }).completion("type", () => {
+      return [];
+    }).option("preset", {
+      type: "string",
+      description: "Preset",
+      default: ""
+    }).action(options => this.init(options));
+    cli.command("start").help({
+      description: "Run project"
+    }).option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).option("rebuild", {
+      type: "boolean",
+      alias: "r"
+    }).option("detach", {
+      type: "boolean",
+      alias: "d"
+    }).action(options => this.start(options));
+    cli.command("stop").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action(options => this.stop(options));
+    cli.command("attach").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action(options => this.attach(options));
+    cli.command("config").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).option("global", {
+      type: "boolean",
+      alias: "g"
+    }).action(options => this.configList(options));
+    cli.command("config:get <key>").help({
+      description: "Get project env variable"
+    }).option("global", {
+      alias: "g",
+      description: "Global"
+    }).option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, key) => this.configGet(options, key));
+    cli.command("config:set [...configs]").option("name", {
+      type: "string",
+      alias: "n"
+    }).option("global", {
+      type: "boolean",
+      alias: "g"
+    }).completion("name", () => this.getProjectNames()).action((options, configs) => this.configSet(options, configs));
+    cli.command("config:unset [...configs]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).option("global", {
+      type: "boolean",
+      alias: "g"
+    }).action((options, configs) => this.configUnset(options, configs));
+    cli.command("build-args").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action(options => this.buildArgsList(options));
+    cli.command("build-args:get [...buildArgs]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, buildArgs) => this.buildArgsGet(options, buildArgs));
+    cli.command("build-args:set [...buildArgs]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, buildArgs) => this.buildArgsSet(options, buildArgs));
+    cli.command("build-args:unset [...buildArgs]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, buildArgs) => this.buildArgsUnset(options, buildArgs));
+    cli.command("volumes").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action(options => this.volumeList(options));
+    cli.command("volume:mount <...volumes>").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, volumes) => this.volumeMount(options, volumes));
+    cli.command("volume:unmount <...volumes>").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, volumes) => this.volumeUnmount(options, volumes));
+    cli.command("logs").help({
+      description: "Logs"
+    }).option("name", {
+      type: "boolean",
+      alias: "n"
+    }).option("global", {
+      type: "boolean",
+      alias: "g"
+    }).option("follow", {
+      type: "boolean",
+      alias: "f"
+    }).option("detach", {
+      type: "boolean",
+      alias: "d"
+    }).completion("name", () => this.getProjectNames()).action(options => this.logs(options));
+    cli.command("exec [...command]").option("name", {
+      type: "string",
+      alias: "n"
+    }).completion("name", () => this.getProjectNames()).action((options, command) => this.exec(options, command));
+  }
+  async getProjectNames() {
+    const projects = await _models.Project.search();
+    return projects.map(project => {
+      return project.name;
+    });
+  }
+  async init(options) {
+    let project = await _models.Project.searchOne({
+      src: this.appConfigService.getPWD()
+    });
+    if (!project) {
+      project = new _models.Project();
+    }
+    if (options.name) {
+      project.name = options.name;
+    }
+    if (!options.name || !project.name) {
+      project.name = await (0, _utils.promptText)({
+        type: "string",
+        required: true,
+        label: "Project name",
+        default: project.name
+      });
+    }
+    if (options.type) {
+      project.type = options.type;
+    }
+    const mapTypes = this.appConfigService.getProjectTypes();
+    if (!options.type || !project.type || !mapTypes[project.type]) {
+      project.type = await (0, _utils.promptSelect)({
+        message: "Project type",
+        options: mapTypes,
+        default: project.type
+      });
+    }
+    switch (project.type) {
+      case _models.PROJECT_TYPE_DOCKERFILE:
+        {
+          const files = await _makes.FS.readdirFiles(this.appConfigService.getPWD());
+          const dockerfiles = files.filter(fileName => {
+            if (new RegExp("^(.*)\\.dockerfile$").test(fileName)) {
+              return true;
+            }
+            return new RegExp("^Dockerfile(\\..*)?").test(fileName);
+          });
+          project.dockerfile = await (0, _utils.promptSelect)({
+            options: dockerfiles.map(dockerfile => {
+              return {
+                value: dockerfile
+              };
+            }),
+            message: "Dockerfile",
+            default: project.dockerfile
+          });
+          break;
+        }
+      case _models.PROJECT_TYPE_IMAGE:
+        {
+          project.imageName = await (0, _utils.promptText)({
+            message: "Image Name",
+            default: project.imageName
+          });
+          break;
+        }
+      default:
+        break;
+    }
+    await this.appEventsService.emit("project:init", project);
+    project.path = this.appConfigService.getPWD();
+    await project.save();
+  }
+  async start(options) {
+    const {
+      name,
+      rebuild,
+      detach
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    if (rebuild) {
+      const project = await this.projectService.get();
+      await this.appEventsService.emit("project:rebuild", project);
+    }
+    await this.projectService.start();
+    if (!detach) {
+      const project = await this.projectService.get();
+      const containerName = `${project.name}.workspace`;
+      const container = await _makes.Docker.getContainer(containerName);
+      await container.resize({
+        w: process.stdout.columns,
+        h: process.stdout.rows
+      });
+      await _makes.Docker.attach(containerName);
+    }
+  }
+  async stop(options) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    await this.projectService.stop();
+  }
+  async attach(options) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const containerName = `${name}.workspace`;
+    await _makes.Docker.attach(containerName);
+  }
+  async configList(options) {
+    const {
+      name,
+      global
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    let env = {};
+    if (!global) {
+      const project = await this.projectService.get();
+      env = project.env || {};
+    } else {
+      const config = await (0, _utils.getConfig)();
+      env = config.env || {};
+    }
+    const table = new _cliTable.default({
+      head: ["KEY", "VALUE"]
+    });
+    for (const i in env) {
+      table.push([i, env[i]]);
+    }
+    return table.toString() + "\n";
+  }
+  async configGet(options, key) {
+    const {
+      name,
+      global
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    let value = "";
+    if (global) {
+      const config = await (0, _utils.getConfig)();
+      value = config[key] || "";
+    } else {
+      const project = await this.projectService.get();
+      value = project.getEnv(key);
+    }
+    const table = new _cliTable.default({
+      head: ["KEY", "VALUE"]
+    });
+    table.push([key, value]);
+    return table.toString() + "\n";
+  }
+  async configSet(options, configs) {
+    const {
+      name,
+      global
+    } = options;
+    const env = configs.reduce((env, config) => {
+      const [key, value] = config.split("=");
+      env[key.trim()] = value.trim();
+      return env;
+    }, {});
+    if (global) {
+      const config = await (0, _utils.getConfig)();
+      await (0, _utils.setConfig)({
+        ...config,
+        env: {
+          ...(config.env || {}),
+          ...env
+        }
+      });
+      return;
+    }
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    for (const i in env) {
+      project.setEnv(i, env[i]);
+    }
+    await project.save();
+  }
+  async configUnset(options, configs) {
+    const {
+      name,
+      global
+    } = options;
+    const env = configs.reduce((env, config) => {
+      const [key] = config.split("=");
+      env[key.trim()] = null;
+      return env;
+    }, {});
+    if (global) {
+      return;
+    }
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    for (const i in env) {
+      project.unsetEnv(i);
+    }
+    await project.save();
+  }
+  async buildArgsList(options) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const table = new _cliTable.default({
+      head: ["KEY", "VALUE"]
+    });
+    const buildArgs = project.buildArgs || {};
+    for (const i in buildArgs) {
+      table.push([i, buildArgs[i]]);
+    }
+    return table.toString() + "\n";
+  }
+  async buildArgsGet(options, args) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const table = new _cliTable.default({
+      head: ["KEY", "VALUE"]
+    });
+    _makes.Logger.info("...");
+    for (const key of args) {
+      if (project.buildArgs && typeof project.buildArgs[key] !== "undefined") {
+        const value = project.buildArgs[key] || "";
+        table.push([key, value]);
+      }
+    }
+    return table.toString() + "\n";
+  }
+  async buildArgsSet(options, args) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const buildArgs = args.reduce((env, config) => {
+      const [key, value] = config.split("=");
+      env[key.trim()] = value.trim();
+      return env;
+    }, {});
+    for (const key in buildArgs) {
+      if (!project.buildArgs) {
+        project.buildArgs = {};
+      }
+      project.buildArgs[key] = buildArgs[key];
+    }
+    await project.save();
+  }
+  async buildArgsUnset(options, args) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const buildArgs = args.reduce((env, config) => {
+      const [key, value] = config.split("=");
+      env[key.trim()] = value.trim();
+      return env;
+    }, {});
+    for (const key in buildArgs) {
+      if (!project.buildArgs) {
+        break;
+      }
+      if (typeof project.buildArgs[key] !== "undefined") {
+        delete project.buildArgs[key];
+      }
+    }
+    await project.save();
+  }
+  async volumeList(options) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const table = new _cliTable.default({
+      head: ["Volume"]
+    });
+    const volumes = project.volumes || [];
+    for (const volume of volumes) {
+      table.push([volume]);
+    }
+    return table.toString() + "\n";
+  }
+  async volumeMount(options, volumes) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    console.log(volumes);
+    project.volumeMount(...volumes);
+    await project.save();
+  }
+  async volumeUnmount(options, volumes) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    project.volumeUnmount(...volumes);
+    await project.save();
+  }
+  async logs(options) {
+    const {
+      name,
+      global,
+      detach,
+      follow
+    } = options;
+    if (global) {
+      const logFilepath = Path.join(_env.DATA_DIR, "ws.log");
+      const prepareLog = str => {
+        return str.replace(/^\[.*]\s([^:]+):\s.*$/gm, (substring, type) => {
+          switch (type) {
+            case "info":
+              return _chalk.default.green(substring);
+            case "warning":
+              return _chalk.default.yellow(substring);
+            case "error":
+              return _chalk.default.red(substring);
+            default:
+              return substring;
+          }
+        });
+      };
+      const stream = _makes.FS.createReadLinesStream(logFilepath, follow ? -10 : undefined);
+      stream.on("data", data => {
+        process.stdout.write(prepareLog(data.toString()));
+        process.stdout.write("\n");
+      });
+      if (follow) {
+        const stats = await _makes.FS.stat(logFilepath);
+        const watcher = _makes.FS.watch(logFilepath);
+        const mutex = new _asyncMutex.Mutex();
+        let position = BigInt(stats.size);
+        watcher.on("change", async () => {
+          await mutex.acquire();
+          try {
+            const stats = await _makes.FS.stat(logFilepath);
+            if (BigInt(stats.size) < position) {
+              console.log("file truncated");
+              position = 0n;
+            }
+            const buffer = await _makes.FS.readBytes(logFilepath, position);
+            position += BigInt(buffer.length);
+            process.stdout.write(prepareLog(buffer.toString("utf-8")));
+          } finally {
+            mutex.release();
+          }
+        });
+      }
+      return;
+    }
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const container = await _makes.Docker.getContainer(`${project.name}.workspace`);
+    if (!detach) {
+      const stream = await container.logs({
+        stdout: true,
+        stderr: true,
+        follow: true
+      });
+      stream.on("data", data => {
+        process.stdout.write((0, _utils.demuxOutput)(data));
+      });
+    } else {
+      const buffer = await container.logs({
+        stdout: true,
+        stderr: true,
+        follow: false
+      });
+      process.stdout.write((0, _utils.demuxOutput)(buffer));
+    }
+  }
+  async exec(options, command) {
+    const {
+      name
+    } = options;
+    if (name) {
+      await this.projectService.cdProject(name);
+    }
+    const project = await this.projectService.get();
+    const containerName = `${project.name}.workspace`;
+    await _makes.Docker.exec(containerName, command);
+  }
+}
+exports.ProjectController = ProjectController;

package/lib/controllers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ImageController";
+export * from "./ProjectController";

package/lib/controllers/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _ImageController = require("./ImageController");
+Object.keys(_ImageController).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ImageController[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ImageController[key];
+    }
+  });
+});
+var _ProjectController = require("./ProjectController");
+Object.keys(_ProjectController).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ProjectController[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ProjectController[key];
+    }
+  });
+});

package/lib/env.d.ts

@@ -0,0 +1,7 @@
+export declare const NODE_ENV: string;
+export declare const ROOT_DIR: string;
+export declare const PRESETS_DIR: string;
+export declare const SERVICES_DIR: string;
+export declare const PLUGINS_DIR: string;
+export declare const DATA_DIR: string;
+export declare const MAP_PATH: string;

package/lib/env.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SERVICES_DIR = exports.ROOT_DIR = exports.PRESETS_DIR = exports.PLUGINS_DIR = exports.NODE_ENV = exports.MAP_PATH = exports.DATA_DIR = void 0;
+var OS = _interopRequireWildcard(require("os"));
+var Path = _interopRequireWildcard(require("path"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const NODE_ENV = process.env.NODE_ENV;
+exports.NODE_ENV = NODE_ENV;
+const ROOT_DIR = Path.join(__dirname, "..");
+exports.ROOT_DIR = ROOT_DIR;
+const PRESETS_DIR = Path.join(ROOT_DIR, "presets");
+exports.PRESETS_DIR = PRESETS_DIR;
+const SERVICES_DIR = Path.join(ROOT_DIR, "services");
+exports.SERVICES_DIR = SERVICES_DIR;
+const PLUGINS_DIR = Path.join(ROOT_DIR, "plugins");
+exports.PLUGINS_DIR = PLUGINS_DIR;
+const DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
+exports.DATA_DIR = DATA_DIR;
+const MAP_PATH = Path.join(DATA_DIR, "data.json");
+exports.MAP_PATH = MAP_PATH;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import { App } from "./App";
+declare const app: App;
+export { app };

package/lib/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.app = void 0;
+var _controllers = require("./controllers");
+var _plugins = require("./plugins");
+var _services = require("./services");
+var _App = require("./App");
+const appConfigService = new _services.AppConfigService();
+const appEventsService = new _services.AppEventsService();
+const projectService = new _services.ProjectService(appConfigService, appEventsService);
+const app = new _App.App(appConfigService);
+exports.app = app;
+app.useController(new _controllers.ImageController());
+app.useController(new _controllers.ProjectController(appConfigService, appEventsService, projectService));
+app.usePlugin(new _plugins.LocaltunnelPlugin(appConfigService, appEventsService, projectService));
+app.usePlugin(new _plugins.MaildevPlugin());
+app.usePlugin(new _plugins.MariadbPlugin());
+app.usePlugin(new _plugins.MongodbPlugin());
+app.usePlugin(new _plugins.NgrokPlugin(appEventsService, projectService));
+app.usePlugin(new _plugins.PageKitePlugin(appConfigService, appEventsService, projectService));
+app.usePlugin(new _plugins.PostgresPlugin());
+app.usePlugin(new _plugins.PresetPlugin(appConfigService, appEventsService));
+app.usePlugin(new _plugins.ProxmoxPlugin());
+app.usePlugin(new _plugins.ProxyPlugin(appConfigService, appEventsService, projectService));
+app.usePlugin(new _plugins.ProjectPlugin());
+app.usePlugin(new _plugins.RedisPlugin());
+app.usePlugin(new _plugins.ServeoPlugin(appConfigService, appEventsService, projectService));
+app.usePlugin(new _plugins.TestPlugin());

package/lib/makes/Controller.d.ts

@@ -0,0 +1,5 @@
+import { Cli } from "@kearisp/cli";
+declare class Controller {
+    install(cli: Cli): void;
+}
+export { Controller };

package/lib/makes/Controller.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Controller = void 0;
+class Controller {
+  install() {
+    // TODO: Do something on install
+  }
+}
+exports.Controller = Controller;