@wocker/ws 1.0.1

package/lib/plugins/MariadbPlugin.js

@@ -0,0 +1,297 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MariadbPlugin = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _format = _interopRequireDefault(require("date-fns/format"));
+var _env = require("../env");
+var _makes = require("../makes");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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; }
+class MariadbPlugin extends _makes.Plugin {
+  user = "root";
+  password = "toor";
+  constructor() {
+    super("mariadb");
+    this.dbDir = Path.join(_env.DATA_DIR, "db/mariadb");
+    // this.dataDir = Path.join(PLUGINS_DIR, "mariadb");
+  }
+
+  install(cli) {
+    super.install(cli);
+    cli.command("mariadb:start").action(() => this.start());
+    cli.command("mariadb:stop").action(() => this.stop());
+    cli.command("mariadb:backup [database]").completion("database", () => this.getDatabases()).action((options, database) => this.backup(database));
+    cli.command("mariadb:delete-backup [database] [filename]").option("yes", {
+      type: "boolean",
+      alias: "y"
+    }).completion("database", () => this.getDumpDatabases()).completion("filename", (options, database) => this.getDumpFiles(database)).action((options, database, filename) => this.deleteBackup(options, database, filename));
+    cli.command("mariadb:restore [database] [filename]").completion("database", () => this.getDumpDatabases()).completion("filename", (options, database) => this.getDumpFiles(database)).action((options, database, filename) => this.restore(options, database, filename));
+    cli.command("mariadb:import <database>").completion("database", () => this.getDatabases()).action((options, database) => this.import(options, database));
+    cli.command("mariadb:dump <database>").completion("database", () => this.getDatabases()).action((options, database) => this.dump(options, database));
+    cli.command("mariadb:exec [...command]").action((options, command) => this.exec(options, command));
+  }
+  async getDatabases() {
+    const stream = await _makes.Docker.exec("mariadb.workspace", ["mysql", `-u${this.user}`, `-p${this.password}`, "-e", "SHOW DATABASES;"], false);
+    let res = "";
+    stream.on("data", data => {
+      res += (0, _utils.demuxOutput)(data).toString();
+    });
+    await new Promise((resolve, reject) => {
+      stream.on("end", resolve);
+      stream.on("error", reject);
+    });
+    return res.split(/\r?\n/).filter(database => {
+      return !/Database$/.test(database);
+    }).filter(database => {
+      return !/_schema/.test(database);
+    }).filter(database => {
+      return !!database;
+    });
+  }
+  async getDumpDatabases() {
+    return _makes.FS.readdir(this.dataPath("dump"));
+  }
+  async getDumpFiles(database) {
+    if (!database) {
+      return [];
+    }
+    const dirPath = this.dataPath("dump", database);
+    if (!_makes.FS.existsSync(dirPath)) {
+      return [];
+    }
+    return _makes.FS.readdirFiles(dirPath);
+  }
+  async start() {
+    await this.startMariadb();
+    await this.startAdmin();
+  }
+  async startMariadb() {
+    console.info("Mariadb starting...");
+    await _makes.Docker.pullImage("mariadb:10.5");
+    await _makes.Docker.containerRun({
+      name: "mariadb.workspace",
+      restart: "always",
+      ports: ["3306:3306"],
+      env: {
+        MYSQL_ROOT_PASSWORD: "toor"
+      },
+      volumes: [`${this.dbDir}:/var/lib/mysql`],
+      image: "mariadb:10.5"
+    });
+  }
+  async startAdmin() {
+    console.info("Phpmyadmin starting...");
+    const configPath = "conf/config.user.inc.php";
+    if (!_makes.FS.existsSync(this.dataPath(configPath))) {
+      await _makes.FS.mkdir(Path.dirname(this.dataPath(configPath)), {
+        recursive: true
+      });
+      await _makes.FS.copyFile(this.pluginPath("admin", configPath), this.dataPath(configPath));
+    }
+    await _makes.FS.mkdir(this.dataPath("save"), {
+      recursive: true
+    });
+    await _makes.FS.mkdir(this.dataPath("upload"), {
+      recursive: true
+    });
+    await _makes.Docker.pullImage("phpmyadmin/phpmyadmin:latest");
+    await _makes.Docker.containerRun({
+      name: "dbadmin-mariadb.workspace",
+      restart: "always",
+      env: {
+        PMA_USER: "root",
+        PMA_PASSWORD: "toor",
+        VIRTUAL_HOST: "dbadmin-mariadb.workspace",
+        VIRTUAL_PORT: "80"
+      },
+      volumes: [`${this.dataPath("conf/config.user.inc.php")}:/etc/phpmyadmin/config.user.inc.php`, `${this.dataPath("save")}:/etc/phpmyadmin/save`, `${this.dataPath("upload")}:/etc/phpmyadmin/upload`],
+      links: ["mariadb.workspace:db"],
+      image: "phpmyadmin/phpmyadmin:latest"
+    });
+  }
+  async stop() {
+    await this.stopMariadb();
+    await this.stopAdmin();
+  }
+  async stopMariadb() {
+    console.info("Mariadb stopping...");
+    const container = await _makes.Docker.getContainer("mariadb.workspace");
+    if (container) {
+      try {
+        await container.stop();
+      } catch (err) {
+        _makes.Logger.warning(err.message, {
+          class: "MariadbPlugin"
+        });
+      }
+      try {
+        await container.remove();
+      } catch (err) {
+        _makes.Logger.warning(err.message, {
+          class: "MariadbPlugin"
+        });
+      }
+    }
+  }
+  async stopAdmin() {
+    console.info("Phpmyadmin stopping...");
+    const container = await _makes.Docker.getContainer("dbadmin-mariadb.workspace");
+    if (container) {
+      try {
+        await container.stop();
+      } catch (err) {
+        _makes.Logger.warning(err.message, {
+          class: "MariadbPlugin"
+        });
+      }
+      try {
+        await container.remove();
+      } catch (err) {
+        _makes.Logger.warning(err.message, {
+          class: "MariadbPlugin"
+        });
+      }
+    }
+  }
+  async exec(options, command) {
+    await _makes.Docker.exec("mariadb.workspace", command);
+  }
+  async backup(database) {
+    if (!database) {
+      database = await (0, _utils.promptSelect)({
+        message: "Database",
+        options: await this.getDatabases()
+      });
+    }
+    const date = (0, _format.default)(new Date(), "yyyy-MM-dd HH-mm");
+    const filePath = this.dataPath("dump", database, `${date}.sql`);
+    if (!_makes.FS.existsSync(Path.dirname(filePath))) {
+      _makes.FS.mkdirSync(Path.dirname(filePath), {
+        recursive: true
+      });
+    }
+    const file = _makes.FS.createWriteStream(filePath);
+    const stream = await _makes.Docker.exec("mariadb.workspace", ["mysqldump", "--add-drop-table", `-u${this.user}`, `-p${this.password}`, database], false);
+    stream.on("data", data => {
+      file.write((0, _utils.demuxOutput)(data));
+    });
+  }
+  async deleteBackup(options, database, filename) {
+    const {
+      yes
+    } = options;
+    if (!database) {
+      const dumps = await this.getDumpDatabases();
+      if (dumps.length === 0) {
+        throw new Error("No dump databases");
+      }
+      database = await (0, _utils.promptSelect)({
+        message: "Database",
+        options: dumps
+      });
+    }
+    if (!filename) {
+      const files = await _makes.FS.readdirFiles(this.dataPath("dump", database));
+      if (files.length === 0) {
+        throw new Error(`No backups for ${database}`);
+      }
+      filename = await (0, _utils.promptSelect)({
+        message: "File",
+        options: files
+      });
+    }
+    if (!yes) {
+      const confirm = await (0, _utils.promptConfirm)({
+        message: `Delete ${filename}`,
+        default: false
+      });
+      if (!confirm) {
+        return;
+      }
+    }
+    const filePath = this.dataPath("dump", database, filename);
+    await _makes.FS.rm(filePath);
+    const otherFiles = await _makes.FS.readdir(this.dataPath("dump", database));
+    if (otherFiles.length === 0) {
+      await _makes.FS.rm(this.dataPath("dump", database), {
+        force: true,
+        recursive: true
+      });
+    }
+  }
+  async restore(options, database, filename) {
+    if (!database) {
+      const dumps = await _makes.FS.readdir(this.dataPath("dump"));
+      if (dumps.length === 0) {
+        throw new Error("No dumps found");
+      }
+      database = await (0, _utils.promptSelect)({
+        message: "Database",
+        options: dumps
+      });
+    }
+    if (!database) {
+      throw new Error("Need database name");
+    }
+    const dirs = await _makes.FS.readdir(this.dataPath("dump", database));
+    if (!filename) {
+      filename = await (0, _utils.promptSelect)({
+        message: "File",
+        options: dirs
+      });
+    }
+    const path = this.dataPath("dump", database, filename);
+    const file = _makes.FS.createReadStream(path);
+    const stream = await _makes.Docker.exec("mariadb.workspace", ["mysql", "-uroot", "-ptoor", database], false);
+    file.on("data", data => {
+      stream.write(data);
+    });
+    file.on("end", () => {
+      stream.write("exit\n");
+    });
+    stream.on("error", data => {
+      process.stderr.write((0, _utils.demuxOutput)(data));
+      stream.write("exit\n");
+      file.close();
+    });
+  }
+  async dump(options, database) {
+    const date = (0, _format.default)(new Date(), "yyyy-MM-dd HH-mm");
+    const dirPath = this.dataPath("dump", database);
+    const filePath = this.dataPath("dump", database, `${date}.sql`);
+    if (!_makes.FS.existsSync(dirPath)) {
+      _makes.FS.mkdirSync(dirPath, {
+        recursive: true
+      });
+    }
+
+    // const filePath = Path.join(DATA_DIR, `${database} ${date}.sql`);
+    // console.log(filePath);
+
+    const file = _makes.FS.createWriteStream(filePath);
+    const stream = await _makes.Docker.exec("mariadb.workspace", ["mysqldump", "-uroot", "-ptoor", database]);
+    stream.pipe(file);
+  }
+  async import(options, database) {
+    const container = await _makes.Docker.getContainer("mariadb.workspace");
+    const exec = await container.exec({
+      AttachStdin: true,
+      AttachStdout: true,
+      AttachStderr: true,
+      Tty: process.stdin.isTTY,
+      Cmd: ["mysql", `-u${this.user}`, `-p${this.password}`, database]
+    });
+    const stream = await exec.start({
+      hijack: true,
+      stdin: true,
+      Tty: process.stdin.isTTY
+    });
+    await _makes.Docker.attachStream(stream);
+  }
+}
+exports.MariadbPlugin = MariadbPlugin;

