@wocker/ws 1.0.23 → 1.0.25

package/lib/modules/docker/index.js

@@ -6,14 +6,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtoService = exports.ModemService = exports.DockerService = exports.ImageService = exports.ContainerService = exports.DockerModule = void 0;
+exports.ProtoService = exports.ModemService = exports.ImageService = exports.DockerService = exports.ContainerService = exports.ComposeService = exports.DockerModule = void 0;
 const core_1 = require("@wocker/core");
+const ComposeService_1 = require("./services/ComposeService");
+Object.defineProperty(exports, "ComposeService", { enumerable: true, get: function () { return ComposeService_1.ComposeService; } });
 const ContainerService_1 = require("./services/ContainerService");
 Object.defineProperty(exports, "ContainerService", { enumerable: true, get: function () { return ContainerService_1.ContainerService; } });
-const ImageService_1 = require("./services/ImageService");
-Object.defineProperty(exports, "ImageService", { enumerable: true, get: function () { return ImageService_1.ImageService; } });
 const DockerService_1 = require("./services/DockerService");
 Object.defineProperty(exports, "DockerService", { enumerable: true, get: function () { return DockerService_1.DockerService; } });
+const ImageService_1 = require("./services/ImageService");
+Object.defineProperty(exports, "ImageService", { enumerable: true, get: function () { return ImageService_1.ImageService; } });
 const ModemService_1 = require("./services/ModemService");
 Object.defineProperty(exports, "ModemService", { enumerable: true, get: function () { return ModemService_1.ModemService; } });
 const ProtoService_1 = require("./services/ProtoService");
