@wocker/ws 1.0.22 → 1.0.24

package/lib/modules/preset/controllers/PresetListener.js

@@ -0,0 +1,140 @@
+"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.PresetListener = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const docker_1 = require("../../docker");
+const PresetRepository_1 = require("../repositories/PresetRepository");
+const PresetService_1 = require("../services/PresetService");
+const utils_2 = require("../../../utils");
+let PresetListener = class PresetListener {
+    constructor(eventService, dockerService, presetRepository, presetService) {
+        this.eventService = eventService;
+        this.dockerService = dockerService;
+        this.presetRepository = presetRepository;
+        this.presetService = presetService;
+        this.eventService.on("project:init", (project) => this.onInit(project));
+        this.eventService.on("project:beforeStart", (project) => this.onBeforeStart(project));
+        this.eventService.on("project:rebuild", (project) => this.onRebuild(project));
+    }
+    async onInit(project) {
+        if (project.type !== core_1.PROJECT_TYPE_PRESET) {
+            return;
+        }
+        const presets = this.presetRepository.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
+        });
+        project.presetMode = await (0, utils_1.promptSelect)({
+            message: "Preset mode",
+            options: [
+                {
+                    label: "For project only",
+                    value: "project"
+                },
+                {
+                    label: "Global usage",
+                    value: "global"
+                }
+            ],
+            default: project.presetMode
+        });
+        const preset = this.presetService.get(project.preset);
+        if (!preset) {
+            throw new Error("Preset not found");
+        }
+        if (preset.buildArgsOptions) {
+            project.buildArgs = await this.presetService.prompt(preset.buildArgsOptions, project.buildArgs);
+        }
+        if (preset.envOptions) {
+            project.env = await this.presetService.prompt(preset.envOptions, project.env);
+        }
+        if (preset.volumeOptions) {
+            for (let volume of preset.volumeOptions) {
+                volume = (0, utils_2.injectVariables)(volume, {
+                    ...project.buildArgs || {},
+                    ...project.env || {}
+                });
+                const { source, destination, options } = (0, utils_1.volumeParse)(volume);
+                let projectVolume = project.getVolumeByDestination(destination);
+                const newSource = await (0, utils_1.promptInput)({
+                    message: "Volume",
+                    required: true,
+                    suffix: `:${destination}`,
+                    default: projectVolume ? (0, utils_1.volumeParse)(projectVolume).source : source
+                });
+                projectVolume = (0, utils_1.volumeFormat)({
+                    source: newSource,
+                    destination,
+                    options
+                });
+                project.volumeMount(projectVolume);
+            }
+        }
+        if (preset.dockerfile) {
+            project.imageName = this.presetService.getImageNameForProject(project, preset);
+        }
+    }
+    async onRebuild(project) {
+        if (project.type !== core_1.PROJECT_TYPE_PRESET) {
+            return;
+        }
+        const preset = this.presetService.get(project.preset);
+        if (!preset) {
+            throw new Error(`Preset ${project.preset} not found`);
+        }
+        const imageName = this.presetService.getImageNameForProject(project, preset);
+        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 !== core_1.PROJECT_TYPE_PRESET) {
+            return;
+        }
+        const preset = this.presetService.get(project.preset);
+        if (preset.dockerfile) {
+            project.imageName = this.presetService.getImageNameForProject(project, preset);
+            if (!await this.dockerService.imageExists(project.imageName)) {
+                await this.dockerService.buildImage({
+                    tag: project.imageName,
+                    labels: {
+                        presetName: preset.name
+                    },
+                    buildArgs: project.buildArgs,
+                    context: preset.path,
+                    src: preset.dockerfile
+                });
+            }
+        }
+    }
+};
+exports.PresetListener = PresetListener;
+exports.PresetListener = PresetListener = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [core_1.EventService,
+        docker_1.DockerService,
+        PresetRepository_1.PresetRepository,
+        PresetService_1.PresetService])
+], PresetListener);

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

@@ -0,0 +1,5 @@
+import { PresetRepository } from "./repositories/PresetRepository";
+import { PresetService } from "./services/PresetService";
+export declare class PresetModule {
+}
+export { PresetRepository, PresetService };

