@wocker/ws 1.0.24 → 1.0.26

package/lib/modules/dns/services/DnsService.d.ts

@@ -0,0 +1,10 @@
+import { DockerService } from "../../docker";
+export declare class DnsService {
+    protected readonly dockerService: DockerService;
+    protected imageName: string;
+    protected containerName: string;
+    constructor(dockerService: DockerService);
+    start(restart?: boolean, rebuild?: boolean): Promise<void>;
+    stop(): Promise<void>;
+    build(rebuild?: boolean): Promise<void>;
+}

package/lib/modules/dns/services/DnsService.js

@@ -0,0 +1,77 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsService = void 0;
+const core_1 = require("@wocker/core");
+const path_1 = __importDefault(require("path"));
+const docker_1 = require("../../docker");
+const env_1 = require("../../../env");
+let DnsService = class DnsService {
+    constructor(dockerService) {
+        this.dockerService = dockerService;
+        this.imageName = "wocker-dns:0.0.1";
+        this.containerName = "wocker-dns";
+    }
+    async start(restart, rebuild) {
+        console.info("Starting DNS service...");
+        console.info("DNS service currently isn't working");
+        if (restart || rebuild) {
+            await this.dockerService.removeContainer(this.containerName);
+        }
+        await this.build(rebuild);
+        let container = await this.dockerService.getContainer(this.containerName);
+        const fs = new core_1.FileSystem(`${env_1.ROOT_DIR}/plugins/dns`);
+        if (!fs.exists("etc/dnsmasq.conf")) {
+            fs.writeFile("etc/dnsmasq.conf", "");
+        }
+        if (!container) {
+            container = await this.dockerService.createContainer({
+                name: this.containerName,
+                image: this.imageName,
+                volumes: [
+                    "/var/run/docker.sock.raw:/var/run/docker.sock:ro",
+                    "/var/run/docker.sock.raw:/tmp/docker.sock:ro",
+                    `${fs.path("app/Procfile")}:/app/Procfile`,
+                    `${fs.path("app/dnsmasq.conf.tmpl")}:/app/dnsmasq.conf.tmpl`,
+                    `${fs.path("etc/dnsmasq.conf")}:/etc/dnsmasq.conf`
+                ]
+            });
+        }
+        const { State: { Running } } = await container.inspect();
+        if (!Running) {
+            await container.start();
+        }
+    }
+    async stop() {
+        await this.dockerService.removeContainer(this.containerName);
+    }
+    async build(rebuild) {
+        if (await this.dockerService.imageExists(this.imageName)) {
+            if (!rebuild) {
+                return;
+            }
+            await this.dockerService.imageRm(this.imageName);
+        }
+        await this.dockerService.buildImage({
+            tag: this.imageName,
+            dockerfile: "./Dockerfile",
+            context: path_1.default.join(env_1.ROOT_DIR, "fixtures/dns")
+        });
+    }
+};
+exports.DnsService = DnsService;
+exports.DnsService = DnsService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [docker_1.DockerService])
+], DnsService);

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<ArrayBufferLike>, streamSource?: "stdout" | "stderr"): void;
+}
+export {};

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

@@ -0,0 +1,127 @@
+"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;
+        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/ContainerService.d.ts

@@ -1,6 +1,6 @@
 import { LogService, DockerServiceParams as Params } from "@wocker/core";
-import type Docker from "dockerode";
 import { Duplex } from "stream";
