@wocker/ws 1.0.7 → 1.0.9

package/lib/controllers/ProxyController.d.ts

@@ -1,34 +1,24 @@
-import { Controller, Cli } from "@wocker/core";
-import { DI, Project } from "../makes";
+import { Project } from "@wocker/core";
 import { AppConfigService, AppEventsService, ProjectService, DockerService } from "../services";
-type InitOptions = {
-    "http-port"?: number;
-    "https-port"?: number;
-};
-type DomainsOptions = {
-    name?: string;
-};
-declare class ProxyController extends Controller {
+export declare class ProxyController {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly appEventsService: AppEventsService;
+    protected readonly projectService: ProjectService;
+    protected readonly dockerService: DockerService;
     protected containerName: string;
-    protected appConfigService: AppConfigService;
-    protected appEventsService: AppEventsService;
-    protected projectService: ProjectService;
-    protected dockerService: DockerService;
-    constructor(di: DI);
-    install(cli: Cli): void;
-    getProjectNames(): Promise<string[]>;
-    getDomains(name: string | undefined, selected: string[]): Promise<string[]>;
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, dockerService: DockerService);
     onProjectStart(project: Project): Promise<void>;
     onProjectStop(project: Project): Promise<void>;
-    init(options: InitOptions): Promise<void>;
+    getProjectNames(): Promise<string[]>;
+    getDomains(name: string | undefined, selected: string[]): Promise<string[]>;
+    init(httpPort: number, httpsPort: number): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     restart(): 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>;
-    clearDomains(options: DomainsOptions): Promise<void>;
+    domainList(name: string): Promise<string>;
+    setDomains(name: string, domains: string[]): Promise<void>;
+    addDomain(name: string, addDomains: string[]): Promise<void>;
+    removeDomain(name: string, removeDomains: string[]): Promise<void>;
+    clearDomains(name: string): Promise<void>;
     logs(): Promise<void>;
 }
-export { ProxyController };

package/lib/controllers/ProxyController.js

@@ -1,4 +1,16 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,82 +21,27 @@ 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();
+let ProxyController = class ProxyController {
+    constructor(appConfigService, appEventsService, projectService, dockerService) {
+        this.appConfigService = appConfigService;
+        this.appEventsService = appEventsService;
+        this.projectService = projectService;
+        this.dockerService = dockerService;
         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 onProjectStart(project) {
+        if (!project.hasEnv("VIRTUAL_HOST")) {
+            project.setEnv("VIRTUAL_HOST", project.containerName);
+        }
+        await this.start();
+    }
+    async onProjectStop(project) {
     }
     async getProjectNames() {
-        const projects = await makes_1.Project.search();
+        const projects = await this.projectService.search();
         return projects.map((project) => project.name);
     }
     async getDomains(name, selected) {
@@ -96,40 +53,34 @@ class ProxyController extends core_1.Controller {
             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;
+    async init(httpPort, httpsPort) {
+        const config = await this.appConfigService.getConfig();
         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")
+                default: config.getMeta("PROXY_HTTP_PORT", "80")
             });
         }
-        await this.appConfigService.setEnvVariable("PROXY_HTTP_PORT", httpPort);
+        config.setMeta("PROXY_HTTP_PORT", httpPort.toString());
         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")
+                default: config.getMeta("PROXY_HTTPS_PORT", "443")
             });
         }
-        await this.appConfigService.setEnvVariable("PROXY_HTTPS_PORT", httpsPort);
+        config.setMeta("PROXY_HTTPS_PORT", httpsPort.toString());
+        await config.save();
     }
     async start() {
         console.info("Proxy starting...");
+        const config = await this.appConfigService.getConfig();
         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");
+        const httpPort = config.getMeta("PROXY_HTTP_PORT", "80");
+        const httpsPort = config.getMeta("PROXY_HTTPS_PORT", "443");
         let container = await this.dockerService.getContainer(this.containerName);
         if (!container) {
             const certsDir = this.appConfigService.dataPath("certs");
@@ -155,9 +106,6 @@ class ProxyController extends core_1.Controller {
                 ]
             });
         }
