@wocker/ws 1.0.1 → 1.0.3

package/lib/{plugins/ProxyPlugin.d.ts → controllers/ProxyController.d.ts}

@@ -1,7 +1,6 @@
-import { Cli } from "@kearisp/cli";
-import { Plugin } from "src/makes";
-import { Project } from "src/models";
-import { AppConfigService, AppEventsService, ProjectService } from "src/services";
+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;
@@ -9,25 +8,27 @@ type InitOptions = {
 type DomainsOptions = {
     name?: string;
 };
-declare class ProxyPlugin extends Plugin {
+declare class ProxyController extends Controller {
+    protected containerName: string;
     protected appConfigService: AppConfigService;
     protected appEventsService: AppEventsService;
     protected projectService: ProjectService;
-    protected containerName: string;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService);
+    protected dockerService: DockerService;
+    constructor(di: DI);
     install(cli: Cli): void;
     getProjectNames(): Promise<string[]>;
+    getDomains(name: string | undefined, selected: string[]): Promise<string[]>;
     onProjectStart(project: Project): Promise<void>;
-    createNetwork(): Promise<void>;
+    onProjectStop(project: Project): Promise<void>;
     init(options: InitOptions): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     restart(): Promise<void>;
-    logs(): Promise<void>;
     domainList(options: DomainsOptions): Promise<string>;
+    setDomains(options: DomainsOptions, domains: string[]): Promise<void>;
     addDomain(options: DomainsOptions, addDomains: string[]): Promise<void>;
     removeDomain(options: DomainsOptions, removeDomains: string[]): Promise<void>;
-    setDomains(options: DomainsOptions, domains: string[]): Promise<void>;
     clearDomains(options: DomainsOptions): Promise<void>;
+    logs(): Promise<void>;
 }
-export { ProxyPlugin };
+export { ProxyController };

package/lib/controllers/ProxyController.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyController = void 0;
+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")]
+        });
+        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;

package/lib/controllers/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./ImageController";
+export * from "./PluginController";
+export * from "./PresetController";
 export * from "./ProjectController";
+export * from "./ProxyController";

package/lib/controllers/index.js

@@ -1,27 +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 _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];
-    }
-  });
-});
+    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/env.js

@@ -1,24 +1,35 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-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;
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAP_PATH = exports.DATA_DIR = exports.PLUGINS_DIR = exports.SERVICES_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = void 0;
+const OS = __importStar(require("os"));
+const Path = __importStar(require("path"));
+exports.NODE_ENV = process.env.NODE_ENV;
+exports.ROOT_DIR = Path.join(__dirname, "..");
+exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");
+exports.SERVICES_DIR = Path.join(exports.ROOT_DIR, "services");
+exports.PLUGINS_DIR = Path.join(exports.ROOT_DIR, "plugins");
+exports.DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
+exports.MAP_PATH = Path.join(exports.DATA_DIR, "data.json");

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,31 +1,32 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+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]; } };
+    }
+    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 });
 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);
+const App_1 = require("./App");
+const plugins_1 = require("./plugins");
+const app = new App_1.App();
 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());
+app.use(plugins_1.ElasticSearchPlugin);
+app.use(plugins_1.LocaltunnelPlugin);
+app.use(plugins_1.MaildevPlugin);
+app.use(plugins_1.MongodbPlugin);
+app.use(plugins_1.NgrokPlugin);
+app.use(plugins_1.PageKitePlugin);
+app.use(plugins_1.PostgresPlugin);
+app.use(plugins_1.ProxmoxPlugin);
+app.use(plugins_1.RedisPlugin);
+__exportStar(require("./makes"), exports);
+__exportStar(require("./services"), exports);

package/lib/makes/Controller.js

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

package/lib/makes/DI.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+declare class DI {
+    private services;
+    resolveService<T>(key: any): T;
+    registerService(key: any, service: any): void;
+}
+export { DI };

package/lib/makes/DI.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DI = void 0;
+require("reflect-metadata");
+class DI {
+    constructor() {
+        this.services = new Map();
+    }
+    resolveService(key) {
+        let res = this.services.get(key);
+        if (!res) {
+            const types = Reflect.getMetadata("design:paramtypes", key);
+            if (types && types.length > 0) {
+                types.forEach((type) => {
+                    this.resolveService(type);
+                });
+            }
+            res = new key(this);
+            this.services.set(key, res);
+        }
+        return res;
+    }
+    registerService(key, service) {
+        this.services.set(key, service);
+    }
+}
+exports.DI = DI;