+import type Docker from "dockerode";
 import type { Container } from "dockerode";
 import { ModemService } from "./ModemService";
 export declare class ContainerService {

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

@@ -67,7 +67,6 @@ let DockerService = class DockerService extends core_1.DockerService {
             User: user,
             Image: image,
             Hostname: name,
-            Domainname: name,
             Labels: {
                 ...projectId ? { projectId } : {}
             },
@@ -126,7 +125,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 +140,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,13 @@
-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,10 +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.record = true;
+        this.logService = logService;
     }
     get modem() {
         if (!this._modem) {
@@ -76,13 +76,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 +150,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/index.d.ts

@@ -1,6 +1,9 @@
-export * from "./app";
+export * from "./core";
+export * from "./dns";
 export * from "./docker";
 export * from "./keystore";
+export * from "./package-manager";
+export * from "./plugin";
 export * from "./preset";
 export * from "./project";
 export * from "./proxy";

package/lib/modules/index.js

@@ -14,9 +14,12 @@ 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("./dns"), exports);
 __exportStar(require("./docker"), exports);
 __exportStar(require("./keystore"), exports);
+__exportStar(require("./package-manager"), exports);
+__exportStar(require("./plugin"), exports);
 __exportStar(require("./preset"), exports);
 __exportStar(require("./project"), exports);
 __exportStar(require("./proxy"), exports);

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

@@ -5,7 +5,4 @@ export declare class KeystoreController {
     protected readonly keystoreService: KeystoreService;
     constructor(appConfigService: AppConfigService, keystoreService: KeystoreService);
     init(provider?: string): Promise<void>;
-    add(name?: string, provider?: string): Promise<void>;
-    inspect(name?: string, provider?: string): Promise<string | undefined>;
-    delete(name?: string, provider?: string): Promise<void>;
 }

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

@@ -35,68 +35,17 @@ let KeystoreController = class KeystoreController {
         this.appConfigService.config.keystore = provider;
         this.appConfigService.save();
     }
-    async add(name, provider) {
-        const value = await (0, utils_1.promptInput)({
-            message: "Secret value",
-            type: "password"
-        });
-        await this.keystoreService.provider(provider).set(name, value);
-    }
-    async inspect(name, provider) {
-        return this.keystoreService.provider(provider).get(name);
-    }
-    async delete(name, provider) {
-        await this.keystoreService.provider(provider).delete(name);
-    }
 };
 exports.KeystoreController = KeystoreController;
 __decorate([
     (0, core_1.Command)("keystore:init"),
-    __param(0, (0, core_1.Option)("provider", {
-        type: "string",
-        description: "Keystore provider name"
-    })),
+    (0, core_1.Description)("Initialize keystore"),
+    __param(0, (0, core_1.Option)("provider", "p")),
+    __param(0, (0, core_1.Description)("Keystore provider name")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], KeystoreController.prototype, "init", null);
-__decorate([
-    (0, core_1.Command)("secret:create [name]"),
-    (0, core_1.Description)("Adds secret value to keystore"),
-    __param(0, (0, core_1.Param)("name")),
-    __param(1, (0, core_1.Option)("provider", {
-        alias: "p",
-        type: "string",
-        description: "Provider name"
-    })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], KeystoreController.prototype, "add", null);
-__decorate([
-    (0, core_1.Command)("secret:inspect [name]"),
-    __param(0, (0, core_1.Param)("name")),
-    __param(1, (0, core_1.Option)("provider", {
-        type: "string",
-        alias: "p"
-    })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], KeystoreController.prototype, "inspect", null);
-__decorate([
-    (0, core_1.Command)("secret:rm [name]"),
-    (0, core_1.Description)("Removes secret value from keystore"),
-    __param(0, (0, core_1.Param)("name")),
-    __param(1, (0, core_1.Option)("provider", {
-        type: "string",
-        alias: "p",
-        description: "Provider name"
-    })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], KeystoreController.prototype, "delete", null);
 exports.KeystoreController = KeystoreController = __decorate([
     (0, core_1.Controller)(),
     (0, core_1.Description)("Keystore commands"),

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

@@ -1,13 +1,13 @@
-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>;
     set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
     registerProvider(name: string, provider: KeystoreProvider): void;
 }

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();
@@ -57,6 +56,10 @@ let KeystoreService = class KeystoreService extends core_1.KeystoreService {
         const provider = this.provider();
         await provider.set(key, value);
     }
+    async delete(key) {
+        const provider = this.provider();
+        await provider.delete(key);
+    }
     registerProvider(name, provider) {
         if (this.providers.has(name)) {
             throw new Error(`Provider ${name} already registered`);
@@ -67,7 +70,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);

package/lib/modules/keystore/utils/createEncryptionKey.d.ts

@@ -1 +1 @@
-export declare const createEncryptionKey: (password: string, passwordHash: string) => Buffer<ArrayBufferLike>;
+export declare const createEncryptionKey: (password: string, passwordHash: string) => NonSharedBuffer;