@wocker/ws 1.0.21 → 1.0.23

package/lib/services/PresetService.js

@@ -1,43 +1,10 @@
 "use strict";
-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;
-});
 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 __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -49,79 +16,78 @@ exports.PresetService = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
 const md5_1 = __importDefault(require("md5"));
-const axios_1 = __importDefault(require("axios"));
-const unzipper_1 = require("unzipper");
-const Path = __importStar(require("path"));
 const AppConfigService_1 = require("./AppConfigService");
 const LogService_1 = require("./LogService");
-const env_1 = require("../env");
-const makes_1 = require("../makes");
+const PresetRepository_1 = require("../repositories/PresetRepository");
+const GithubClient_1 = require("../makes/GithubClient");
 let PresetService = class PresetService {
-    constructor(appConfigService, logService) {
+    constructor(appConfigService, presetRepository, logService) {
         this.appConfigService = appConfigService;
+        this.presetRepository = presetRepository;
         this.logService = logService;
     }
-    toObject(config) {
-        const _this = this;
-        return new class extends core_1.Preset {
-            constructor(data) {
-                super(data);
-            }
-            async save() {
-                const { source, path, ...rest } = this.toJSON();
-                const config = _this.appConfigService.getConfig();
-                let presetData = (config.presets || []).find((presetData) => {
-                    return presetData.name === this.name;
-                });
-                switch (this.source) {
-                    case core_1.PRESET_SOURCE_EXTERNAL:
-                        const fs = new core_1.FileSystem(this.path);
-                        fs.writeJSON("config.json", rest);
-                        break;
-                    case core_1.PRESET_SOURCE_GITHUB: {
-                        const fs = new core_1.FileSystem(_this.appConfigService.dataPath("presets", this.name));
-                        if (!fs.exists()) {
-                            fs.mkdir("");
+    async prompt(configMap, values = {}) {
+        for (const name in configMap) {
+            const config = configMap[name];
+            switch (config.type) {
+                case "boolean": {
+                    const value = await (0, utils_1.promptConfirm)({
+                        message: config.message,
+                        required: config.required,
+                        default: typeof values[name] !== "undefined" && values[name] === "true"
+                            ? true
+                            : undefined,
+                    });
+                    values[name] = value.toString();
+                    break;
+                }
+                case "select": {
+                    const result = await (0, utils_1.promptSelect)({
+                        required: config.required,
+                        multiple: config.multiple,
+                        message: config.message,
+                        options: config.options,
+                        default: values[name]
+                    });
+                    if (!config.multiple) {
+                        values[name] = result;
+                    }
+                    else {
+                        const options = (0, utils_1.normalizeOptions)(config.options);
+                        for (const option of options) {
+                            if (result.includes(option.value)) {
+                                values[option.value] = "true";
+                            }
+                            else if (option.value in values) {
+                                delete values[option.value];
+                            }
                         }
-                        fs.writeJSON("config.json", rest);
-                        break;
                     }
+                    break;
                 }
-                if (!presetData) {
-                    config.registerPreset(this.name, source, path);
-                    await config.save();
+                case "int":
+                case "number": {
+                    const result = await (0, utils_1.promptInput)({
+                        ...config,
+                        type: "number",
+                        default: values[name] || config.default
+                    });
+                    values[name] = result.toString();
+                    break;
                 }
-            }
-            async delete() {
-                if (this.source === core_1.PRESET_SOURCE_GITHUB) {
-                    const config = _this.appConfigService.getConfig();
-                    await makes_1.FS.rm(_this.appConfigService.dataPath("presets", this.name), {
-                        recursive: true
+                case "string":
+                case "text":
+                case "password": {
+                    values[name] = await (0, utils_1.promptInput)({
+                        ...config,
+                        type: config.type === "string" ? "text" : config.type,
+                        default: values[name] || config.default
                     });
-                    config.unregisterPreset(this.name);
-                    await config.save();
+                    break;
                 }
             }
-        }(config);
-    }
-    async getList() {
-        const dirs = await makes_1.FS.readdir(env_1.PRESETS_DIR);
-        const { presets = [] } = this.appConfigService.getConfig();
-        return [
-            ...dirs.map((name) => {
-                return {
-                    name,
-                    source: core_1.PRESET_SOURCE_INTERNAL,
-                    path: Path.join(env_1.PRESETS_DIR, name)
-                };
-            }),
-            ...presets.map((item) => {
-                if (item.source === core_1.PRESET_SOURCE_GITHUB) {
-                    item.path = this.appConfigService.dataPath("presets", item.name);
-                }
-                return item;
-            })
-        ];
+        }
+        return values;
     }
     getImageNameForProject(project, preset) {
         switch (project.presetMode) {
@@ -132,8 +98,7 @@ let PresetService = class PresetService {
         }
     }
     getImageName(preset, buildArgs) {
-        const rawValues = [];
-        const hashValues = [];
+        const rawValues = [], hashValues = [];
         Object.keys(preset.buildArgsOptions || {}).forEach((key) => {
             const hash = (preset.buildArgsOptions[key] || {}).hash || true;
             const value = buildArgs[key];
@@ -153,208 +118,128 @@ let PresetService = class PresetService {
         return `ws-preset-${preset.name}:${version}`;
     }
     async init() {
-        let preset = await this.searchOne({
+        const fs = new core_1.FileSystem(this.appConfigService.pwd());
+        let preset = this.presetRepository.searchOne({
             path: this.appConfigService.pwd()
         });
-        const fs = new core_1.FileSystem(this.appConfigService.pwd());
-        if (!preset) {
-            if (!fs.exists("config.json")) {
-                preset = this.toObject({
-                    name: "",
-                    version: "",
-                    source: "external",
-                    path: this.appConfigService.pwd()
-                });
-            }
-            else {
-                preset = this.toObject(fs.readJSON("config.json"));
-                preset.source = "external";
-                preset.path = this.appConfigService.pwd();
-            }
+        if (preset) {
+            return;
         }
-        if (!preset.name) {
-            const list = await this.getList();
-            preset.name = await (0, utils_1.promptText)({
-                message: "Preset name:",
-                required: true,
-                validate: async (value) => {
-                    if (!/^[a-z][a-z0-9-_]+$/.test(value || "")) {
-                        return "Invalid name";
-                    }
-                    const presetData = list.find((presetData) => {
-                        return presetData.name === value;
-                    });
-                    if (presetData) {
-                        return "Preset name is already taken";
-                    }
-                    return true;
-                },
-                default: preset.name
-            });
+        if (fs.exists("config.json")) {
+            const config = fs.readJSON("config.json");
+            this.appConfigService.registerPreset(config.name, core_1.PRESET_SOURCE_EXTERNAL, fs.path());
+            return;
         }
-        if (!preset.version) {
-            preset.version = await (0, utils_1.promptText)({
-                message: "Preset version:",
-                validate: (version) => {
-                    if (!/^[0-9]+\.[0.9]+\.[0-9]+$/.test(version)) {
-                        return "Invalid version";
-                    }
+        let config = {};
+        config.name = await (0, utils_1.promptInput)({
+            message: "Preset name",
+            required: true,
+            validate: (name) => {
+                if (!name || typeof name !== "string") {
                     return true;
-                },
-                default: preset.version
-            });
-        }
-        if (!preset.type) {
-            preset.type = await (0, utils_1.promptSelect)({
-                message: "Preset type:",
-                options: ["dockerfile", "image"]
-            });
-        }
-        switch (preset.type) {
+                }
+                if (this.presetRepository.searchOne({ name })) {
+                    return "Preset name already taken";
+                }
+                return true;
+            }
+        });
+        config.version = await (0, utils_1.promptInput)({
+            message: "Preset version",
+            validate: (version) => {
+                if (!/^[0-9]+\.[0-9]+\.[0-9]+$/.test(version)) {
+                    return "Invalid version";
+                }
+                return true;
+            }
+        });
+        config.type = await (0, utils_1.promptSelect)({
+            message: "Preset type",
+            options: ["dockerfile", "image"]
+        });
+        switch (config.type) {
             case "dockerfile":
-                if (!preset.dockerfile) {
-                    const files = await fs.readdirFiles();
-                    const dockerfiles = files.filter((fileName) => {
-                        if (new RegExp("^(.*)\\.dockerfile$").test(fileName)) {
-                            return true;
-                        }
-                        return new RegExp("^Dockerfile(\\..*)?").test(fileName);
-                    });
-                    if (dockerfiles.length === 0) {
-                        throw new Error("No dockerfiles found");
+                const files = await fs.readdirFiles();
+                const dockerfiles = files.filter((fileName) => {
+                    if (new RegExp("^(.*)\\.dockerfile$").test(fileName)) {
+                        return true;
                     }
-                    preset.dockerfile = await (0, utils_1.promptSelect)({
-                        message: "Preset dockerfile:",
-                        options: dockerfiles
-                    });
+                    return new RegExp("^Dockerfile(\\..*)?").test(fileName);
+                });
+                if (dockerfiles.length === 0) {
+                    throw new Error("No dockerfiles found");
                 }
+                config.dockerfile = await (0, utils_1.promptSelect)({
+                    message: "Preset dockerfile",
+                    options: dockerfiles
+                });
                 break;
             case "image":
-                if (preset.image) {
-                    preset.image = await (0, utils_1.promptText)({
-                        message: "Preset image:",
-                        required: true,
-                        validate(value) {
-                            if (!/^[a-z0-9]+(?:[._-][a-z0-9]+)*(?::[a-z0-9]+(?:[._-][a-z0-9]+)*)?$/.test(value)) {
-                                return "Invalid image name";
-                            }
-                            return true;
+                config.image = await (0, utils_1.promptInput)({
+                    message: "Preset image",
+                    required: true,
+                    validate(value) {
+                        if (!/^[a-z0-9]+(?:[._-][a-z0-9]+)*(?::[a-z0-9]+(?:[._-][a-z0-9]+)*)?$/.test(value)) {
+                            return "Invalid image name";
                         }
-                    });
-                }
+                        return true;
+                    }
+                });
                 break;
         }
-        console.info(JSON.stringify(preset.toJSON(), null, 4));
+        console.info(JSON.stringify(config, null, 4));
         const confirm = await (0, utils_1.promptConfirm)({
-            message: "Correct?"
+            message: "Correct",
+            default: true
         });
-        if (confirm) {
-            await preset.save();
+        if (!confirm) {
+            return;
         }
+        fs.writeJSON("config.json", config);
+        this.appConfigService.registerPreset(config.name, core_1.PRESET_SOURCE_EXTERNAL, fs.path());
     }
     async deinit() {
-        const preset = await this.searchOne({
+        const preset = this.presetRepository.searchOne({
             path: this.appConfigService.pwd()
         });
         if (!preset) {
             return;
         }
-        const config = this.appConfigService.getConfig();
-        config.unregisterPreset(preset.name);
-        await config.save();
+        this.appConfigService.config.unregisterPreset(preset.name);
+        this.appConfigService.save();
     }
-    async get(name) {
-        const list = await this.getList();
-        const item = list.find((item) => {
-            return item.name === name;
-        });
-        if (!item) {
-            throw new Error(`Preset ${name} not found`);
+    get(name) {
+        const preset = name
+            ? this.presetRepository.searchOne({ name })
+            : this.presetRepository.searchOne({ path: this.appConfigService.pwd() });
+        if (!preset) {
+            throw new Error(name ? `Preset "${name}" not found` : "Preset not found");
         }
-        const config = await makes_1.FS.readJSON(item.path, "config.json");
-        return this.toObject({
-            ...item,
-            ...config
-        });
+        return preset;
     }
-    async addPreset(name, version) {
-        let preset = await this.searchOne({
+    async addPreset(name, repository, version) {
+        let preset = this.presetRepository.searchOne({
             name
         });
         if (!preset) {
             console.info("Loading...");
-            const res = await makes_1.Http.get("https://raw.githubusercontent.com")
-                .withHeader("User-Agent", "Wocker")
-                .send(`/kearisp/wocker-${name}-preset/master/config.json`);
-            preset = this.toObject(res.data);
-            preset.source = core_1.PRESET_SOURCE_GITHUB;
-            preset.path = this.appConfigService.dataPath("presets", preset.name);
-            const zipRes = await axios_1.default.create({
-                baseURL: "https://github.com",
-                headers: {
-                    "User-Agent": "Wocker"
-                }
-            }).get(`/kearisp/wocker-${preset.name}-preset/archive/refs/heads/master.zip`, {
-                responseType: "stream"
-            });
-            makes_1.FS.mkdirSync(preset.path, {
-                recursive: true
-            });
-            zipRes.data.pipe((0, unzipper_1.Parse)()).on("entry", (entry) => {
-                const path = entry.path.replace(/^[^\/]+\//, "");
-                if (path === "config.json") {
-                    return;
-                }
-                const fullPath = this.appConfigService.dataPath("presets", preset.name, path);
-                if (entry.type === "File") {
-                    entry.pipe(makes_1.FS.createWriteStream(fullPath));
-                }
-                else if (entry.type === "Directory") {
-                    makes_1.FS.mkdirSync(fullPath, {
-                        recursive: true
-                    });
-                }
-            });
-            await preset.save();
-        }
-        console.log(preset.version);
-    }
-    async search(options = {}) {
-        const { name, source, path } = options;
-        const presets = [];
-        const presetConfigs = await this.getList();
-        for (const presetConfig of presetConfigs) {
-            if (name && name !== presetConfig.name) {
-                continue;
-            }
-            if (source && source !== presetConfig.source) {
-                continue;
-            }
-            if (path && path !== presetConfig.path) {
-                continue;
-            }
-            try {
-                const fullConfig = await makes_1.FS.readJSON(presetConfig.path, "config.json");
-                const preset = this.toObject({
-                    ...presetConfig,
-                    ...fullConfig
-                });
-                presets.push(preset);
-            }
-            catch (err) {
-                this.logService.error("PresetService.search(", options, ") ->", err.message);
+            if (!repository) {
+                repository = `kearisp/wocker-${name}-preset`;
             }
+            const [owner, repo] = repository.split("/");
+            const github = new GithubClient_1.GithubClient(owner, repo);
+            const info = await github.getInfo();
+            const config = await github.getFile(info.default_branch, "config.json");
+            console.log(config);
+            await github.download(info.default_branch, this.appConfigService.fs.path(`presets/${name}`));
+            this.appConfigService.registerPreset(name, core_1.PRESET_SOURCE_GITHUB);
         }
-        return presets;
-    }
-    async searchOne(options = {}) {
-        const [preset] = await this.search(options);
-        return preset || null;
     }
 };
 exports.PresetService = PresetService;
 exports.PresetService = PresetService = __decorate([
     (0, core_1.Injectable)(),
     __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        PresetRepository_1.PresetRepository,
         LogService_1.LogService])
 ], PresetService);

package/lib/services/ProjectService.d.ts

@@ -1,24 +1,27 @@
 import { Project, ProjectProperties } from "@wocker/core";
+import { DockerService } from "../modules/docker";
+import { KeystoreService } from "../modules/keystore";
 import { AppConfigService } from "./AppConfigService";
 import { AppEventsService } from "./AppEventsService";
-import { DockerService } from "./DockerService";
 type SearchParams = Partial<{
     name: string;
     path: string;
 }>;
-declare class ProjectService {
+export declare class ProjectService {
     protected readonly appConfigService: AppConfigService;
     protected readonly appEventsService: AppEventsService;
+    protected readonly keystoreService: KeystoreService;
     protected readonly dockerService: DockerService;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, dockerService: DockerService);
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, keystoreService: KeystoreService, dockerService: DockerService);
     fromObject(data: Partial<ProjectProperties>): Project;
     get(name?: string): Project;
     getById(id: string): Project;
     cdProject(name: string): void;
     start(project: Project, restart?: boolean, rebuild?: boolean): Promise<void>;
     stop(project: Project): Promise<void>;
-    save(project: Project): Promise<void>;
+    save(project: Project): void;
     search(params?: Partial<SearchParams>): Project[];
     searchOne(params?: Partial<SearchParams>): Project | null;
+    logs(detach?: boolean): Promise<void>;
 }
-export { ProjectService };
+export {};

package/lib/services/ProjectService.js

@@ -11,13 +11,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectService = void 0;
 const core_1 = require("@wocker/core");
+const docker_1 = require("../modules/docker");
+const keystore_1 = require("../modules/keystore");
 const AppConfigService_1 = require("./AppConfigService");
 const AppEventsService_1 = require("./AppEventsService");
-const DockerService_1 = require("./DockerService");
 let ProjectService = class ProjectService {
-    constructor(appConfigService, appEventsService, dockerService) {
+    constructor(appConfigService, appEventsService, keystoreService, dockerService) {
         this.appConfigService = appConfigService;
         this.appEventsService = appEventsService;
+        this.keystoreService = keystoreService;
         this.dockerService = dockerService;
     }
     fromObject(data) {
@@ -26,8 +28,14 @@ let ProjectService = class ProjectService {
             constructor(data) {
                 super(data);
             }
-            async save() {
-                await _this.save(this);
+            async getSecret(key, defaultValue) {
+                return _this.keystoreService.get(`p:${this.name}:${key}`, defaultValue);
+            }
+            async setSecret(key, value) {
+                return _this.keystoreService.set(`p:${this.name}:${key}`, value);
+            }
+            save() {
+                _this.save(this);
             }
         }(data);
     }
@@ -46,12 +54,11 @@ let ProjectService = class ProjectService {
         return project;
     }
     getById(id) {
-        const config = this.appConfigService.getConfig();
-        const projectData = config.getProject(id);
+        const projectData = this.appConfigService.config.getProject(id);
         const data = this.appConfigService.fs.readJSON("projects", id, "config.json");
         return this.fromObject({
             ...data,
-            path: projectData.path || projectData.src
+            path: projectData.path
         });
     }
     cdProject(name) {
@@ -128,7 +135,7 @@ let ProjectService = class ProjectService {
         await this.appEventsService.emit("project:stop", project);
         await this.dockerService.removeContainer(project.containerName);
     }
-    async save(project) {
+    save(project) {
         if (!project.name) {
             throw new Error("Project should has a name");
         }
@@ -138,27 +145,27 @@ let ProjectService = class ProjectService {
         if (!project.id) {
             project.id = project.name;
         }
-        const config = this.appConfigService.getConfig();
         if (!this.appConfigService.fs.exists(`projects/${project.id}`)) {
-            this.appConfigService.fs.mkdir(`projects/${project.id}`, { recursive: true });
+            this.appConfigService.fs.mkdir(`projects/${project.id}`, {
+                recursive: true
+            });
         }
         const { path, ...rest } = project.toJSON();
-        config.addProject(project.id, project.name, path);
+        this.appConfigService.addProject(project.id, project.name, path);
         this.appConfigService.fs.writeJSON(`projects/${project.id}/config.json`, rest);
-        await config.save();
+        this.appConfigService.save();
     }
     search(params = {}) {
         const { name, path } = params;
-        const config = this.appConfigService.getConfig();
         const projects = [];
-        for (const projectConfig of config.projects || []) {
-            if (name && projectConfig.name !== name) {
+        for (const projectRef of this.appConfigService.projects || []) {
+            if (name && projectRef.name !== name) {
                 continue;
             }
-            if (path && (projectConfig.path || projectConfig.src) !== path) {
+            if (path && projectRef.path !== path) {
                 continue;
             }
-            const project = this.getById(projectConfig.id);
+            const project = this.getById(projectRef.name);
             if (name && project.name !== name) {
                 continue;
             }
@@ -170,11 +177,30 @@ let ProjectService = class ProjectService {
         const [project] = this.search(params);
         return project || null;
     }
+    async logs(detach) {
+        const project = this.get();
+        const container = await this.dockerService.getContainer(project.containerName);
+        if (!container) {
+            throw new Error("Project not started");
+        }
+        if (!detach) {
+            await this.dockerService.logs(container);
+        }
+        else {
+            const data = await container.logs({
+                stdout: true,
+                stderr: true,
+                follow: false
+            });
+            process.stdout.write(data);
+        }
+    }
 };
 exports.ProjectService = ProjectService;
 exports.ProjectService = ProjectService = __decorate([
     (0, core_1.Injectable)("PROJECT_SERVICE"),
     __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
         AppEventsService_1.AppEventsService,
-        DockerService_1.DockerService])
+        keystore_1.KeystoreService,
+        docker_1.DockerService])
 ], ProjectService);

package/lib/utils/followProgress2.d.ts

@@ -0,0 +1 @@
+export declare const followProgress2: (stream: NodeJS.ReadableStream) => Promise<void>;