@wocker/ws 1.0.2 → 1.0.4

package/lib/controllers/ProxyController.d.ts

@@ -1,4 +1,6 @@
-import { DI, AppConfigService, AppEventsService, ProjectService, DockerService, Controller, Cli, Project } from "@wocker/core";
+import { Controller, Cli } from "@wocker/core";
+import { DI, Project } from "../makes";
+import { AppConfigService, AppEventsService, ProjectService, DockerService } from "../services";
 type InitOptions = {
     "http-port"?: number;
     "https-port"?: number;
@@ -15,6 +17,7 @@ declare class ProxyController extends Controller {
     constructor(di: DI);
     install(cli: Cli): void;
     getProjectNames(): Promise<string[]>;
+    getDomains(name: string | undefined, selected: string[]): Promise<string[]>;
     onProjectStart(project: Project): Promise<void>;
     onProjectStop(project: Project): Promise<void>;
     init(options: InitOptions): Promise<void>;

package/lib/controllers/ProxyController.js

@@ -1,249 +1,273 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyController = void 0;
-var _core = require("@wocker/core");
-var _utils = require("@wocker/utils");
-var _cliTable = _interopRequireDefault(require("cli-table3"));
-var _chalk = _interopRequireDefault(require("chalk"));
-var _makes = require("../makes");
-var _utils2 = require("../utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class ProxyController extends _core.Controller {
-  containerName = "proxy.workspace";
-  constructor(di) {
-    super();
-    this.appConfigService = di.resolveService(_core.AppConfigService);
-    this.appEventsService = di.resolveService(_core.AppEventsService);
-    this.projectService = di.resolveService(_core.ProjectService);
-    this.dockerService = di.resolveService(_core.DockerService);
-  }
-  install(cli) {
-    super.install(cli);
-    this.appEventsService.on("project:beforeStart", project => this.onProjectStart(project));
-    this.appEventsService.on("project:stop", project => this.onProjectStop(project));
-    cli.command("proxy:init").option("http-port", {
-      type: "number",
-      description: "Http port"
-    }).option("https-port", {
-      type: "number",
-      description: "Https port"
-    }).action(options => this.init(options));
-    cli.command("proxy:start").action(() => this.start());
-    cli.command("proxy:stop").action(() => this.stop());
-    cli.command("proxy:restart").action(() => this.restart());
-    cli.command("domains").option("name", {
-      type: "string",
-      alias: "n",
-      description: "Project name"
-    }).action(options => this.domainList(options));
-    cli.command("domain:set [...domains]").option("name", {
-      type: "string",
-      alias: "n",
-      description: "Project name"
-    }).completion("name", () => this.getProjectNames()).action((options, domains) => this.setDomains(options, domains));
-    cli.command("domain:add [...domains]").option("name", {
-      type: "string",
-      alias: "n",
-      description: "Project name"
-    }).completion("name", () => this.getProjectNames()).action((options, domains) => this.addDomain(options, domains));
-    cli.command("domain:remove [...domains]").option("name", {
-      type: "string",
-      alias: "n",
-      description: "Project name"
-    }).completion("name", () => this.getProjectNames()).action((options, domains) => this.removeDomain(options, domains));
-    cli.command("domain:clear").option("name", {
-      type: "string",
-      alias: "n",
-      description: "Project name"
-    }).completion("name", () => this.getProjectNames()).action(options => this.clearDomains(options));
-    cli.command("proxy:logs").action(() => this.logs());
-  }
-  async getProjectNames() {
-    const projects = await _core.Project.search();
-    return projects.map(project => project.name);
-  }
-  async onProjectStart(project) {
-    if (!project.hasEnv("VIRTUAL_HOST")) {
-      project.setEnv("VIRTUAL_HOST", `${project.name}.workspace`);
-    }
-    await this.start();
-  }
-  async onProjectStop(project) {
-    //
-  }
-  async init(options) {
-    let {
-      "http-port": httpPort,
-      "https-port": httpsPort
-    } = options;
-    if (typeof httpPort === "undefined" || isNaN(httpPort)) {
-      httpPort = await (0, _utils.promptText)({
-        required: true,
-        message: "Http port:",
-        type: "int",
-        default: await this.appConfigService.getEnvVariable("PROXY_HTTP_PORT", "80")
-      });
-    }
-    await this.appConfigService.setEnvVariable("PROXY_HTTP_PORT", httpPort);
-    if (typeof httpsPort === "undefined" || isNaN(httpsPort)) {
-      httpsPort = await (0, _utils.promptText)({
-        required: true,
-        message: "Https port:",
-        type: "int",
-        default: await this.appConfigService.getEnvVariable("PROXY_HTTPS_PORT", "443")
-      });
-    }
-    await this.appConfigService.setEnvVariable("PROXY_HTTPS_PORT", httpsPort);
-  }
-  async start() {
-    console.info("Proxy starting...");
-    await this.dockerService.pullImage("nginxproxy/nginx-proxy");
-    const httpPort = await this.appConfigService.getEnvVariable("PROXY_HTTP_PORT", "80");
-    const httpsPort = await this.appConfigService.getEnvVariable("PROXY_HTTPS_PORT", "443");
-    let container = await this.dockerService.getContainer(this.containerName);
-    if (!container) {
-      const certsDir = this.appConfigService.dataPath("certs");
-      if (!_makes.FS.existsSync(certsDir)) {
-        _makes.FS.mkdirSync(certsDir, {
-          recursive: true
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const makes_1 = require("../makes");
+const utils_2 = require("../utils");
+const services_1 = require("../services");
+class ProxyController extends core_1.Controller {
+    constructor(di) {
+        super();
+        this.containerName = "proxy.workspace";
+        this.appConfigService = di.resolveService(services_1.AppConfigService);
+        this.appEventsService = di.resolveService(services_1.AppEventsService);
+        this.projectService = di.resolveService(services_1.ProjectService);
+        this.dockerService = di.resolveService(services_1.DockerService);
+    }
+    install(cli) {
+        super.install(cli);
+        this.appEventsService.on("project:beforeStart", (project) => this.onProjectStart(project));
+        this.appEventsService.on("project:stop", (project) => this.onProjectStop(project));
+        cli.command("proxy:init")
+            .option("http-port", {
+            type: "number",
+            description: "Http port"
+        })
+            .option("https-port", {
+            type: "number",
+            description: "Https port"
+        })
+            .action((options) => this.init(options));
+        cli.command("proxy:start")
+            .action(() => this.start());
+        cli.command("proxy:stop")
+            .action(() => this.stop());
+        cli.command("proxy:restart")
+            .action(() => this.restart());
+        cli.command("domains")
+            .option("name", {
+            type: "string",
+            alias: "n",
+            description: "Project name"
+        })
+            .action((options) => this.domainList(options));
+        cli.command("domain:set [...domains]")
+            .option("name", {
+            type: "string",
+            alias: "n",
+            description: "Project name"
+        })
+            .completion("name", () => this.getProjectNames())
+            .action((options, domains) => this.setDomains(options, domains));
+        cli.command("domain:add [...domains]")
+            .option("name", {
+            type: "string",
+            alias: "n",
+            description: "Project name"
+        })
+            .completion("name", () => this.getProjectNames())
+            .action((options, domains) => this.addDomain(options, domains));
+        cli.command("domain:remove [...domains]")
+            .option("name", {
+            type: "string",
+            alias: "n",
+            description: "Project name"
+        })
+            .completion("name", () => this.getProjectNames())
+            .completion("domains", (options, domains) => this.getDomains(options.name, domains))
+            .action((options, domains) => this.removeDomain(options, domains));
+        cli.command("domain:clear")
+            .option("name", {
+            type: "string",
+            alias: "n",
+            description: "Project name"
+        })
+            .completion("name", () => this.getProjectNames())
+            .action((options) => this.clearDomains(options));
+        cli.command("proxy:logs")
+            .action(() => this.logs());
+    }
+    async getProjectNames() {
+        const projects = await makes_1.Project.search();
+        return projects.map((project) => project.name);
+    }
+    async getDomains(name, selected) {
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        return (project.getEnv("VIRTUAL_HOST") || "").split(",").filter((domain) => {
+            return !selected.includes(domain);
+        });
+    }
+    async onProjectStart(project) {
+        if (!project.hasEnv("VIRTUAL_HOST")) {
+            project.setEnv("VIRTUAL_HOST", `${project.name}.workspace`);
+        }
+        await this.start();
+    }
+    async onProjectStop(project) {
+    }
+    async init(options) {
+        let { "http-port": httpPort, "https-port": httpsPort } = options;
+        if (typeof httpPort === "undefined" || isNaN(httpPort)) {
+            httpPort = await (0, utils_1.promptText)({
+                required: true,
+                message: "Http port:",
+                type: "int",
+                default: await this.appConfigService.getEnvVariable("PROXY_HTTP_PORT", "80")
+            });
+        }
+        await this.appConfigService.setEnvVariable("PROXY_HTTP_PORT", httpPort);
+        if (typeof httpsPort === "undefined" || isNaN(httpsPort)) {
+            httpsPort = await (0, utils_1.promptText)({
+                required: true,
+                message: "Https port:",
+                type: "int",
+                default: await this.appConfigService.getEnvVariable("PROXY_HTTPS_PORT", "443")
+            });
+        }
+        await this.appConfigService.setEnvVariable("PROXY_HTTPS_PORT", httpsPort);
+    }
+    async start() {
+        console.info("Proxy starting...");
+        await this.dockerService.pullImage("nginxproxy/nginx-proxy");
+        const httpPort = await this.appConfigService.getEnvVariable("PROXY_HTTP_PORT", "80");
+        const httpsPort = await this.appConfigService.getEnvVariable("PROXY_HTTPS_PORT", "443");
+        let container = await this.dockerService.getContainer(this.containerName);
+        if (!container) {
+            const certsDir = this.appConfigService.dataPath("certs");
+            if (!makes_1.FS.existsSync(certsDir)) {
+                makes_1.FS.mkdirSync(certsDir, {
+                    recursive: true
+                });
+            }
+            container = await this.dockerService.createContainer({
+                name: this.containerName,
+                image: "nginxproxy/nginx-proxy",
+                restart: "always",
+                env: {
+                    DEFAULT_HOST: "index.workspace"
+                },
+                ports: [
+                    `${httpPort}:80`,
+                    `${httpsPort}:443`
+                ],
+                volumes: [
+                    "/var/run/docker.sock:/tmp/docker.sock:ro",
+                    `${certsDir}:/etc/nginx/certs`
+                ]
+            });
+        }
+        else {
+            console.info("Container already exists");
+        }
+        const { State: { Status } } = await container.inspect();
+        if (["created", "exited"].includes(Status)) {
+            console.info("Starting...", Status);
+            await container.start();
+        }
+    }
+    async stop() {
+        console.info("Proxy stopping...");
+        await this.dockerService.removeContainer(this.containerName);
+    }
+    async restart() {
+        await this.stop();
+        await this.start();
+    }
+    async domainList(options) {
+        const { name } = options;
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        const table = new cli_table3_1.default({
+            head: [chalk_1.default.yellow("Domain")]
         });
-      }
-      container = await this.dockerService.createContainer({
-        name: this.containerName,
-        image: "nginxproxy/nginx-proxy",
-        volumes: ["/var/run/docker.sock:/tmp/docker.sock:ro", `${certsDir}:/etc/nginx/certs`],
-        ports: [`${httpPort}:80`, `${httpsPort}:443`],
-        env: {
-          DEFAULT_HOST: "index.workspace"
-        }
-      });
-    } else {
-      console.info("Container already exists");
-    }
-    const {
-      State: {
-        Status
-      }
-    } = await container.inspect();
-    if (["created", "exited"].includes(Status)) {
-      console.info("Starting...", Status);
-      await container.start();
-    }
-  }
-  async stop() {
-    console.info("Proxy stopping...");
-    await this.dockerService.removeContainer(this.containerName);
-  }
-  async restart() {
-    await this.stop();
-    await this.start();
-  }
-  async domainList(options) {
-    const {
-      name
-    } = options;
-    if (name) {
-      await this.projectService.cdProject(name);
-    }
-    const project = await this.projectService.get();
-    const table = new _cliTable.default({
-      head: [_chalk.default.yellow("Domain")]
-    });
-    const domains = project.getEnv("VIRTUAL_HOST", "").split(",");
-    for (const domain of domains) {
-      table.push([domain]);
-    }
-    return table.toString() + "\n";
-  }
-  async setDomains(options, domains) {
-    const {
-      name
-    } = options;
-    if (name) {
-      await this.projectService.cdProject(name);
-    }
-    const project = await this.projectService.get();
-    project.setEnv("VIRTUAL_HOST", domains.join(","));
-    project.save();
-    const container = await this.dockerService.getContainer(`${project.name}.workspace`);
-    if (container) {
-      await this.projectService.stop(project);
-      await this.projectService.start(project);
-    }
-  }
-  async addDomain(options, addDomains) {
-    const {
-      name
-    } = options;
-    if (name) {
-      await this.projectService.cdProject(name);
-    }
-    const project = await this.projectService.get();
-    let domains = project.getEnv("VIRTUAL_HOST", "").split(",").filter(domain => {
-      return !!domain;
-    });
-    domains = [...domains, ...addDomains.filter(domain => {
-      return !domains.find(existDomain => {
-        return existDomain === domain;
-      });
-    })];
-    project.setEnv("VIRTUAL_HOST", domains.join(","));
-    await project.save();
-    const container = await this.dockerService.getContainer(`${project.name}.workspace`);
-    if (container) {
-      await this.projectService.stop(project);
-      await this.projectService.start(project);
-    }
-  }
-  async removeDomain(options, removeDomains) {
-    const {
-      name
-    } = options;
-    if (name) {
-      await this.projectService.cdProject(name);
-    }
-    const project = await this.projectService.get();
-    let domains = project.getEnv("VIRTUAL_HOST", "").split(",").filter(domain => {
-      return !!domain;
-    });
-    domains = domains.filter(domain => {
-      return !removeDomains.includes(domain);
-    });
-    project.setEnv("VIRTUAL_HOST", domains.join(","));
-    await project.save();
-  }
-  async clearDomains(options) {
-    const {
-      name
-    } = options;
-    if (name) {
-      await this.projectService.cdProject(name);
-    }
-    const project = await this.projectService.get();
-    project.unsetEnv("VIRTUAL_HOST");
-    await project.save();
-    const container = await this.dockerService.getContainer(`${project.name}.workspace`);
-    if (container) {
-      await this.projectService.stop(project);
-      await this.projectService.start(project);
-    }
-  }
-  async logs() {
-    const container = await this.dockerService.getContainer(this.containerName);
-    if (!container) {
-      return;
-    }
-    const stream = await container.logs({
-      follow: true,
-      stdout: true,
-      stderr: true
-    });
-    stream.on("data", data => {
-      process.stdout.write((0, _utils2.demuxOutput)(data));
-    });
-  }
+        const domains = project.getEnv("VIRTUAL_HOST", "").split(",");
+        for (const domain of domains) {
+            table.push([domain]);
+        }
+        return table.toString() + "\n";
+    }
+    async setDomains(options, domains) {
+        const { name } = options;
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        project.setEnv("VIRTUAL_HOST", domains.join(","));
+        project.save();
+        const container = await this.dockerService.getContainer(`${project.name}.workspace`);
+        if (container) {
+            await this.projectService.stop();
+            await this.projectService.start();
+        }
+    }
+    async addDomain(options, addDomains) {
+        const { name } = options;
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        let domains = project.getEnv("VIRTUAL_HOST", "").split(",").filter((domain) => {
+            return !!domain;
+        });
+        domains = [
+            ...domains,
+            ...addDomains.filter((domain) => {
+                return !domains.find((existDomain) => {
+                    return existDomain === domain;
+                });
+            })
+        ];
+        project.setEnv("VIRTUAL_HOST", domains.join(","));
+        await project.save();
+        const container = await this.dockerService.getContainer(`${project.name}.workspace`);
+        if (container) {
+            await this.projectService.stop();
+            await this.projectService.start();
+        }
+    }
+    async removeDomain(options, removeDomains) {
+        const { name } = options;
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        let domains = project.getEnv("VIRTUAL_HOST", "").split(",").filter((domain) => {
+            return !!domain;
+        });
+        domains = domains.filter((domain) => {
+            return !removeDomains.includes(domain);
+        });
+        project.setEnv("VIRTUAL_HOST", domains.join(","));
+        await project.save();
+    }
+    async clearDomains(options) {
+        const { name } = options;
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        project.unsetEnv("VIRTUAL_HOST");
+        await project.save();
+        const container = await this.dockerService.getContainer(`${project.name}.workspace`);
+        if (container) {
+            await this.projectService.stop();
+            await this.projectService.start();
+        }
+    }
+    async logs() {
+        const container = await this.dockerService.getContainer(this.containerName);
+        if (!container) {
+            return;
+        }
+        const stream = await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true
+        });
+        stream.on("data", (data) => {
+            process.stdout.write((0, utils_2.demuxOutput)(data));
+        });
+    }
 }
-exports.ProxyController = ProxyController;
+exports.ProxyController = ProxyController;

package/lib/controllers/index.js

@@ -1,60 +1,21 @@
 "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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-  });
-});
-var _PluginController = require("./PluginController");
-Object.keys(_PluginController).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _PluginController[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _PluginController[key];
-    }
-  });
-});
-var _PresetController = require("./PresetController");
-Object.keys(_PresetController).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _PresetController[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _PresetController[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];
-    }
-  });
-});
-var _ProxyController = require("./ProxyController");
-Object.keys(_ProxyController).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _ProxyController[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _ProxyController[key];
-    }
-  });
-});
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ImageController"), exports);
+__exportStar(require("./PluginController"), exports);
+__exportStar(require("./PresetController"), exports);
+__exportStar(require("./ProjectController"), exports);
+__exportStar(require("./ProxyController"), exports);

package/lib/decorators/Inject.d.ts

@@ -0,0 +1 @@
+export declare const Inject: () => (target: any) => void;

package/lib/decorators/Inject.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = void 0;
+const Inject = () => {
+    return (target) => {
+    };
+};
+exports.Inject = Inject;

package/lib/decorators/Injectable.d.ts

@@ -0,0 +1,4 @@
+import { DI } from "../makes";
+export declare const Injectable: () => <T extends new (...rest: any[]) => {}>(Target: T) => {
+    new (di: DI): {};
+} & T;