@wocker/ws 1.0.2 → 1.0.3

package/lib/controllers/PresetController.js

@@ -1,150 +1,169 @@
 "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;
 });
+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;
-var _core = require("@wocker/core");
-var _utils = require("@wocker/utils");
-var Path = _interopRequireWildcard(require("path"));
-var _env = require("../env");
-var _utils2 = require("../utils");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-class PresetController extends _core.Controller {
-  constructor(di) {
-    super();
-    this.appConfigService = di.resolveService(_core.AppConfigService);
-    this.appEventsService = di.resolveService(_core.AppEventsService);
-    this.projectService = di.resolveService(_core.ProjectService);
-    this.presetService = di.resolveService(_core.PresetService);
-    this.dockerService = di.resolveService(_core.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.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");
+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);
     }
-    if (preset.buildArgsOptions) {
-      project.buildArgs = await (0, _utils.promptConfig)(preset.buildArgsOptions, project.buildArgs);
+    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));
     }
-    if (preset.envOptions) {
-      project.env = await (0, _utils.promptConfig)(preset.envOptions, project.env);
-    }
-    if (preset.volumeOptions) {
-      for (let volume of preset.volumeOptions) {
-        volume = (0, _utils2.injectVariables)(volume, {
-          ...(project.buildArgs || {}),
-          ...(project.env || {})
-        });
-        const {
-          destination,
-          options
-        } = (0, _utils2.volumeParse)(volume);
-        let projectVolume = project.getVolumeByDestination(destination);
-        const source = await (0, _utils.promptText)({
-          message: "Volume",
-          suffix: `:${destination}`,
-          default: projectVolume ? (0, _utils2.volumeParse)(projectVolume).source : "./"
+    async presets() {
+        const presets = await this.presetService.search();
+        return presets.map((preset) => {
+            return preset.name;
         });
-        projectVolume = (0, _utils2.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`);
+    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);
+        }
     }
-    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 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;
+    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
+                });
+            }
+        }
     }
-    const preset = await this.presetService.get(project.preset);
-    if (preset.dockerfile) {
-      project.imageName = preset.getImageName(project.buildArgs);
-      if (!(await this.dockerService.imageExists(project.imageName))) {
+    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: project.imageName,
-          labels: {
-            presetName: preset.name
-          },
-          buildArgs: project.buildArgs,
-          context: Path.join(_env.PRESETS_DIR, preset.name),
-          src: preset.dockerfile
+            tag: imageName,
+            labels: {
+                presetName: preset.name
+            },
+            buildArgs: 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.promptGroup)(preset.buildArgsOptions);
     }
-    const imageName = preset.getImageName(buildArgs);
-    await this.dockerService.buildImage({
-      tag: imageName,
-      labels: {
-        presetName: preset.name
-      },
-      buildArgs: buildArgs,
-      context: Path.join(_env.PRESETS_DIR, preset.name),
-      src: preset.dockerfile
-    });
-  }
 }
-exports.PresetController = PresetController;
+exports.PresetController = PresetController;

package/lib/controllers/ProjectController.d.ts

@@ -1,6 +1,6 @@
-import { DI, AppConfigService as CoreAppConfigService, AppEventsService as CoreAppEventsService, ProjectService as CoreProjectService, DockerService } from "@wocker/core";
 import { Cli } from "@kearisp/cli";
-import { Controller } from "src/makes";
+import { DI, Controller } from "../makes";
+import { AppConfigService, AppEventsService, ProjectService, DockerService } from "../services";
 type InitOptions = {
     name?: string;
     type?: string;
@@ -41,9 +41,9 @@ type ExecOptions = {
 };
 declare class ProjectController extends Controller {
     protected di: DI;
-    protected appConfigService: CoreAppConfigService;
-    protected appEventsService: CoreAppEventsService;
-    protected projectService: CoreProjectService;
+    protected appConfigService: AppConfigService;
+    protected appEventsService: AppEventsService;
+    protected projectService: ProjectService;
     protected dockerService: DockerService;
     constructor(di: DI);
     install(cli: Cli): void;