@wocker/ws 1.0.24 → 1.0.25

package/lib/{RootModule.d.ts → AppModule.d.ts}

@@ -1,5 +1,5 @@
 import { Container } from "@wocker/core";
-export declare class RootModule {
+export declare class AppModule {
     load(container: Container): Promise<{
         imports: any[];
     }>;

package/lib/{RootModule.js → AppModule.js}

@@ -5,17 +5,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 RootModule_1;
+var AppModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RootModule = void 0;
+exports.AppModule = void 0;
 const core_1 = require("@wocker/core");
 const controllers_1 = require("./controllers");
 const PluginService_1 = require("./services/PluginService");
 const NpmService_1 = require("./services/NpmService");
 const modules_1 = require("./modules");
-let RootModule = RootModule_1 = class RootModule {
+let AppModule = AppModule_1 = class AppModule {
     async load(container) {
-        const appModule = container.getModule(RootModule_1), fs = appModule.get(core_1.AppFileSystemService), appConfigService = appModule.get(core_1.AppConfigService), logService = appModule.get(core_1.LogService), pluginService = appModule.get(PluginService_1.PluginService);
+        const appModule = container.getModule(AppModule_1), fs = appModule.get(core_1.AppFileSystemService), appConfigService = appModule.get(core_1.AppConfigService), logService = appModule.get(core_1.LogService), pluginService = appModule.get(PluginService_1.PluginService);
         const imports = [];
         for (const pluginData of appConfigService.plugins || []) {
             try {
@@ -41,12 +41,12 @@ let RootModule = RootModule_1 = class RootModule {
         };
     }
 };
-exports.RootModule = RootModule;
-exports.RootModule = RootModule = RootModule_1 = __decorate([
+exports.AppModule = AppModule;
+exports.AppModule = AppModule = AppModule_1 = __decorate([
     (0, core_1.Global)(),
     (0, core_1.Module)({
         imports: [
-            modules_1.AppModule,
+            modules_1.CoreModule,
             modules_1.ProjectModule,
             modules_1.PresetModule,
             modules_1.DockerModule,
@@ -61,23 +61,10 @@ exports.RootModule = RootModule = RootModule_1 = __decorate([
             controllers_1.DebugController
         ],
         providers: [
-            core_1.AppService,
-            core_1.AppFileSystemService,
-            core_1.AppConfigService,
-            core_1.EventService,
-            core_1.LogService,
             NpmService_1.NpmService,
-            PluginService_1.PluginService,
-            core_1.ProcessService
+            PluginService_1.PluginService
         ],
         exports: [
-            core_1.WOCKER_VERSION_KEY,
-            core_1.WOCKER_DATA_DIR_KEY,
-            core_1.AppService,
-            core_1.AppFileSystemService,
-            core_1.AppConfigService,
-            core_1.EventService,
-            core_1.LogService,
             modules_1.DockerService,
             modules_1.CertService,
             modules_1.ContainerService,
@@ -90,4 +77,4 @@ exports.RootModule = RootModule = RootModule_1 = __decorate([
             core_1.ProcessService
         ]
     })
-], RootModule);
+], AppModule);

package/lib/controllers/ProjectController.d.ts

@@ -39,7 +39,6 @@ export declare class ProjectController {
     addExtraHost(extraHost: string, extraDomain: string, name?: string): Promise<void>;
     removeExtraHost(extraHost: string, name?: string): Promise<void>;
     attach(name?: string): Promise<void>;
-    exec(command?: string[], name?: string): Promise<void>;
     run(script: string, args?: string[], name?: string): Promise<void>;
     logs(name?: string, global?: boolean, detach?: boolean, follow?: boolean, clear?: boolean): Promise<void>;
 }

package/lib/controllers/ProjectController.js

@@ -464,10 +464,6 @@ let ProjectController = class ProjectController {
         const project = this.projectService.get(name);
         await this.dockerService.attach(project.containerName);
     }
-    async exec(command, name) {
-        const project = this.projectService.get(name);
-        await this.dockerService.exec(project.containerName, command, true);
-    }
     async run(script, args, name) {
         const project = this.projectService.get(name);
         if (!project.scripts || !project.scripts[script]) {
@@ -909,18 +905,6 @@ __decorate([
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], ProjectController.prototype, "attach", 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);
 __decorate([
     (0, core_1.Command)("run <script> [...args]"),
     __param(0, (0, core_1.Param)("script")),

package/lib/env.d.ts

@@ -1,4 +1,4 @@
-export declare const WOCKER_VERSION = "1.0.24";
+export declare const WOCKER_VERSION = "1.0.25";
 export declare const NODE_ENV: string;
 export declare const ROOT_DIR: string;
 export declare const PRESETS_DIR: string;

package/lib/env.js

@@ -36,11 +36,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KEYTAR_SERVICE = exports.VIRTUAL_HOST_KEY = exports.WOCKER_DATA_DIR = exports.PLUGINS_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = exports.WOCKER_VERSION = void 0;
 const OS = __importStar(require("os"));
 const Path = __importStar(require("path"));
-exports.WOCKER_VERSION = "1.0.24";
+exports.WOCKER_VERSION = "1.0.25";
 exports.NODE_ENV = process.env.NODE_ENV;
 exports.ROOT_DIR = Path.join(__dirname, "..");
-exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");
-exports.PLUGINS_DIR = Path.join(exports.ROOT_DIR, "plugins");
+exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "fixtures/presets");
+exports.PLUGINS_DIR = Path.join(exports.ROOT_DIR, "fixtures/plugins");
 exports.WOCKER_DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
 exports.VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
 exports.KEYTAR_SERVICE = process.env.WOCKER_KEYTAR_SERVICE || "wocker";

package/lib/main.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = void 0;
 const core_1 = require("@wocker/core");
 const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
-const RootModule_1 = require("./RootModule");
+const AppModule_1 = require("./AppModule");
 exports.app = {
     async run(args) {
-        const context = await core_1.Factory.create(RootModule_1.RootModule), appConfigService = context.get(core_1.AppConfigService), logService = context.get(core_1.LogService);
+        const context = await core_1.Factory.create(AppModule_1.AppModule), appConfigService = context.get(core_1.AppConfigService), logService = context.get(core_1.LogService);
         try {
             const res = await context.run(args);
             if (res) {

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

@@ -0,0 +1,2 @@
+export declare class CoreModule {
+}

package/lib/modules/{app → core}/index.js

@@ -6,13 +6,14 @@ 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.AppModule = void 0;
+exports.CoreModule = void 0;
 const core_1 = require("@wocker/core");
 const env_1 = require("../../env");
-let AppModule = class AppModule {
+let CoreModule = class CoreModule {
 };
-exports.AppModule = AppModule;
-exports.AppModule = AppModule = __decorate([
+exports.CoreModule = CoreModule;
+exports.CoreModule = CoreModule = __decorate([
+    (0, core_1.Global)(),
     (0, core_1.Module)({
         providers: [
             {
@@ -22,11 +23,23 @@ exports.AppModule = AppModule = __decorate([
             {
                 provide: core_1.WOCKER_DATA_DIR_KEY,
                 useValue: env_1.WOCKER_DATA_DIR
-            }
+            },
+            core_1.AppService,
+            core_1.AppConfigService,
+            core_1.AppFileSystemService,
+            core_1.EventService,
+            core_1.LogService,
+            core_1.ProcessService
         ],
         exports: [
+            core_1.AppService,
+            core_1.AppConfigService,
+            core_1.AppFileSystemService,
+            core_1.EventService,
+            core_1.LogService,
+            core_1.ProcessService,
             core_1.WOCKER_VERSION_KEY,
             core_1.WOCKER_DATA_DIR_KEY
         ]
     })
-], AppModule);
+], CoreModule);

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

@@ -1,3 +1,4 @@
+import { ComposeService } from "./services/ComposeService";
 import { ContainerService } from "./services/ContainerService";
 import { DockerService } from "./services/DockerService";
 import { ImageService } from "./services/ImageService";
@@ -5,4 +6,4 @@ import { ModemService } from "./services/ModemService";
 import { ProtoService } from "./services/ProtoService";
 export declare class DockerModule {
 }
-export { ContainerService, DockerService, ImageService, ModemService, ProtoService };
+export { ComposeService, ContainerService, DockerService, ImageService, ModemService, ProtoService };

package/lib/modules/docker/index.js

@@ -6,8 +6,10 @@ 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.ImageService = exports.DockerService = 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 DockerService_1 = require("./services/DockerService");
@@ -24,6 +26,7 @@ exports.DockerModule = DockerModule;
 exports.DockerModule = DockerModule = __decorate([
     (0, core_1.Module)({
         providers: [
+            ComposeService_1.ComposeService,
             ContainerService_1.ContainerService,
             DockerService_1.DockerService,
             ImageService_1.ImageService,
@@ -31,6 +34,7 @@ exports.DockerModule = DockerModule = __decorate([
             ProtoService_1.ProtoService
         ],
         exports: [
+            ComposeService_1.ComposeService,
             ContainerService_1.ContainerService,
             DockerService_1.DockerService,
             ImageService_1.ImageService,

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.js

@@ -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);

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,13 +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;
     protected record?: boolean;
-    constructor(protoService: ProtoService);
+    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,10 @@ 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() {
@@ -76,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;
                         }
@@ -133,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,4 +1,4 @@
-export * from "./app";
+export * from "./core";
 export * from "./docker";
 export * from "./keystore";
 export * from "./preset";

package/lib/modules/index.js

@@ -14,7 +14,7 @@ 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("./app"), exports);
+__exportStar(require("./core"), exports);
 __exportStar(require("./docker"), exports);
 __exportStar(require("./keystore"), exports);
 __exportStar(require("./preset"), exports);

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

@@ -1,10 +1,9 @@
-import { AppService, AppConfigService, AppFileSystemService, KeystoreService as CoreKeystoreService, KeystoreProvider } from "@wocker/core";
+import { AppConfigService, AppFileSystemService, KeystoreService as CoreKeystoreService, KeystoreProvider } from "@wocker/core";
 export declare class KeystoreService extends CoreKeystoreService {
-    protected readonly appService: AppService;
     protected readonly appConfigService: AppConfigService;
     protected readonly fs: AppFileSystemService;
     protected providers: Map<string, KeystoreProvider>;
-    constructor(appService: AppService, appConfigService: AppConfigService, fs: AppFileSystemService);
+    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

@@ -14,9 +14,8 @@ const core_1 = require("@wocker/core");
 const KeytarKeystoreProvider_1 = require("../providers/KeytarKeystoreProvider");
 const FileKeystoreProvider_1 = require("../providers/FileKeystoreProvider");
 let KeystoreService = class KeystoreService extends core_1.KeystoreService {
-    constructor(appService, appConfigService, fs) {
+    constructor(appConfigService, fs) {
         super();
-        this.appService = appService;
         this.appConfigService = appConfigService;
         this.fs = fs;
         this.providers = new Map();
@@ -67,7 +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", [core_1.AppService,
-        core_1.AppConfigService,
+    __metadata("design:paramtypes", [core_1.AppConfigService,
         core_1.AppFileSystemService])
 ], KeystoreService);