package/lib/modules/preset/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.PresetService = exports.PresetRepository = exports.PresetModule = void 0;
+const core_1 = require("@wocker/core");
+const docker_1 = require("../docker");
+const PresetController_1 = require("./controllers/PresetController");
+const PresetListener_1 = require("./controllers/PresetListener");
+const PresetRepository_1 = require("./repositories/PresetRepository");
+Object.defineProperty(exports, "PresetRepository", { enumerable: true, get: function () { return PresetRepository_1.PresetRepository; } });
+const PresetService_1 = require("./services/PresetService");
+Object.defineProperty(exports, "PresetService", { enumerable: true, get: function () { return PresetService_1.PresetService; } });
+let PresetModule = class PresetModule {
+};
+exports.PresetModule = PresetModule;
+exports.PresetModule = PresetModule = __decorate([
+    (0, core_1.Module)({
+        imports: [
+            docker_1.DockerModule
+        ],
+        controllers: [
+            PresetController_1.PresetController,
+            PresetListener_1.PresetListener
+        ],
+        providers: [
+            PresetRepository_1.PresetRepository,
+            PresetService_1.PresetService
+        ],
+        exports: [
+            PresetRepository_1.PresetRepository,
+            PresetService_1.PresetService
+        ]
+    })
+], PresetModule);

package/lib/modules/preset/repositories/PresetRepository.d.ts

@@ -0,0 +1,16 @@
+import { AppConfig, PresetServiceSearchOptions as SearchOptions, Preset, PresetSource, AppConfigService, LogService } from "@wocker/core";
+type PresetData = {
+    name: string;
+    source: PresetSource;
+    path?: string;
+};
+export declare class PresetRepository {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly logService: LogService;
+    constructor(appConfigService: AppConfigService, logService: LogService);
+    protected load(data: PresetData): Preset;
+    protected configs(): AppConfig["presets"];
+    search(options?: SearchOptions): Preset[];
+    searchOne(options?: SearchOptions): Preset | null;
+}
+export {};

package/lib/{repositories → modules/preset/repositories}/PresetRepository.js

@@ -11,12 +11,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresetRepository = void 0;
 const core_1 = require("@wocker/core");
