@wocker/ws 1.0.23 → 1.0.25

package/lib/modules/project/controllers/ProjectController.js

@@ -0,0 +1,143 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectController = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const path_1 = __importDefault(require("path"));
+const preset_1 = require("../../preset");
+const ProjectService_1 = require("../services/ProjectService");
+let ProjectController = class ProjectController {
+    constructor(appConfigService, processService, projectService, presetService) {
+        this.appConfigService = appConfigService;
+        this.processService = processService;
+        this.projectService = projectService;
+        this.presetService = presetService;
+    }
+    async start(name, restart, build, attach) {
+        const project = this.projectService.get(name);
+        await this.projectService.start(project, restart, build, attach);
+    }
+    async stop(name) {
+        const project = this.projectService.get(name);
+        await this.projectService.stop(project);
+    }
+    async eject(name) {
+        const project = this.projectService.get(name);
+        const preset = this.presetService.get(project.preset);
+        if (!preset) {
+            throw new Error("Preset not found");
+        }
+        const confirm = await (0, utils_1.promptConfirm)({
+            message: "Confirm eject",
+            default: false
+        });
+        if (!confirm) {
+            return;
+        }
+        const copier = new core_1.FileSystemManager(preset.path, this.processService.pwd());
+        if (preset.dockerfile) {
+            if (!copier.destination.exists(preset.dockerfile)) {
+                copier.copy(preset.dockerfile);
+            }
+            project.type = "dockerfile";
+            project.dockerfile = preset.dockerfile;
+        }
+        const files = copier.source.readdir("", {
+            recursive: true
+        });
+        for (const path of files) {
+            const stat = copier.source.stat(path), dir = path_1.default.dirname(path);
+            if (stat.isFile() && path === "config.json") {
+                continue;
+            }
+            if (stat.isFile() && path === preset.dockerfile) {
+                continue;
+            }
+            if (copier.destination.exists(path)) {
+                continue;
+            }
+            if (!copier.destination.exists(dir)) {
+                copier.destination.mkdir(dir, {
+                    recursive: true
+                });
+            }
+            copier.copy(path);
+        }
+        delete project.preset;
+        delete project.imageName;
+        project.save();
+    }
+    async exec(command, name) {
+        const project = this.projectService.get(name);
+        await this.projectService.exec(project, command);
+    }
+};
+exports.ProjectController = ProjectController;
+__decorate([
+    (0, core_1.Command)("start"),
+    (0, core_1.Description)("Starting project"),
+    __param(0, (0, core_1.Option)("name", "n")),
+    __param(0, (0, core_1.Description)("The name of the project")),
+    __param(1, (0, core_1.Option)("restart", "r")),
+    __param(1, (0, core_1.Description)("Restarting project")),
+    __param(2, (0, core_1.Option)("build", "b")),
+    __param(2, (0, core_1.Description)("Build")),
+    __param(3, (0, core_1.Option)("attach", "a")),
+    __param(3, (0, core_1.Description)("Attach")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Boolean, Boolean]),
+    __metadata("design:returntype", Promise)
+], ProjectController.prototype, "start", null);
+__decorate([
+    (0, core_1.Command)("stop"),
+    (0, core_1.Description)("Stopping project"),
+    __param(0, (0, core_1.Option)("name", "n")),
+    __param(0, (0, core_1.Description)("The name of the project")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ProjectController.prototype, "stop", null);
+__decorate([
+    (0, core_1.Command)("preset:eject"),
+    (0, core_1.Description)("Eject preset files into the project"),
+    __param(0, (0, core_1.Option)("name", "n")),
+    __param(0, (0, core_1.Description)("The name of the project")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ProjectController.prototype, "eject", null);
+__decorate([
+    (0, core_1.Command)("exec [...command]"),
+    __param(0, (0, core_1.Param)("command")),
+    __param(1, (0, core_1.Option)("name", {
+        type: "string",
+        alias: "n",
+        description: "The name of the project"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, String]),
+    __metadata("design:returntype", Promise)
+], ProjectController.prototype, "exec", null);
+exports.ProjectController = ProjectController = __decorate([
+    (0, core_1.Controller)(),
+    (0, core_1.Description)("Project commands"),
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.ProcessService,
+        ProjectService_1.ProjectService,
+        preset_1.PresetService])
+], ProjectController);

package/lib/modules/project/index.d.ts

@@ -0,0 +1,5 @@
+import { ProjectRepository } from "./repositories/ProjectRepository";
+import { ProjectService } from "./services/ProjectService";
+export declare class ProjectModule {
+}
+export { ProjectRepository, ProjectService };

package/lib/modules/project/index.js

@@ -0,0 +1,39 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectService = exports.ProjectRepository = exports.ProjectModule = void 0;
+const core_1 = require("@wocker/core");
+const keystore_1 = require("../keystore");
+const docker_1 = require("../docker");
+const preset_1 = require("../preset");
+const ProjectController_1 = require("./controllers/ProjectController");
+const ProjectRepository_1 = require("./repositories/ProjectRepository");
+Object.defineProperty(exports, "ProjectRepository", { enumerable: true, get: function () { return ProjectRepository_1.ProjectRepository; } });
+const ProjectService_1 = require("./services/ProjectService");
+Object.defineProperty(exports, "ProjectService", { enumerable: true, get: function () { return ProjectService_1.ProjectService; } });
+let ProjectModule = class ProjectModule {
+};
+exports.ProjectModule = ProjectModule;
+exports.ProjectModule = ProjectModule = __decorate([
+    (0, core_1.Module)({
+        imports: [
+            preset_1.PresetModule,
+            keystore_1.KeystoreModule,
+            docker_1.DockerModule
+        ],
+        controllers: [ProjectController_1.ProjectController],
+        providers: [
+            ProjectRepository_1.ProjectRepository,
+            ProjectService_1.ProjectService
+        ],
+        exports: [
+            ProjectRepository_1.ProjectRepository,
+            ProjectService_1.ProjectService
+        ]
+    })
+], ProjectModule);

package/lib/modules/project/repositories/ProjectRepository.d.ts

@@ -0,0 +1,13 @@
+import { AppConfigService, AppFileSystemService, Project, ProjectProperties, ProjectServiceSearchParams as SearchParams } from "@wocker/core";
+import { KeystoreService } from "../../keystore";
+export declare class ProjectRepository {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly fs: AppFileSystemService;
+    protected readonly keystoreService: KeystoreService;
+    constructor(appConfigService: AppConfigService, fs: AppFileSystemService, keystoreService: KeystoreService);
+    getByName(name: string): Project;
+    fromObject(data: Partial<ProjectProperties>): Project;
+    save(project: Project): void;
+    search(params?: SearchParams): Project[];
+    searchOne(params?: SearchParams): Project | null;
+}

package/lib/modules/project/repositories/ProjectRepository.js

@@ -0,0 +1,90 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRepository = void 0;
+const core_1 = require("@wocker/core");
+const keystore_1 = require("../../keystore");
+let ProjectRepository = class ProjectRepository {
+    constructor(appConfigService, fs, keystoreService) {
+        this.appConfigService = appConfigService;
+        this.fs = fs;
+        this.keystoreService = keystoreService;
+    }
+    getByName(name) {
+        const ref = this.appConfigService.config.getProject(name), config = this.fs.readJSON(`projects/${name}/config.json`);
+        return this.fromObject({
+            ...config,
+            path: ref.path
+        });
+    }
+    fromObject(data) {
+        const _this = this;
+        return new class extends core_1.Project {
+            constructor(data) {
+                super(data);
+            }
+            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);
+    }
+    save(project) {
+        if (!project.name) {
+            throw new Error("Project should has a name");
+        }
+        if (!project.path) {
+            throw new Error("Project should has a path");
+        }
+        if (!project.id) {
+            project.id = project.name;
+        }
+        if (!this.fs.exists(`projects/${project.id}`)) {
+            this.fs.mkdir(`projects/${project.id}`, {
+                recursive: true
+            });
+        }
+        const { path, ...rest } = project.toObject();
+        this.appConfigService.addProject(project.id, project.name, path);
+        this.fs.writeJSON(`projects/${project.id}/config.json`, rest);
+        this.appConfigService.save();
+    }
+    search(params = {}) {
+        const { name, path } = params, projects = [];
+        for (const ref of this.appConfigService.projects) {
+            if (name && ref.name !== name) {
+                continue;
+            }
+            if (path && ref.path !== path) {
+                continue;
+            }
+            const project = this.getByName(ref.name);
+            projects.push(project);
+        }
+        return projects;
+    }
+    searchOne(params = {}) {
+        const [project] = this.search(params);
+        return project || null;
+    }
+};
+exports.ProjectRepository = ProjectRepository;
+exports.ProjectRepository = ProjectRepository = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.AppFileSystemService,
+        keystore_1.KeystoreService])
+], ProjectRepository);

