@wocker/ws 1.0.1 → 1.0.3

package/lib/controllers/PresetController.js

@@ -0,0 +1,169 @@
+"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 __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.PresetController = void 0;
+const utils_1 = require("@wocker/utils");
+const Path = __importStar(require("path"));
+const env_1 = require("../env");
+const utils_2 = 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);
+        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();
+        return presets.map((preset) => {
+            return preset.name;
+        });
+    }
+    async onInit(project) {
+        if (project.type !== "preset") {
+            return;
+        }
+        const presets = await this.presetService.search();
+        if (presets.length === 0) {
+            throw new Error("No presets");
+        }
+        project.preset = await (0, utils_1.promptSelect)({
+            message: "Choose preset:",
+            options: presets.map((preset) => {
+                return {
+                    label: preset.name,
+                    value: preset.name
+                };
+            }),
+            default: project.preset
+        });
+        const preset = await this.presetService.get(project.preset);
+        if (!preset) {
+            throw new Error("Preset not found");
+        }
+        if (preset.buildArgsOptions) {
+            project.buildArgs = await (0, utils_1.promptConfig)(preset.buildArgsOptions, project.buildArgs);
+        }
+        if (preset.envOptions) {
+            project.env = await (0, utils_1.promptConfig)(preset.envOptions, project.env);
+        }
+        if (preset.volumeOptions) {
+            for (let volume of preset.volumeOptions) {
+                volume = (0, utils_2.injectVariables)(volume, {
+                    ...project.buildArgs || {},
+                    ...project.env || {}
+                });
+                const { destination, options } = (0, utils_2.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 : "./"
+                });
+                projectVolume = (0, utils_2.volumeFormat)({
+                    source,
+                    destination,
+                    options
+                });
+                project.volumeMount(projectVolume);
+            }
+        }
+        if (preset.dockerfile) {
+            project.imageName = preset.getImageName(project.buildArgs);
+        }
+    }
+    async onRebuild(project) {
+        if (project.type !== "preset") {
+            return;
+        }
+        const preset = await this.presetService.get(project.preset);
+        if (!preset) {
+            throw new Error(`Preset ${project.preset} not found`);
+        }
+        const imageName = preset.getImageName(project.buildArgs || {});
+        const exists = await this.dockerService.imageExists(imageName);
+        if (exists) {
+            console.info(`Removing image: ${imageName}`);
+            await this.dockerService.imageRm(imageName);
+        }
+    }
+    async onBeforeStart(project) {
+        if (project.type !== "preset") {
+            return;
+        }
+        const preset = await this.presetService.get(project.preset);
+        if (preset.dockerfile) {
+            project.imageName = preset.getImageName(project.buildArgs);
+            if (!await this.dockerService.imageExists(project.imageName)) {
+                await this.dockerService.buildImage({
+                    tag: project.imageName,
+                    labels: {
+                        presetName: preset.name
+                    },
+                    buildArgs: project.buildArgs,
+                    context: Path.join(env_1.PRESETS_DIR, preset.name),
+                    src: preset.dockerfile
+                });
+            }
+        }
+    }
+    async build(options, presetName) {
+        const preset = await this.presetService.get(presetName);
+        let buildArgs = {};
+        if (preset.buildArgsOptions) {
+            buildArgs = await (0, utils_1.promptGroup)(preset.buildArgsOptions);
+        }
+        const imageName = preset.getImageName(buildArgs);
+        await this.dockerService.buildImage({
+            tag: imageName,
+            labels: {
+                presetName: preset.name
+            },
+            buildArgs: buildArgs,
+            context: Path.join(env_1.PRESETS_DIR, preset.name),
+            src: preset.dockerfile
+        });
+    }
+}
+exports.PresetController = PresetController;

package/lib/controllers/ProjectController.d.ts

@@ -1,11 +1,14 @@
 import { Cli } from "@kearisp/cli";
-import { Controller } from "src/makes";
-import { AppConfigService, AppEventsService, ProjectService } from "src/services";
+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;
@@ -37,15 +40,20 @@ type ExecOptions = {
     name?: string;
 };
 declare class ProjectController extends Controller {
+    protected di: DI;
     protected appConfigService: AppConfigService;
     protected appEventsService: AppEventsService;
     protected projectService: ProjectService;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService);
+    protected dockerService: DockerService;
+    constructor(di: DI);
     install(cli: Cli): void;
     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>;