package/lib/plugins/MongodbPlugin.d.ts

@@ -0,0 +1,20 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+declare class MongodbPlugin extends Plugin {
+    container: string;
+    adminContainer: string;
+    constructor();
+    install(cli: Cli): void;
+    getDatabases(): Promise<string[]>;
+    getDatabasesDumps(): Promise<string[]>;
+    start(): Promise<void>;
+    startAdmin(): Promise<void>;
+    stop(): Promise<void>;
+    stopDB(): Promise<void>;
+    stopAdmin(): Promise<void>;
+    restart(): Promise<void>;
+    backup(database?: string): Promise<void>;
+    deleteBackup(database?: string, filename?: string, yes?: boolean): Promise<void>;
+    restore(database?: string, filename?: string): Promise<void>;
+}
+export { MongodbPlugin };

package/lib/plugins/MongodbPlugin.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MongodbPlugin = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var dateFns = _interopRequireWildcard(require("date-fns"));
+var _env = require("../env");
+var _utils = require("../utils");
+var _makes = require("../makes");
+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; }
+class MongodbPlugin extends _makes.Plugin {
+  container = "mongodb.workspace";
+  adminContainer = "dbadmin-mongodb.workspace";
+  constructor() {
+    super("mongodb");
+    this.dataDir = Path.join(_env.DATA_DIR, "db/mongodb");
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("mongodb:start").action(() => {
+      return this.start();
+    });
+    cli.command("mongodb:stop").action(() => {
+      return this.stop();
+    });
+    cli.command("mongodb:restart").action(() => {
+      return this.restart();
+    });
+    cli.command("mongodb:backup [database]").completion("database", () => {
+      return this.getDatabases();
+    }).action((options, database) => {
+      return this.backup(database);
+    });
+    cli.command("mongodb:restore [database] [filename]").completion("database", () => {
+      const dumpPath = this.dataPath("dump");
+      return _makes.FS.readdir(dumpPath);
+    }).completion("filename", (options, database) => {
+      if (!database) {
+        return [];
+      }
+      const dirPath = this.dataPath("dump", database);
+      if (!_makes.FS.existsSync(dirPath)) {
+        return [];
+      }
+      return _makes.FS.readdir(dirPath);
+    }).action((options, database, filename) => {
+      return this.restore(database, filename);
+    });
+    cli.command("mongodb:delete-backup [database] [filename]").option("yes", {
+      type: "boolean",
+      alias: "y"
+    }).completion("database", () => {
+      return this.getDatabasesDumps();
+    }).completion("filename", (options, database) => {
+      if (!database) {
+        return [];
+      }
+      const dumpPath = this.dataPath("dump", database);
+      if (!_makes.FS.existsSync(dumpPath)) {
+        return [];
+      }
+      return _makes.FS.readdirFiles(dumpPath);
+    }).action((options, database, filename) => {
+      return this.deleteBackup(database, filename, options.yes);
+    });
+  }
+  async getDatabases() {
+    const stream = await _makes.Docker.exec(this.container, ["mongosh", "--username", "root", "--password", "toor", "--quiet", "--eval", "db.getMongo().getDBNames().forEach(function(i){print(i)})"], false);
+    let res = "";
+    stream.on("data", data => {
+      res += (0, _utils.demuxOutput)(data).toString();
+    });
+    await new Promise((resolve, reject) => {
+      stream.on("end", resolve);
+      stream.on("error", reject);
+    });
+    return res.split(/\r?\n/).filter(database => {
+      return !!database;
+    });
+  }
+  async getDatabasesDumps() {
+    const dumpDir = this.dataPath("dump");
+    return _makes.FS.readdir(dumpDir);
+  }
+  async start() {
+    console.log("Mongidb starting...");
+    await _makes.Docker.pullImage("mongo:latest");
+    const container = await _makes.Docker.createContainer({
+      name: this.container,
+      restart: "always",
+      image: "mongo:latest",
+      volumes: [`${this.dataPath()}:/data/db`],
+      ports: ["27017:27017"],
+      env: {
+        MONGO_INITDB_ROOT_USERNAME: "root",
+        MONGO_INITDB_ROOT_PASSWORD: "toor",
+        MONGO_ROOT_USER: "root",
+        MONGO_ROOT_PASSWORD: "toor"
+      }
+    });
+    await container.start();
+    await this.startAdmin();
+  }
+  async startAdmin() {
+    console.log("Mongodb Admin starting...");
+    await _makes.Docker.pullImage("mongo-express:latest");
+    const container = await _makes.Docker.createContainer({
+      name: this.adminContainer,
+      restart: "always",
+      env: {
+        ME_CONFIG_MONGODB_SERVER: this.container,
+        ME_CONFIG_MONGODB_PORT: "27017",
+        MONGO_ROOT_USER: "root",
+        MONGO_ROOT_PASSWORD: "toor",
+        ME_CONFIG_MONGODB_ADMINUSERNAME: "root",
+        ME_CONFIG_MONGODB_ADMINPASSWORD: "toor",
+        ME_CONFIG_MONGODB_ENABLE_ADMIN: "true",
+        ME_CONFIG_MONGODB_AUTH_DATABASE: "admin",
+        ME_CONFIG_MONGODB_AUTH_USERNAME: "root",
+        ME_CONFIG_MONGODB_AUTH_PASSWORD: "toor",
+        VIRTUAL_HOST: this.adminContainer,
+        VIRTUAL_PORT: "8081"
+      },
+      image: "mongo-express:latest"
+    });
+    await container.start();
+  }
+  async stop() {
+    await this.stopDB();
+    await this.stopAdmin();
+  }
+  async stopDB() {
+    console.log("Mongodb stopping...");
+    const container = await _makes.Docker.getContainer(this.container);
+    if (container) {
+      try {
+        await container.stop();
+        await container.remove();
+      } catch (err) {
+        _makes.Logger.error(err.message);
+      }
+    }
+  }
+  async stopAdmin() {
+    console.log("Mongodb Admin stopping...");
+    const container = await _makes.Docker.getContainer(this.adminContainer);
+    if (container) {
+      await container.stop().catch(() => {
+        //
+      });
+      await container.remove().catch(() => {
+        //
+      });
+    }
+  }
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  async backup(database) {
+    if (!database) {
+      database = await (0, _utils.promptSelect)({
+        message: "Database",
+        options: await this.getDatabases()
+      });
+    }
+    const date = dateFns.format(new Date(), "yyyy-MM-dd HH-mm");
+    const dirPath = this.dataPath("dump", database);
+    const filePath = this.dataPath("dump", database, `${date}.gz`);
+    if (!_makes.FS.existsSync(dirPath)) {
+      _makes.FS.mkdirSync(dirPath, {
+        recursive: true
+      });
+    }
+    const stream = await _makes.Docker.exec(this.container, ["mongodump", "--authenticationDatabase", "admin", "--host", `${this.container}:27017`, "--username", "root", "--password", "toor", "--db", database, "--archive", "--gzip"], false);
+    const file = _makes.FS.createWriteStream(filePath);
+    stream.on("data", data => {
+      file.write((0, _utils.demuxOutput)(data));
+    });
+    await new Promise((resolve, reject) => {
+      stream.on("end", resolve);
+      stream.on("error", reject);
+    });
+  }
+  async deleteBackup(database, filename, yes) {
+    if (!database) {
+      database = await (0, _utils.promptSelect)({
+        message: "Database",
+        options: await this.getDatabasesDumps()
+      });
+    }
+    if (!database) {
+      throw new Error("No database");
+    }
+    const dirPath = this.dataPath("dump", database);
+    if (!_makes.FS.existsSync(dirPath)) {
+      throw new Error(`Backups dir for database "${database}" not found`);
+    }
+    if (!filename) {
+      const files = await _makes.FS.readdirFiles(dirPath);
+      if (files.length === 0) {
+        throw new Error(`No backups for ${database}`);
+      }
+      filename = await (0, _utils.promptSelect)({
+        message: "File",
+        options: files
+      });
+    }
+    const filePath = this.dataPath("dump", database, filename);
+    if (!_makes.FS.existsSync(filePath)) {
+      throw new Error(`Backup "${filename}" not found`);
+    }
+    if (!yes) {
+      yes = await (0, _utils.promptConfirm)({
+        message: `Delete ${filename}?`,
+        default: false
+      });
+    }
+    if (!yes) {
+      return;
+    }
+    await _makes.FS.rm(filePath);
+    const otherFiles = await _makes.FS.readdir(dirPath);
+    if (otherFiles.length === 0) {
+      await _makes.FS.rm(dirPath, {
+        force: true,
+        recursive: true
+      });
+    }
+  }
+  async restore(database, filename) {
+    if (!database) {
+      const dumps = await _makes.FS.readdir(this.dataPath("dump"));
+      if (dumps.length === 0) {
+        throw new Error("No dumps found");
+      }
+      database = await (0, _utils.promptSelect)({
+        message: "Database",
+        options: dumps
+      });
+    }
+    if (!database) {
+      throw new Error("Need database name");
+    }
+    if (!filename) {
+      const filenames = await _makes.FS.readdir(this.dataPath("dump", database));
+      filename = await (0, _utils.promptSelect)({
+        message: "File",
+        options: filenames
+      });
+    }
+    const path = this.dataPath("dump", database, filename);
+    const file = _makes.FS.createReadStream(path);
+    const stream = await _makes.Docker.exec(this.container, ["mongorestore", "--authenticationDatabase", "admin", "--host", `${this.container}:27017`, "--username", "root", "--password", "toor", "--db", database, "--drop", "--gzip", "--archive"], false);
+    file.on("data", data => {
+      stream.write(data);
+    });
+    file.on("end", () => {
+      throw new Error("File end");
+    });
+    stream.on("error", err => {
+      file.close();
+      throw err;
+    });
+    console.log(path);
+  }
+}
+exports.MongodbPlugin = MongodbPlugin;