package/lib/modules/project/services/ProjectService.d.ts

@@ -0,0 +1,25 @@
+import { Project, AppConfigService, EventService, ProcessService, ProjectService as CoreProjectService, ProjectServiceSearchParams as SearchParams, LogService } from "@wocker/core";
+import { DockerService, ComposeService } from "../../docker";
+import { PresetService, PresetRepository } from "../../preset";
+import { ProjectRepository } from "../repositories/ProjectRepository";
+export declare class ProjectService extends CoreProjectService {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly processService: ProcessService;
+    protected readonly eventService: EventService;
+    protected readonly dockerService: DockerService;
+    protected readonly composeService: ComposeService;
+    protected readonly projectRepository: ProjectRepository;
+    protected readonly presetService: PresetService;
+    protected readonly presetRepository: PresetRepository;
+    protected readonly logService: LogService;
+    constructor(appConfigService: AppConfigService, processService: ProcessService, eventService: EventService, dockerService: DockerService, composeService: ComposeService, projectRepository: ProjectRepository, presetService: PresetService, presetRepository: PresetRepository, logService: LogService);
+    get(name?: string): Project;
+    search(params?: SearchParams): Project[];
+    searchOne(params?: SearchParams): Project | null;
+    save(project: Project): void;
+    start(project: Project, restart?: boolean, rebuild?: boolean, attach?: boolean): Promise<void>;
+    stop(project: Project): Promise<void>;
+    build(project: Project, rebuild?: boolean): Promise<void>;
+    exec(project: Project, command: string[]): Promise<void>;
+    logs(project: Project, detach?: boolean): Promise<void>;
+}