-const AppConfigService_1 = require("../services/AppConfigService");
-const LogService_1 = require("../services/LogService");
-const env_1 = require("../env");
+const env_1 = require("../../../env");
 let PresetRepository = class PresetRepository {
-    constructor(appConfig, logService) {
-        this.appConfig = appConfig;
+    constructor(appConfigService, logService) {
+        this.appConfigService = appConfigService;
         this.logService = logService;
     }
     load(data) {
@@ -37,7 +35,7 @@ let PresetRepository = class PresetRepository {
                         fs.writeJSON("config.json", this.toObject());
                         break;
                 }
-                _this.appConfig.registerPreset(this.name, this.source, data.path);
+                _this.appConfigService.registerPreset(this.name, this.source, data.path);
             }
             delete() {
                 switch (this.source) {
@@ -49,13 +47,13 @@ let PresetRepository = class PresetRepository {
                         }
                         break;
                 }
-                _this.appConfig.unregisterPreset(this.name);
+                _this.appConfigService.unregisterPreset(this.name);
             }
         }(config);
     }
     configs() {
         const fs = new core_1.FileSystem(env_1.PRESETS_DIR), dirs = fs.exists("") ? fs.readdir("") : [];
-        const { presets = [] } = this.appConfig.config;
+        const { presets = [] } = this.appConfigService.config;
         return [
             ...dirs.map((name) => {
                 return {
@@ -68,7 +66,7 @@ let PresetRepository = class PresetRepository {
                 if (item.source === core_1.PRESET_SOURCE_GITHUB) {
                     return {
                         ...item,
-                        path: this.appConfig.fs.path("presets", item.name)
+                        path: this.appConfigService.fs.path("presets", item.name)
                     };
                 }
                 return item;
@@ -110,6 +108,6 @@ let PresetRepository = class PresetRepository {
 exports.PresetRepository = PresetRepository;
 exports.PresetRepository = PresetRepository = __decorate([
     (0, core_1.Injectable)(),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
-        LogService_1.LogService])
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.LogService])
 ], PresetRepository);

package/lib/{services → modules/preset/services}/PresetService.d.ts

@@ -1,25 +1,17 @@
-import { EnvConfig, Project, Preset, PresetVariableConfig } from "@wocker/core";
-import { AppConfigService } from "./AppConfigService";
-import { LogService } from "./LogService";
+import { Project, Preset, PresetVariableConfig, EnvConfig, AppConfigService, AppFileSystemService } from "@wocker/core";
 import { PresetRepository } from "../repositories/PresetRepository";
-type SearchOptions = Partial<{
-    name: string;
-    source: string;
-    path: string;
-}>;
 export declare class PresetService {
     protected readonly appConfigService: AppConfigService;
+    protected readonly fs: AppFileSystemService;
     protected readonly presetRepository: PresetRepository;
-    protected readonly logService: LogService;
-    constructor(appConfigService: AppConfigService, presetRepository: PresetRepository, logService: LogService);
+    constructor(appConfigService: AppConfigService, fs: AppFileSystemService, presetRepository: PresetRepository);
     prompt(configMap: {
         [name: string]: PresetVariableConfig;
     }, values?: EnvConfig): Promise<EnvConfig>;
     getImageNameForProject(project: Project, preset: Preset): string;
     getImageName(preset: Preset, buildArgs: EnvConfig): string;
+    get(name?: string): Preset;
     init(): Promise<void>;
     deinit(): Promise<void>;
-    get(name?: string): Preset;
     addPreset(name: string, repository?: string, version?: string): Promise<void>;
 }
-export { SearchOptions as PresetServiceSearchOptions };

package/lib/{services → modules/preset/services}/PresetService.js

@@ -16,15 +16,13 @@ exports.PresetService = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
 const md5_1 = __importDefault(require("md5"));
-const AppConfigService_1 = require("./AppConfigService");
-const LogService_1 = require("./LogService");
 const PresetRepository_1 = require("../repositories/PresetRepository");
-const GithubClient_1 = require("../makes/GithubClient");
+const GithubClient_1 = require("../../../makes/GithubClient");
 let PresetService = class PresetService {
-    constructor(appConfigService, presetRepository, logService) {
+    constructor(appConfigService, fs, presetRepository) {
         this.appConfigService = appConfigService;
+        this.fs = fs;
         this.presetRepository = presetRepository;
-        this.logService = logService;
     }
     async prompt(configMap, values = {}) {
         for (const name in configMap) {
@@ -36,7 +34,7 @@ let PresetService = class PresetService {
                         required: config.required,
                         default: typeof values[name] !== "undefined" && values[name] === "true"
                             ? true
-                            : undefined,
+                            : config.default
                     });
                     values[name] = value.toString();
                     break;
@@ -117,6 +115,15 @@ let PresetService = class PresetService {
         }).join("-");
         return `ws-preset-${preset.name}:${version}`;
     }
+    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");
+        }
+        return preset;
+    }
     async init() {
         const fs = new core_1.FileSystem(this.appConfigService.pwd());
         let preset = this.presetRepository.searchOne({
@@ -205,34 +212,22 @@ let PresetService = class PresetService {
         if (!preset) {
             return;
         }
-        const config = this.appConfigService.getConfig();
-        config.unregisterPreset(preset.name);
-        config.save();
-    }
-    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");
-        }
-        return preset;
+        this.appConfigService.config.unregisterPreset(preset.name);
+        this.appConfigService.save();
     }
     async addPreset(name, repository, version) {
+        if (!repository) {
+            repository = `kearisp/wocker-${name}-preset`;
+        }
         let preset = this.presetRepository.searchOne({
             name
         });
         if (!preset) {
             console.info("Loading...");
-            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}`));
+            await github.download(info.default_branch, this.fs.path(`presets/${name}`));
             this.appConfigService.registerPreset(name, core_1.PRESET_SOURCE_GITHUB);
         }
     }
@@ -240,7 +235,7 @@ let PresetService = class PresetService {
 exports.PresetService = PresetService;
 exports.PresetService = PresetService = __decorate([
     (0, core_1.Injectable)(),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
-        PresetRepository_1.PresetRepository,
-        LogService_1.LogService])
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.AppFileSystemService,
+        PresetRepository_1.PresetRepository])
 ], PresetService);

package/lib/modules/project/controllers/ProjectController.d.ts

@@ -0,0 +1,13 @@
+import { AppConfigService, ProcessService } from "@wocker/core";
+import { PresetService } from "../../preset";
+import { ProjectService } from "../services/ProjectService";
+export declare class ProjectController {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly processService: ProcessService;
+    protected readonly projectService: ProjectService;
+    protected readonly presetService: PresetService;
+    constructor(appConfigService: AppConfigService, processService: ProcessService, projectService: ProjectService, presetService: PresetService);
+    start(name?: string, restart?: boolean, build?: boolean, attach?: boolean): Promise<void>;
+    stop(name?: string): Promise<void>;
+    eject(name?: string): Promise<void>;
+}

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

@@ -0,0 +1,127 @@
+"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();
+    }
+};
+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);
+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;
+}