package/lib/plugins/NgrokPlugin.d.ts

@@ -0,0 +1,37 @@
+import { Cli } from "@kearisp/cli";
+import { Plugin } from "src/makes";
+import { Project } from "src/models";
+import { AppEventsService, ProjectService } from "src/services";
+type StartOptions = {
+    name?: string;
+    detach?: string;
+};
+type StopOptions = {
+    name?: string;
+};
+type LogsOptions = {
+    name?: string;
+};
+type AttachOptions = {
+    name?: string;
+};
+type ForwardingOptions = {
+    name?: string;
+};
+declare class NgrokPlugin extends Plugin {
+    protected appEventsService: AppEventsService;
+    protected projectService: ProjectService;
+    constructor(appEventsService: AppEventsService, projectService: ProjectService);
+    install(cli: Cli): void;
+    init(options: any): Promise<void>;
+    getForwarding(project: Project): Promise<string | undefined>;
+    onProjectStart(project: Project): Promise<void>;
+    onProjectStop(project: Project): Promise<void>;
+    start(options: StartOptions): Promise<void>;
+    stop(options: StopOptions): Promise<void>;
+    restart(options: StartOptions): Promise<void>;
+    logs(options: LogsOptions): Promise<void>;
+    attach(options: AttachOptions): Promise<void>;
+    forwarding(options: ForwardingOptions): Promise<string>;
+}
+export { NgrokPlugin };