package/lib/modules/project/services/ProjectService.js

@@ -0,0 +1,253 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectService = void 0;
+const core_1 = require("@wocker/core");
+const docker_1 = require("../../docker");
+const preset_1 = require("../../preset");
+const ProjectRepository_1 = require("../repositories/ProjectRepository");
+let ProjectService = class ProjectService extends core_1.ProjectService {
+    constructor(appConfigService, processService, eventService, dockerService, composeService, projectRepository, presetService, presetRepository, logService) {
+        super();
+        this.appConfigService = appConfigService;
+        this.processService = processService;
+        this.eventService = eventService;
+        this.dockerService = dockerService;
+        this.composeService = composeService;
+        this.projectRepository = projectRepository;
+        this.presetService = presetService;
+        this.presetRepository = presetRepository;
+        this.logService = logService;
+    }
+    get(name) {
+        const project = name
+            ? this.projectRepository.searchOne({ name })
+            : this.projectRepository.searchOne({
+                path: this.processService.pwd()
+            });
+        if (!project) {
+            throw new Error("Project not found");
+        }
+        if (name) {
+            this.processService.chdir(project.path);
+        }
+        return project;
+    }
+    search(params = {}) {
+        return this.projectRepository.search(params);
+    }
+    searchOne(params = {}) {
+        return this.projectRepository.searchOne(params);
+    }
+    save(project) {
+        this.projectRepository.save(project);
+    }
+    async start(project, restart, rebuild, attach) {
+        if (restart || rebuild) {
+            await this.stop(project);
+        }
+        await this.build(project, rebuild);
+        await this.eventService.emit("project:beforeStart", project);
+        switch (project.type) {
+            case core_1.PROJECT_TYPE_IMAGE:
+            case core_1.PROJECT_TYPE_DOCKERFILE:
+            case core_1.PROJECT_TYPE_PRESET: {
+                let container = await this.dockerService.getContainer(project.containerName);
+                const fs = new core_1.FileSystem(project.path);
+                if (!container) {
+                    container = await this.dockerService.createContainer({
+                        name: project.containerName,
+                        image: project.imageName,
+                        env: {
+                            ...this.appConfigService.config.env || {},
+                            ...project.env || {}
+                        },
+                        ports: project.ports || [],
+                        volumes: (project.volumes || []).map((volume) => {
+                            const regVolume = /^([^:]+):([^:]+)(?::([^:]+))?$/;
+                            const [, source, destination, options] = regVolume.exec(volume);
+                            if (source.startsWith("/")) {
+                                return volume;
+                            }
+                            return `${fs.path(source)}:${destination}` + (options ? `:${options}` : "");
+                        }),
+                        extraHosts: Object.keys(project.extraHosts || {}).map((host) => {
+                            return `${project.extraHosts[host]}:${host}`;
+                        })
+                    });
+                }
+                const { State: { Status } } = await container.inspect();
+                if (Status === "created" || Status === "exited") {
+                    await container.start();
+                }
+                break;
+            }
+            case core_1.PROJECT_TYPE_COMPOSE: {
+                await this.composeService.up({
+                    context: project.path,
+                    composefile: project.composefile
+                });
+                break;
+            }
+        }
+        await this.eventService.emit("project:start", project);
+        await this.eventService.emit("project:afterStart", project);
+        if (attach) {
+            switch (project.type) {
+                case core_1.PROJECT_TYPE_IMAGE:
+                case core_1.PROJECT_TYPE_DOCKERFILE:
+                case core_1.PROJECT_TYPE_PRESET:
+                    await this.dockerService.attach(project.containerName);
+                    break;
+                case core_1.PROJECT_TYPE_COMPOSE:
+                    break;
+            }
+        }
+    }
+    async stop(project) {
+        await this.eventService.emit("project:beforeStop", project);
+        switch (project.type) {
+            case core_1.PROJECT_TYPE_IMAGE:
+            case core_1.PROJECT_TYPE_DOCKERFILE:
+            case core_1.PROJECT_TYPE_PRESET:
+                await this.dockerService.removeContainer(project.containerName);
+                break;
+            case core_1.PROJECT_TYPE_COMPOSE: {
+                await this.composeService.down({
+                    context: project.path,
+                    composefile: project.composefile
+                });
+                break;
+            }
+        }
+        await this.eventService.emit("project:stop", project);
+    }
+    async build(project, rebuild) {
+        switch (project.type) {
+            case core_1.PROJECT_TYPE_IMAGE:
+                await this.dockerService.pullImage(project.imageName);
+                break;
+            case core_1.PROJECT_TYPE_DOCKERFILE: {
+                project.imageName = `project-${project.name}:develop`;
+                project.save();
+                if (rebuild) {
+                    await this.dockerService.imageRm(project.imageName);
+                }
+                if (!await this.dockerService.imageExists(project.imageName)) {
+                    await this.dockerService.buildImage({
+                        version: this.appConfigService.isExperimentalEnabled("buildKit") ? "2" : "1",
+                        tag: project.imageName,
+                        buildArgs: project.buildArgs,
+                        context: project.path,
+                        dockerfile: project.dockerfile
+                    });
+                }
+                break;
+            }
+            case core_1.PROJECT_TYPE_PRESET: {
+                const preset = this.presetRepository.searchOne({
+                    name: project.preset
+                });
+                if (preset.image) {
+                    await this.dockerService.pullImage(preset.image);
+                    project.imageName = preset.image;
+                    project.save();
+                }
+                if (preset.dockerfile) {
+                    project.imageName = this.presetService.getImageNameForProject(project, preset);
+                    project.save();
+                    if (rebuild) {
+                        await this.dockerService.imageRm(project.imageName);
+                    }
+                    if (!await this.dockerService.imageExists(project.imageName)) {
+                        await this.dockerService.buildImage({
+                            version: this.appConfigService.isExperimentalEnabled("buildKit") ? "2" : "1",
+                            tag: project.imageName,
+                            labels: {
+                                "org.wocker.preset": preset.name
+                            },
+                            buildArgs: project.buildArgs,
+                            context: preset.path,
+                            dockerfile: preset.dockerfile
+                        });
+                    }
+                }
+                break;
+            }
+            case core_1.PROJECT_TYPE_COMPOSE: {
+                await this.composeService.build({
+                    context: project.path,
+                    composefile: project.composefile
+                });
+                break;
+            }
+        }
+        await this.eventService.emit("project:build", project, rebuild);
+    }
+    async exec(project, command) {
+        switch (project.type) {
+            case core_1.PROJECT_TYPE_IMAGE:
+            case core_1.PROJECT_TYPE_DOCKERFILE:
+            case core_1.PROJECT_TYPE_PRESET:
+                await this.dockerService.exec(project.containerName, command, true);
+                break;
+            case core_1.PROJECT_TYPE_COMPOSE: {
+                const [service, ...args] = command;
+                await this.composeService.exec({
+                    service,
+                    args,
+                    context: project.path,
+                    composefile: project.composefile
+                });
+                break;
+            }
+        }
+    }
+    async logs(project, detach) {
+        switch (project.type) {
+            case core_1.PROJECT_TYPE_IMAGE:
+            case core_1.PROJECT_TYPE_DOCKERFILE:
+            case core_1.PROJECT_TYPE_PRESET: {
+                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);
+                }
+                break;
+            }
+            case core_1.PROJECT_TYPE_COMPOSE:
+                break;
+        }
+    }
+};
+exports.ProjectService = ProjectService;
+exports.ProjectService = ProjectService = __decorate([
+    (0, core_1.Injectable)("PROJECT_SERVICE"),
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.ProcessService,
+        core_1.EventService,
+        docker_1.DockerService,
+        docker_1.ComposeService,
+        ProjectRepository_1.ProjectRepository,
+        preset_1.PresetService,
+        preset_1.PresetRepository,
+        core_1.LogService])
+], ProjectService);