@@ -24,16 +26,18 @@ exports.DockerModule = DockerModule;
 exports.DockerModule = DockerModule = __decorate([
     (0, core_1.Module)({
         providers: [
+            ComposeService_1.ComposeService,
             ContainerService_1.ContainerService,
-            ImageService_1.ImageService,
             DockerService_1.DockerService,
+            ImageService_1.ImageService,
             ModemService_1.ModemService,
             ProtoService_1.ProtoService
         ],
         exports: [
+            ComposeService_1.ComposeService,
             ContainerService_1.ContainerService,
-            ImageService_1.ImageService,
             DockerService_1.DockerService,
+            ImageService_1.ImageService,
             ModemService_1.ModemService,
             ProtoService_1.ProtoService
         ]

package/lib/modules/docker/services/ComposeService.d.ts

@@ -0,0 +1,32 @@
+import { LogService } from "@wocker/core";
+import { ComposeConfig } from "../type/ComposeConfig";
+type UpOptions = {
+    composefile: string;
+    context: string;
+};
+type DownOptions = {
+    composefile: string;
+    context: string;
+};
+type BuildOptions = {
+    composefile: string;
+    context: string;
+};
+type ExecOptions = {
+    service: string;
+    args: string[];
+    composefile: string;
+    context: string;
+};
+export declare class ComposeService {
+    protected readonly logService: LogService;
+    constructor(logService: LogService);
+    up(options: UpOptions): Promise<void>;
+    down(options: DownOptions): Promise<void>;
+    build(options: BuildOptions): Promise<void>;
+    exec(options: ExecOptions): Promise<void>;
+    protected getConfig(context: string, composefile: string): ComposeConfig;
+    protected getConfigAsString(context: string, composefile: string): string;
+    protected processChunk(chunk: Buffer<ArrayBuffer>, streamSource?: "stdout" | "stderr"): void;
+}
+export {};

package/lib/modules/docker/services/ComposeService.js

@@ -0,0 +1,129 @@
+"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 __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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComposeService = void 0;
+const core_1 = require("@wocker/core");
+const yaml_1 = __importDefault(require("yaml"));
+const compose = __importStar(require("docker-compose"));
+let ComposeService = class ComposeService {
+    constructor(logService) {
+        this.logService = logService;
+    }
+    async up(options) {
+        const { context, composefile } = options;
+        const res = await compose.upAll({
+            cwd: context,
+            configAsString: this.getConfigAsString(context, composefile),
+            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
+        });
+        this.logService.debug("compose up", res);
+    }
+    async down(options) {
+        const { context, composefile } = options;
+        const res = await compose.downAll({
+            cwd: context,
+            configAsString: this.getConfigAsString(context, composefile),
+            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
+        });
+        this.logService.debug("compose down", res);
+    }
+    async build(options) {
+        const { context, composefile } = options;
+        const res = await compose.buildAll({
+            cwd: context,
+            config: composefile,
+            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
+        });
+        this.logService.debug("build", res);
+    }
+    async exec(options) {
+        const { service, args, context, composefile } = options;
+        const config = this.getConfig(context, composefile);
+        console.log(config);
+        await compose.exec(service, args, {
+            configAsString: this.getConfigAsString(context, composefile),
+            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
+        });
+    }
+    getConfig(context, composefile) {
+        const fs = new core_1.FileSystem(context), config = fs.readYAML(composefile);
+        if (!config.networks) {
+            config.networks = {};
+        }
+        config.networks.workspace = {
+            external: true
+        };
+        for (const name in config.services) {
+            if (!config.services[name].networks) {
+                config.services[name].networks = [];
+            }
+            if (!config.services[name].networks.includes("workspace")) {
+                config.services[name].networks.push("workspace");
+            }
+        }
+        return config;
+    }
+    getConfigAsString(context, composefile) {
+        const config = this.getConfig(context, composefile);
+        return yaml_1.default.stringify(config);
+    }
+    processChunk(chunk, streamSource) {
+        switch (streamSource) {
+            case "stdout":
+                process.stdout.write(chunk);
+                break;
+            case "stderr":
+                process.stderr.write(chunk);
+                break;
+        }
+    }
+};
+exports.ComposeService = ComposeService;
+exports.ComposeService = ComposeService = __decorate([
+    (0, core_1.Injectable)("DOCKER_COMPOSE_SERVICE"),
+    __metadata("design:paramtypes", [core_1.LogService])
+], ComposeService);

package/lib/modules/docker/services/DockerService.d.ts

@@ -5,11 +5,11 @@ import { ContainerService } from "./ContainerService";
 import { ModemService } from "./ModemService";
 import { ImageService } from "./ImageService";
 export declare class DockerService extends CoreDockerService {
-    protected readonly logService: LogService;
     protected readonly modemService: ModemService;
     protected readonly containerService: ContainerService;
     protected readonly imageService: ImageService;
-    constructor(logService: LogService, modemService: ModemService, containerService: ContainerService, imageService: ImageService);
+    protected readonly logService: LogService;
+    constructor(modemService: ModemService, containerService: ContainerService, imageService: ImageService, logService: LogService);
     get docker(): Docker;
     createVolume(name: string): Promise<VolumeCreateResponse>;
     hasVolume(name: string): Promise<boolean>;

package/lib/modules/docker/services/DockerService.js

@@ -15,12 +15,12 @@ const ContainerService_1 = require("./ContainerService");
 const ModemService_1 = require("./ModemService");
 const ImageService_1 = require("./ImageService");
 let DockerService = class DockerService extends core_1.DockerService {
-    constructor(logService, modemService, containerService, imageService) {
+    constructor(modemService, containerService, imageService, logService) {
         super();
-        this.logService = logService;
         this.modemService = modemService;
         this.containerService = containerService;
         this.imageService = imageService;
+        this.logService = logService;
     }
     get docker() {
         return this.modemService.docker;
@@ -126,7 +126,7 @@ let DockerService = class DockerService extends core_1.DockerService {
             },
             NetworkingConfig: {
                 EndpointsConfig: networkMode === "host" ? {} : {
-                    workspace: {
+                    [networkName]: {
                         Links: links,
                         Aliases: aliases || (env.VIRTUAL_HOST ? env.VIRTUAL_HOST.split(",") : undefined)
                     }
@@ -141,29 +141,7 @@ let DockerService = class DockerService extends core_1.DockerService {
         await this.containerService.rm(name);
     }
     async buildImage(params) {
-        const { tag, labels = {}, buildArgs = {}, context, src } = params;
-        const fs = new core_1.FileSystem(context);
-        const files = await fs.readdirFiles("", {
-            recursive: true
-        });
-        const stream = await this.docker.buildImage({
-            context,
-            src: files
-        }, {
-            t: tag,
-            labels,
-            buildargs: Object.keys(buildArgs).reduce((res, key) => {
-                const value = buildArgs[key];
-                if (typeof value !== "undefined") {
-                    res[key] = typeof buildArgs[key] !== "string"
-                        ? buildArgs[key].toString()
-                        : buildArgs[key];
-                }
-                return res;
-            }, {}),
-            dockerfile: src
-        });
-        await this.modemService.followProgress(stream);
+        await this.imageService.build(params);
     }
     async imageExists(tag) {
         return this.imageService.exists(tag);
@@ -261,8 +239,8 @@ let DockerService = class DockerService extends core_1.DockerService {
 exports.DockerService = DockerService;
 exports.DockerService = DockerService = __decorate([
     (0, core_1.Injectable)("DOCKER_SERVICE"),
-    __metadata("design:paramtypes", [core_1.LogService,
-        ModemService_1.ModemService,
+    __metadata("design:paramtypes", [ModemService_1.ModemService,
         ContainerService_1.ContainerService,
-        ImageService_1.ImageService])
+        ImageService_1.ImageService,
+        core_1.LogService])
 ], DockerService);

package/lib/modules/docker/services/ImageService.d.ts

@@ -1,18 +1,12 @@
 import type Docker from "dockerode";
+import { DockerServiceParams as Params } from "@wocker/core";
 import { ModemService } from "./ModemService";
-type BuildParams = {
-    tag: string;
-    context: string;
-    dockerfile: string;
-    version: "1" | "2";
-};
 export declare class ImageService {
     protected readonly modemService: ModemService;
     constructor(modemService: ModemService);
     get docker(): Docker;
-    build(params: BuildParams): Promise<void>;
+    build(params: Params.BuildImage): Promise<void>;
     exists(tag: string): Promise<boolean>;
     pull(tag: string): Promise<void>;
     rm(tag: string, force?: boolean): Promise<void>;
 }
-export {};

package/lib/modules/docker/services/ImageService.js

@@ -20,7 +20,10 @@ let ImageService = class ImageService {
         return this.modemService.docker;
     }
     async build(params) {
-        const { tag, context, dockerfile, version } = params;
+        const { version, tag, context, labels, buildArgs } = params;
+        const dockerfile = "dockerfile" in params
+            ? params.dockerfile
+            : params.src;
         const files = (new core_1.FileSystem(context)).readdir("", {
             recursive: true
         });
@@ -28,9 +31,18 @@ let ImageService = class ImageService {
             context,
             src: files
         }, {
+            version,
             t: tag,
-            dockerfile,
-            version
+            labels,
+            buildargs: Object.keys(buildArgs || {}).reduce((res, key) => {
+                const value = buildArgs[key];
+                if (typeof value !== "undefined") {
+                    res[key] = typeof value !== "string" ? value.toString() : value;
+                }
+                return res;
+            }, {}),
+            rm: true,
+            dockerfile
         });
         await this.modemService.followProgress(stream);
     }

package/lib/modules/docker/services/ModemService.d.ts

@@ -1,12 +1,14 @@
-import { ModemService as CoreModemService } from "@wocker/core";
+import { ModemService as CoreModemService, LogService } from "@wocker/core";
 import type Modem from "docker-modem";
 import type Docker from "dockerode";
 import { ProtoService } from "./ProtoService";
 export declare class ModemService extends CoreModemService {
     protected readonly protoService: ProtoService;
+    protected readonly logService: LogService;
     protected _modem?: Modem;
     protected _docker?: Docker;
-    constructor(protoService: ProtoService);
+    protected record?: boolean;
+    constructor(protoService: ProtoService, logService: LogService);
     get modem(): Modem;
     get docker(): Docker;
     attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;

package/lib/modules/docker/services/ModemService.js

@@ -14,9 +14,11 @@ const core_1 = require("@wocker/core");
 const formatSizeUnits_1 = require("../utils/formatSizeUnits");
 const ProtoService_1 = require("./ProtoService");
 let ModemService = class ModemService extends core_1.ModemService {
-    constructor(protoService) {
+    constructor(protoService, logService) {
         super();
         this.protoService = protoService;
+        this.logService = logService;
+        this.record = true;
     }
     get modem() {
         if (!this._modem) {
@@ -75,13 +77,30 @@ let ModemService = class ModemService extends core_1.ModemService {
                 const text = chunk.toString().replace(/}\s*\{/g, "},{"), items = JSON.parse(`[${text}]`);
                 for (const item of items) {
                     if (item.id === "moby.buildkit.trace") {
+                        const StatusResponse = this.protoService.lookupType("moby.buildkit.v1.StatusResponse");
+                        const buffer = Buffer.from(item.aux, "base64");
+                        const decoded = StatusResponse.decode(buffer);
+                        const obj = StatusResponse.toObject(decoded, {
+                            enums: String,
+                            longs: String,
+                            bytes: String,
+                            defaults: true
+                        });
+                        console.dir(obj, {
+                            depth: null
+                        });
                     }
-                    if (item.stream) {
+                    else if (item.id === "moby.image.id") {
+                        console.dir(item, {
+                            depth: null
+                        });
+                    }
+                    else if (item.stream) {
                         process.stdout.write(`${item.stream}`);
                         line += item.stream.split("\n").length - 1;
                     }
                     else if (item.id) {
-                        const { id, status, processDetail: { current, total, } = {} } = item;
+                        const { id, status, processDetail: { current, total } = {} } = item;
                         if (typeof mapLines[id] === "undefined") {
                             mapLines[id] = line;
                         }
@@ -132,6 +151,7 @@ let ModemService = class ModemService extends core_1.ModemService {
 };
 exports.ModemService = ModemService;
 exports.ModemService = ModemService = __decorate([
-    (0, core_1.Injectable)("MODEM_SERVICE"),
-    __metadata("design:paramtypes", [ProtoService_1.ProtoService])
+    (0, core_1.Injectable)("DOCKER_MODEM_SERVICE"),
+    __metadata("design:paramtypes", [ProtoService_1.ProtoService,
+        core_1.LogService])
 ], ModemService);

package/lib/modules/docker/services/ProtoService.js

@@ -7,8 +7,8 @@ class ProtoService {
     get root() {
         if (!this._root) {
             this._root = (0, protobufjs_1.loadSync)([
-                `${env_1.ROOT_DIR}/proto/solver/pb/ops.proto`,
-                `${env_1.ROOT_DIR}/proto/buildkit.proto`
+                `${env_1.ROOT_DIR}/fixtures/proto/solver/pb/ops.proto`,
+                `${env_1.ROOT_DIR}/fixtures/proto/buildkit.proto`
             ]);
         }
         return this._root;

package/lib/modules/docker/type/ComposeConfig.d.ts

@@ -0,0 +1,12 @@
+export type ComposeConfig = {
+    services: {
+        [name: string]: {
+            networks?: string[];
+        };
+    };
+    networks?: {
+        [name: string]: {
+            external?: boolean;
+        };
+    };
+};

package/lib/modules/docker/type/ComposeConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/modules/index.d.ts

@@ -1,3 +1,6 @@
+export * from "./core";
 export * from "./docker";
 export * from "./keystore";
+export * from "./preset";
+export * from "./project";
 export * from "./proxy";

package/lib/modules/index.js

@@ -14,6 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core"), exports);
 __exportStar(require("./docker"), exports);
 __exportStar(require("./keystore"), exports);
+__exportStar(require("./preset"), exports);
+__exportStar(require("./project"), exports);
 __exportStar(require("./proxy"), exports);

package/lib/modules/keystore/controllers/KeystoreController.d.ts

@@ -1,4 +1,4 @@
-import { AppConfigService } from "../../../services/AppConfigService";
+import { AppConfigService } from "@wocker/core";
 import { KeystoreService } from "../services/KeystoreService";
 export declare class KeystoreController {
     protected readonly appConfigService: AppConfigService;

package/lib/modules/keystore/controllers/KeystoreController.js

@@ -15,7 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeystoreController = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
-const AppConfigService_1 = require("../../../services/AppConfigService");
 const KeystoreService_1 = require("../services/KeystoreService");
 let KeystoreController = class KeystoreController {
     constructor(appConfigService, keystoreService) {
@@ -101,6 +100,6 @@ __decorate([
 exports.KeystoreController = KeystoreController = __decorate([
     (0, core_1.Controller)(),
     (0, core_1.Description)("Keystore commands"),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+    __metadata("design:paramtypes", [core_1.AppConfigService,
         KeystoreService_1.KeystoreService])
 ], KeystoreController);

package/lib/modules/keystore/providers/FileKeystoreProvider.d.ts

@@ -1,12 +1,11 @@
-import { KeystoreProvider } from "@wocker/core";
-import { AppConfigService } from "../../../services/AppConfigService";
+import { AppFileSystemService, KeystoreProvider } from "@wocker/core";
 import { FileKeystore } from "../types/FileKeystore";
 export declare class FileKeystoreProvider extends KeystoreProvider {
-    protected readonly appConfigService: AppConfigService;
+    protected readonly fs: AppFileSystemService;
     protected password?: string;
     protected encryptionKey?: Buffer;
     protected _keystore?: FileKeystore;
-    constructor(appConfigService: AppConfigService);
+    constructor(fs: AppFileSystemService);
     protected get keystore(): FileKeystore;
     protected get passwordHash(): string | undefined;
     protected getEncryptionKey(): Promise<Buffer>;

package/lib/modules/keystore/providers/FileKeystoreProvider.js

@@ -12,17 +12,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileKeystoreProvider = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
-const AppConfigService_1 = require("../../../services/AppConfigService");
 const FileKeystore_1 = require("../types/FileKeystore");
 const utils_2 = require("../utils");
 let FileKeystoreProvider = class FileKeystoreProvider extends core_1.KeystoreProvider {
-    constructor(appConfigService) {
+    constructor(fs) {
         super();
-        this.appConfigService = appConfigService;
+        this.fs = fs;
     }
     get keystore() {
         if (!this._keystore) {
-            const fs = this.appConfigService.fs;
+            const fs = this.fs;
             let data = {
                 secrets: {}
             };
@@ -93,5 +92,5 @@ let FileKeystoreProvider = class FileKeystoreProvider extends core_1.KeystorePro
 exports.FileKeystoreProvider = FileKeystoreProvider;
 exports.FileKeystoreProvider = FileKeystoreProvider = __decorate([
     (0, core_1.Injectable)(),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService])
+    __metadata("design:paramtypes", [core_1.AppFileSystemService])
 ], FileKeystoreProvider);

package/lib/modules/keystore/services/KeystoreService.d.ts

@@ -1,9 +1,9 @@
-import { KeystoreService as CoreKeystoreService, KeystoreProvider } from "@wocker/core";
-import { AppConfigService } from "../../../services/AppConfigService";
+import { AppConfigService, AppFileSystemService, KeystoreService as CoreKeystoreService, KeystoreProvider } from "@wocker/core";
 export declare class KeystoreService extends CoreKeystoreService {
     protected readonly appConfigService: AppConfigService;
+    protected readonly fs: AppFileSystemService;
     protected providers: Map<string, KeystoreProvider>;
-    constructor(appConfigService: AppConfigService);
+    constructor(appConfigService: AppConfigService, fs: AppFileSystemService);
     hasProvider(name: string): boolean;
     provider(name?: string): KeystoreProvider;
     get(keys: string | string[], byDefault?: string): Promise<string | undefined>;

package/lib/modules/keystore/services/KeystoreService.js

@@ -11,13 +11,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeystoreService = void 0;
 const core_1 = require("@wocker/core");
-const AppConfigService_1 = require("../../../services/AppConfigService");
-const KeytarKeystoreProvider_1 = require("./../providers/KeytarKeystoreProvider");
-const FileKeystoreProvider_1 = require("./../providers/FileKeystoreProvider");
+const KeytarKeystoreProvider_1 = require("../providers/KeytarKeystoreProvider");
+const FileKeystoreProvider_1 = require("../providers/FileKeystoreProvider");
 let KeystoreService = class KeystoreService extends core_1.KeystoreService {
-    constructor(appConfigService) {
+    constructor(appConfigService, fs) {
         super();
         this.appConfigService = appConfigService;
+        this.fs = fs;
         this.providers = new Map();
     }
     hasProvider(name) {
@@ -32,7 +32,7 @@ let KeystoreService = class KeystoreService extends core_1.KeystoreService {
         }
         switch (name) {
             case "file":
-                return new FileKeystoreProvider_1.FileKeystoreProvider(this.appConfigService);
+                return new FileKeystoreProvider_1.FileKeystoreProvider(this.fs);
             case "keytar":
                 return new KeytarKeystoreProvider_1.KeytarKeystoreProvider();
             default:
@@ -66,5 +66,6 @@ let KeystoreService = class KeystoreService extends core_1.KeystoreService {
 exports.KeystoreService = KeystoreService;
 exports.KeystoreService = KeystoreService = __decorate([
     (0, core_1.Injectable)("KEYSTORE_SERVICE"),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService])
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.AppFileSystemService])
 ], KeystoreService);

package/lib/modules/preset/controllers/PresetController.d.ts

@@ -0,0 +1,18 @@
+import { AppConfigService } from "@wocker/core";
+import { DockerService } from "../../docker";
+import { PresetRepository } from "../repositories/PresetRepository";
+import { PresetService } from "../services/PresetService";
+export declare class PresetController {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly dockerService: DockerService;
+    protected readonly presetRepository: PresetRepository;
+    protected readonly presetService: PresetService;
+    constructor(appConfigService: AppConfigService, dockerService: DockerService, presetRepository: PresetRepository, presetService: PresetService);
+    init(): Promise<void>;
+    list(): Promise<string>;
+    add(name: string, version?: string): Promise<void>;
+    destroy(): Promise<void>;
+    delete(name: string, confirm?: boolean): Promise<void>;
+    build(presetName: string, rebuild?: boolean): Promise<void>;
+    presets(): Promise<string[]>;
+}