-        else {
-            console.info("Container already exists");
-        }
         const { State: { Status } } = await container.inspect();
         if (["created", "exited"].includes(Status)) {
             console.info("Starting...", Status);
@@ -172,8 +120,7 @@ class ProxyController extends core_1.Controller {
         await this.stop();
         await this.start();
     }
-    async domainList(options) {
-        const { name } = options;
+    async domainList(name) {
         if (name) {
             await this.projectService.cdProject(name);
         }
@@ -187,22 +134,20 @@ class ProxyController extends core_1.Controller {
         }
         return table.toString() + "\n";
     }
-    async setDomains(options, domains) {
-        const { name } = options;
+    async setDomains(name, domains) {
         if (name) {
             await this.projectService.cdProject(name);
         }
         const project = await this.projectService.get();
         project.setEnv("VIRTUAL_HOST", domains.join(","));
-        project.save();
+        await 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;
+    async addDomain(name, addDomains) {
         if (name) {
             await this.projectService.cdProject(name);
         }
@@ -226,8 +171,7 @@ class ProxyController extends core_1.Controller {
             await this.projectService.start();
         }
     }
-    async removeDomain(options, removeDomains) {
-        const { name } = options;
+    async removeDomain(name, removeDomains) {
         if (name) {
             await this.projectService.cdProject(name);
         }
@@ -241,8 +185,7 @@ class ProxyController extends core_1.Controller {
         project.setEnv("VIRTUAL_HOST", domains.join(","));
         await project.save();
     }
-    async clearDomains(options) {
-        const { name } = options;
+    async clearDomains(name) {
         if (name) {
             await this.projectService.cdProject(name);
         }
@@ -266,8 +209,120 @@ class ProxyController extends core_1.Controller {
             stderr: true
         });
         stream.on("data", (data) => {
-            process.stdout.write((0, utils_2.demuxOutput)(data));
+            process.stdout.write((0, utils_1.demuxOutput)(data));
         });
     }
-}
+};
 exports.ProxyController = ProxyController;
+__decorate([
+    (0, core_1.Completion)("name"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "getProjectNames", null);
+__decorate([
+    (0, core_1.Command)("domains"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "getDomains", null);
+__decorate([
+    (0, core_1.Command)("proxy:init"),
+    __param(0, (0, core_1.Option)("http-port", {
+        type: "number",
+        description: "Http port"
+    })),
+    __param(1, (0, core_1.Option)("https-port", {
+        type: "number",
+        description: "Https port"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "init", null);
+__decorate([
+    (0, core_1.Command)("proxy:start"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "start", null);
+__decorate([
+    (0, core_1.Command)("proxy:stop"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "stop", null);
+__decorate([
+    (0, core_1.Command)("proxy:restart"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "restart", null);
+__decorate([
+    (0, core_1.Command)("domains"),
+    __param(0, (0, core_1.Option)("name", {
+        type: "string",
+        alias: "n",
+        description: "Project name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "domainList", null);
+__decorate([
+    (0, core_1.Command)("domain:set [...domains]"),
+    __param(0, (0, core_1.Option)("name", {
+        type: "string",
+        alias: "n",
+        description: "Project name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "setDomains", null);
+__decorate([
+    (0, core_1.Command)("domain:add [...domains]"),
+    __param(0, (0, core_1.Option)("name", {
+        type: "string",
+        alias: "n",
+        description: "Project name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "addDomain", null);
+__decorate([
+    (0, core_1.Command)("domain:remove [...domains]"),
+    __param(0, (0, core_1.Option)("name", {
+        type: "string",
+        alias: "n",
+        description: "Project name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "removeDomain", null);
+__decorate([
+    (0, core_1.Command)("domain:clear"),
+    __param(0, (0, core_1.Option)("name", {
+        type: "string",
+        alias: "n",
+        description: "Project name"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "clearDomains", null);
+__decorate([
+    (0, core_1.Command)("proxy:logs"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ProxyController.prototype, "logs", null);
+exports.ProxyController = ProxyController = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [services_1.AppConfigService,
+        services_1.AppEventsService,
+        services_1.ProjectService,
+        services_1.DockerService])
+], ProxyController);

package/lib/controllers/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./CompletionController";
+export * from "./DebugController";
 export * from "./ImageController";
 export * from "./PluginController";
 export * from "./PresetController";

package/lib/controllers/index.js

@@ -14,6 +14,8 @@ 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("./CompletionController"), exports);
+__exportStar(require("./DebugController"), exports);
 __exportStar(require("./ImageController"), exports);
 __exportStar(require("./PluginController"), exports);
 __exportStar(require("./PresetController"), exports);

package/lib/main.d.ts

@@ -0,0 +1,3 @@
+export declare const app: {
+    run(args: string[]): Promise<void>;
+};

package/lib/main.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const core_1 = require("@wocker/core");
+const chalk_1 = __importDefault(require("chalk"));
+const AppModule_1 = require("./AppModule");
+const services_1 = require("./services");
+exports.app = {
+    async run(args) {
+        const app = await core_1.Factory.create(AppModule_1.AppModule);
+        const config = app.get(services_1.AppConfigService);
+        const logger = app.get(services_1.LogService);
+        try {
+            const res = await app.run(args);
+            if (res) {
+                process.stdout.write(res);
+            }
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(err.message));
+            const { debug } = await config.getConfig();
+            if (debug) {
+                logger.error(err.stack || err.message);
+            }
+        }
+    }
+};

package/lib/makes/FS.d.ts

@@ -2,17 +2,27 @@
 /// <reference types="node" />
 import { FS as CoreFS } from "@wocker/core";
 import * as fs from "fs";
-import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from "fs";
+import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, ObjectEncodingOptions, MakeDirectoryOptions } from "fs";
 import { PassThrough } from "readable-stream";
+type ReaddirOptions = ObjectEncodingOptions & {
+    recursive?: boolean;
+};
 type ReaddirFilesOptions = {
     recursive?: boolean;
 };
-declare class FS extends CoreFS {
+export declare class FS extends CoreFS {
+    protected source: string;
+    constructor(source: string);
+    path(...parts: string[]): string;
+    exists(...parts: string[]): boolean;
+    stat(...parts: string[]): fs.Stats;
+    mkdir(path: string, options?: MakeDirectoryOptions): void;
+    readdir(...parts: string[]): Promise<string[]>;
+    readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
     static access(path: PathLike): Promise<any>;
-    static exists(path: PathLike): Promise<boolean>;
     static existsSync(path: PathLike): boolean;
     static mkdir(dirPath: string, options?: MakeDirectoryOptions): Promise<void>;
-    static mkdirSync(path: any, options?: MakeDirectoryOptions): string;
+    static mkdirSync(path: string, options?: MakeDirectoryOptions): string;
     static readdir(path: PathLike): Promise<string[]>;
     static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
     static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
@@ -28,4 +38,4 @@ declare class FS extends CoreFS {
     static createReadLinesStream(path: PathLike, count?: number): PassThrough;
     static copyFile(src: PathLike, dest: PathLike): Promise<void>;
 }
-export { FS };
+export {};

package/lib/makes/FS.js

@@ -29,6 +29,45 @@ const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
 const readable_stream_1 = require("readable-stream");
 class FS extends core_1.FS {
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    path(...parts) {
+        return Path.join(this.source, ...parts);
+    }
+    exists(...parts) {
+        const fullPath = this.path(...parts);
+        return FS.existsSync(fullPath);
+    }
+    stat(...parts) {
+        const fullPath = this.path(...parts);
+        return fs.statSync(fullPath);
+    }
+    mkdir(path, options) {
+        const fullPath = this.path(path);
+        fs.mkdirSync(fullPath, options);
+    }
+    async readdir(...parts) {
+        const fullPath = this.path(...parts);
+        return FS.readdir(fullPath);
+    }
+    async readdirFiles(path, options) {
+        const fullPath = this.path(path);
+        return new Promise((resolve, reject) => {
+            fs.readdir(fullPath, options, (err, files) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                files = files.filter((path) => {
+                    const stat = this.stat(path);
+                    return stat.isFile();
+                });
+                resolve(files);
+            });
+        });
+    }
     static async access(path) {
         return new Promise((resolve, reject) => {
             fs.access(path, (err) => {
@@ -41,13 +80,6 @@ class FS extends core_1.FS {
             });
         });
     }
-    static async exists(path) {
-        return new Promise((resolve) => {
-            fs.exists(path, (exists) => {
-                resolve(exists);
-            });
-        });
-    }
     static existsSync(path) {
         return fs.existsSync(path);
     }
@@ -106,7 +138,8 @@ class FS extends core_1.FS {
                 withFileTypes: true
             }, (err, files) => {
                 if (err) {
-                    return reject(err);
+                    reject(err);
+                    return;
                 }
                 const names = files.filter((dirent) => {
                     return dirent.isFile();
@@ -160,7 +193,7 @@ class FS extends core_1.FS {
                     reject(err);
                     return;
                 }
-                fs.read(file, buffer, 0, buffer.length, position, (err, bytesRead, buffer) => {
+                fs.read(file, buffer, 0, buffer.length, position, (err, _, buffer) => {
                     if (err) {
                         reject(err);
                         return;

package/lib/makes/Http.d.ts

@@ -0,0 +1,18 @@
+import { AxiosHeaders, AxiosResponse } from "axios";
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export declare class Http {
+    readonly method: HttpMethod;
+    readonly url: string;
+    body?: any;
+    protected headers: AxiosHeaders;
+    private constructor();
+    withHeader(name: string, value: string): Http;
+    withBody(body: any): Http;
+    send(path: string): Promise<AxiosResponse>;
+    static get(url: string): Http;
+    static post(url: string): Http;
+    static put(url: string): Http;
+    static patch(url: string): Http;
+    static delete(url: string): Http;
+}
+export {};