package/lib/modules/proxy/controllers/CertController.d.ts

@@ -1,5 +1,5 @@
 import { CertService } from "../services/CertService";
-import { ProjectService } from "../../../services/ProjectService";
+import { ProjectService } from "../../project";
 export declare class CertController {
     protected readonly projectService: ProjectService;
     protected readonly certService: CertService;

package/lib/modules/proxy/controllers/CertController.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CertController = void 0;
 const core_1 = require("@wocker/core");
 const CertService_1 = require("../services/CertService");
-const ProjectService_1 = require("../../../services/ProjectService");
+const project_1 = require("../../project");
 let CertController = class CertController {
     constructor(projectService, certService) {
         this.projectService = projectService;
@@ -109,6 +109,6 @@ __decorate([
 ], CertController.prototype, "existsOtherNames", null);
 exports.CertController = CertController = __decorate([
     (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [ProjectService_1.ProjectService,
+    __metadata("design:paramtypes", [project_1.ProjectService,
         CertService_1.CertService])
 ], CertController);

package/lib/modules/proxy/controllers/ProxyController.d.ts

@@ -1,15 +1,13 @@
-import { Project } from "@wocker/core";
-import { AppConfigService } from "../../../services/AppConfigService";
-import { AppEventsService } from "../../../services/AppEventsService";
-import { ProjectService } from "../../../services/ProjectService";
+import { Project, AppConfigService, EventService } from "@wocker/core";
+import { ProjectService } from "../../project";
 import { ProxyService } from "../services/ProxyService";
 export declare class ProxyController {
     protected readonly appConfigService: AppConfigService;
-    protected readonly appEventsService: AppEventsService;
+    protected readonly eventService: EventService;
     protected readonly projectService: ProjectService;
     protected readonly proxyService: ProxyService;
     protected containerName: string;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService, proxyService: ProxyService);
+    constructor(appConfigService: AppConfigService, eventService: EventService, projectService: ProjectService, proxyService: ProxyService);
     onProjectStart(project: Project): Promise<void>;
     onProjectStop(project: Project): Promise<void>;
     getProjectNames(): string[];

package/lib/modules/proxy/controllers/ProxyController.js

@@ -19,20 +19,18 @@ exports.ProxyController = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
 const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
-const AppConfigService_1 = require("../../../services/AppConfigService");
-const AppEventsService_1 = require("../../../services/AppEventsService");
-const ProjectService_1 = require("../../../services/ProjectService");
+const project_1 = require("../../project");
 const ProxyService_1 = require("../services/ProxyService");
 let ProxyController = class ProxyController {
-    constructor(appConfigService, appEventsService, projectService, proxyService) {
+    constructor(appConfigService, eventService, projectService, proxyService) {
         this.appConfigService = appConfigService;
-        this.appEventsService = appEventsService;
+        this.eventService = eventService;
         this.projectService = projectService;
         this.proxyService = proxyService;
         this.containerName = "proxy.workspace";
-        this.appEventsService.on("project:init", (project) => this.proxyService.init(project));
-        this.appEventsService.on("project:start", (project) => this.onProjectStart(project));
-        this.appEventsService.on("project:stop", (project) => this.onProjectStop(project));
+        this.eventService.on("project:init", (project) => this.proxyService.init(project));
+        this.eventService.on("project:start", (project) => this.onProjectStart(project));
+        this.eventService.on("project:stop", (project) => this.onProjectStop(project));
     }
     async onProjectStart(project) {
         if (project.domains.length === 0) {
@@ -176,8 +174,8 @@ __decorate([
 exports.ProxyController = ProxyController = __decorate([
     (0, core_1.Controller)(),
     (0, core_1.Description)("Proxy commands"),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
-        AppEventsService_1.AppEventsService,
-        ProjectService_1.ProjectService,
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.EventService,
+        project_1.ProjectService,
         ProxyService_1.ProxyService])
 ], ProxyController);