@wocker/ws 1.0.7 → 1.0.9

package/lib/controllers/PresetController.js

@@ -15,6 +15,12 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -22,37 +28,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresetController = void 0;
+const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
+const utils_2 = require("@wocker/utils");
 const Path = __importStar(require("path"));
 const env_1 = require("../env");
-const utils_2 = require("../utils");
+const utils_3 = require("../utils");
 const makes_1 = require("../makes");
 const services_1 = require("../services");
-class PresetController extends makes_1.Controller {
-    constructor(di) {
-        super();
-        this.appConfigService = di.resolveService(services_1.AppConfigService);
-        this.appEventsService = di.resolveService(services_1.AppEventsService);
-        this.projectService = di.resolveService(services_1.ProjectService);
-        this.presetService = di.resolveService(services_1.PresetService);
-        this.dockerService = di.resolveService(services_1.DockerService);
-    }
-    install(cli) {
-        super.install(cli);
+let PresetController = class PresetController {
+    constructor(appConfigService, appEventsService, projectService, presetService, dockerService) {
+        this.appConfigService = appConfigService;
+        this.appEventsService = appEventsService;
+        this.projectService = projectService;
+        this.presetService = presetService;
+        this.dockerService = dockerService;
         this.appConfigService.registerProjectType("preset", "Preset");
         this.appEventsService.on("project:init", (project) => this.onInit(project));
         this.appEventsService.on("project:beforeStart", (project) => this.onBeforeStart(project));
         this.appEventsService.on("project:rebuild", (project) => this.onRebuild(project));
-        cli.command("preset:build <preset>")
-            .completion("preset", () => this.presets())
-            .option("rebuild", {
-            type: "boolean",
-            alias: "r",
-            description: "Rebuild image"
-        })
-            .action((options, preset) => this.build(options, preset));
     }
     async presets() {
         const presets = await this.presetService.search();
@@ -90,18 +92,18 @@ class PresetController extends makes_1.Controller {
         }
         if (preset.volumeOptions) {
             for (let volume of preset.volumeOptions) {
-                volume = (0, utils_2.injectVariables)(volume, {
+                volume = (0, utils_3.injectVariables)(volume, {
                     ...project.buildArgs || {},
                     ...project.env || {}
                 });
-                const { destination, options } = (0, utils_2.volumeParse)(volume);
+                const { destination, options } = (0, utils_3.volumeParse)(volume);
                 let projectVolume = project.getVolumeByDestination(destination);
                 const source = await (0, utils_1.promptText)({
                     message: "Volume",
                     suffix: `:${destination}`,
-                    default: projectVolume ? (0, utils_2.volumeParse)(projectVolume).source : "./"
+                    default: projectVolume ? (0, utils_3.volumeParse)(projectVolume).source : "./"
                 });
-                projectVolume = (0, utils_2.volumeFormat)({
+                projectVolume = (0, utils_3.volumeFormat)({
                     source,
                     destination,
                     options
@@ -110,7 +112,7 @@ class PresetController extends makes_1.Controller {
             }
         }
         if (preset.dockerfile) {
-            project.imageName = preset.getImageName(project.buildArgs);
+            project.imageName = this.presetService.getImageName(preset, project.buildArgs);
         }
     }
     async onRebuild(project) {
@@ -148,7 +150,59 @@ class PresetController extends makes_1.Controller {
             }
         }
     }
-    async build(options, presetName) {
+    async eject(name) {
+        if (name) {
+            await this.projectService.cdProject(name);
+        }
+        const project = await this.projectService.get();
+        const preset = await this.presetService.get(project.preset);
+        if (!preset) {
+            throw new Error("Preset not found");
+        }
+        const confirm = await (0, utils_2.promptConfirm)({
+            message: "Confirm eject",
+            default: false
+        });
+        if (!confirm) {
+            return;
+        }
+        const source = new makes_1.FS(this.appConfigService.presetPath(preset.name));
+        const destination = new makes_1.FS(this.appConfigService.getPWD());
+        const fs = new core_1.FSManager(this.appConfigService.presetPath(preset.name), this.appConfigService.getPWD());
+        if (preset.dockerfile) {
+            if (!destination.exists(preset.dockerfile)) {
+                await fs.copy(preset.dockerfile);
+            }
+            project.type = "dockerfile";
+            project.dockerfile = preset.dockerfile;
+        }
+        const files = await source.readdirFiles("", {
+            recursive: true
+        });
+        for (const path of files) {
+            const stat = source.stat(path);
+            if (stat.isFile() && path === "config.json") {
+                continue;
+            }
+            if (stat.isFile() && path === preset.dockerfile) {
+                continue;
+            }
+            if (destination.exists(path)) {
+                continue;
+            }
+            const dir = Path.dirname(path);
+            if (!destination.exists(dir)) {
+                destination.mkdir(dir, {
+                    recursive: true
+                });
+            }
+            await fs.copy(path);
+        }
+        delete project.preset;
+        delete project.imageName;
+        await project.save();
+    }
+    async build(rebuild, presetName) {
         const preset = await this.presetService.get(presetName);
         let buildArgs = {};
         if (preset.buildArgsOptions) {
@@ -165,5 +219,35 @@ class PresetController extends makes_1.Controller {
             src: preset.dockerfile
         });
     }
-}
+};
 exports.PresetController = PresetController;
+__decorate([
+    (0, core_1.Command)("preset:eject"),
+    __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)
+], PresetController.prototype, "eject", null);
+__decorate([
+    (0, core_1.Command)("preset:build <preset>"),
+    __param(0, (0, core_1.Option)("rebuild", {
+        type: "boolean",
+        alias: "r",
+        description: "Rebuild image"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean, String]),
+    __metadata("design:returntype", Promise)
+], PresetController.prototype, "build", null);
+exports.PresetController = PresetController = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [services_1.AppConfigService,
+        services_1.AppEventsService,
+        services_1.ProjectService,
+        services_1.PresetService,
+        services_1.DockerService])
+], PresetController);

package/lib/controllers/ProjectController.d.ts

@@ -1,72 +1,29 @@
-import { Cli } from "@kearisp/cli";
-import { DI, Controller } from "../makes";
-import { AppConfigService, AppEventsService, ProjectService, DockerService } from "../services";
-type InitOptions = {
-    name?: string;
-    type?: string;
-    preset?: string;
-};
-type ListOptions = {
-    all?: boolean;
-};
-type StartOptions = {
-    name?: string;
-    rebuild?: boolean;
-    detach?: boolean;
-};
-type StopOptions = {
-    name?: string;
-};
-type AttachOptions = {
-    name?: string;
-};
-type ConfigOptions = {
-    name?: string;
-    global?: boolean;
-};
-type BuildArgsOptions = {
-    name?: string;
-};
-type VolumeOptions = {
-    name?: string;
-};
-type LogsOptions = {
-    name?: string;
-    global?: boolean;
-    detach?: boolean;
-    follow?: boolean;
-};
-type ExecOptions = {
-    name?: string;
-};
-declare class ProjectController extends Controller {
-    protected di: DI;
-    protected appConfigService: AppConfigService;
-    protected appEventsService: AppEventsService;
-    protected projectService: ProjectService;
-    protected dockerService: DockerService;
-    constructor(di: DI);
-    install(cli: Cli): void;
+import { AppConfigService, AppEventsService, ProjectService, DockerService, LogService } from "../services";
+export declare class ProjectController {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly appEventsService: AppEventsService;
+    protected readonly projectService: ProjectService;
+    protected readonly dockerService: DockerService;
+    protected readonly logService: LogService;
+    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, dockerService: DockerService, logService: LogService);
     protected getProjectNames(): Promise<string[]>;
-    protected getScripts(): Promise<string[]>;
-    init(options: InitOptions): Promise<void>;
-    projectList(options: ListOptions): Promise<string>;
-    start(options: StartOptions): Promise<void>;
-    stop(options: StopOptions): Promise<void>;
-    run(script: string): Promise<void>;
-    attach(options: AttachOptions): Promise<void>;
-    configList(options: ConfigOptions): Promise<string>;
-    configGet(options: ConfigOptions, key: string): Promise<string>;
-    configSet(options: ConfigOptions, configs: string[]): Promise<void>;
-    configUnset(options: ConfigOptions, configs: string[]): Promise<void>;
-    buildArgsList(options: BuildArgsOptions): Promise<string>;
-    buildArgsGet(options: BuildArgsOptions, args: string[]): Promise<string>;
-    buildArgsSet(options: BuildArgsOptions, args: string[]): Promise<void>;
-    buildArgsUnset(options: BuildArgsOptions, args: string[]): Promise<void>;
-    volumeList(options: VolumeOptions): Promise<string>;
-    volumeMount(options: VolumeOptions, volumes: string[]): Promise<void>;
-    volumeUnmount(options: VolumeOptions, volumes: string[]): Promise<void>;
-    logs(options: LogsOptions): Promise<void>;
-    exec(options: ExecOptions, command: string[]): Promise<void>;
+    init(name: string, type: string, preset: string): Promise<void>;
+    projectList(all: boolean): Promise<string>;
+    start(name?: string, detach?: boolean, rebuild?: boolean, restart?: boolean): Promise<void>;
+    stop(name: string): Promise<void>;
+    run(name: string, script: string): Promise<void>;
+    attach(name?: string): Promise<void>;
+    configList(name?: string, global?: boolean): Promise<string>;
+    configGet(name: string, global: boolean, keys: string[]): Promise<string>;
+    configSet(name: string, global: boolean, variables: string[]): Promise<void>;
+    configUnset(name: string, global: boolean, configs: string[]): Promise<void>;
+    buildArgsList(name?: string): Promise<string>;
+    buildArgsGet(name: string, args: string[]): Promise<string>;
+    buildArgsSet(name: string, args: string[]): Promise<void>;
+    buildArgsUnset(name: string, args: string[]): Promise<void>;
+    volumeList(name?: string): Promise<string>;
+    volumeMount(name: string, volumes: string[]): Promise<void>;
+    volumeUnmount(name: string, volumes: string[]): Promise<void>;
+    logs(name: string, global: boolean, detach: boolean, follow: boolean): Promise<void>;
+    exec(name?: string, command?: string[]): Promise<void>;
 }
-export { ProjectController };