@wocker/ws 1.0.7 → 1.0.8

package/lib/plugins/ProxmoxPlugin.js

@@ -15,6 +15,12 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -22,21 +28,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxmoxPlugin = void 0;
+const core_1 = require("@wocker/core");
 const Path = __importStar(require("path"));
-const makes_1 = require("../makes");
+const services_1 = require("../services");
 const utils_1 = require("../utils");
-class ProxmoxPlugin extends makes_1.Plugin {
-    constructor() {
-        super("proxmox");
-        this.configDir = Path.join(__dirname, "../../services/proxmox");
+let ProxmoxPlugin = class ProxmoxPlugin {
+    constructor(appConfigService, dockerService) {
+        this.appConfigService = appConfigService;
+        this.dockerService = dockerService;
+        this.configDir = this.appConfigService.dataPath("plugins/proxmox");
     }
-    install(cli) {
-        super.install(cli);
+    pluginPath(...parts) {
+        return Path.join(this.appConfigService.pluginsPath("proxmox"), ...parts);
     }
     async up() {
-        const container = await makes_1.Docker.getContainer("proxmox.workspace");
+        const container = await this.dockerService.getContainer("proxmox.workspace");
         if (container) {
             await this.down();
         }
@@ -63,5 +74,10 @@ class ProxmoxPlugin extends makes_1.Plugin {
         await (0, utils_1.exec)("docker image rm ws-proxmox").catch(() => {
         });
     }
-}
+};
 exports.ProxmoxPlugin = ProxmoxPlugin;
+exports.ProxmoxPlugin = ProxmoxPlugin = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [services_1.AppConfigService,
+        services_1.DockerService])
+], ProxmoxPlugin);

package/lib/plugins/RedisPlugin.d.ts

@@ -1,18 +1,16 @@
 import { FSManager } from "@wocker/core";
 import { Cli } from "@kearisp/cli";
-import { DI, Plugin } from "../makes";
 import { AppConfigService, DockerService } from "../services";
-declare class RedisPlugin extends Plugin {
+export declare class RedisPlugin {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly dockerService: DockerService;
     protected container: string;
     protected commander: string;
-    protected appConfigService: AppConfigService;
-    protected dockerService: DockerService;
     protected fs: FSManager;
-    constructor(di: DI);
+    constructor(appConfigService: AppConfigService, dockerService: DockerService);
     install(cli: Cli): void;
     up(): Promise<void>;
     protected startCommander(): Promise<void>;
     down(): Promise<void>;
     protected stopCommander(): Promise<void>;
 }
-export { RedisPlugin };

package/lib/plugins/RedisPlugin.js

@@ -1,20 +1,26 @@
 "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.RedisPlugin = void 0;
 const core_1 = require("@wocker/core");
-const makes_1 = require("../makes");
 const services_1 = require("../services");
-class RedisPlugin extends makes_1.Plugin {
-    constructor(di) {
-        super("redis");
+let RedisPlugin = class RedisPlugin {
+    constructor(appConfigService, dockerService) {
+        this.appConfigService = appConfigService;
+        this.dockerService = dockerService;
         this.container = "redis.workspace";
         this.commander = "redis-commander.workspace";
-        this.appConfigService = di.resolveService(services_1.AppConfigService);
-        this.dockerService = di.resolveService(services_1.DockerService);
         this.fs = new core_1.FSManager(this.appConfigService.pluginsPath("redis"), this.appConfigService.dataPath("plugins/redis"));
     }
     install(cli) {
-        super.install(cli);
         cli.command("redis:start")
             .action(() => this.up());
         cli.command("redis:stop")
@@ -76,5 +82,10 @@ class RedisPlugin extends makes_1.Plugin {
         console.info("RedisCommander stopping...");
         await this.dockerService.removeContainer(this.commander);
     }
-}
+};
 exports.RedisPlugin = RedisPlugin;
+exports.RedisPlugin = RedisPlugin = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [services_1.AppConfigService,
+        services_1.DockerService])
+], RedisPlugin);

package/lib/plugins/index.d.ts

@@ -4,7 +4,5 @@ export * from "./MaildevPlugin";
 export * from "./MongodbPlugin";
 export * from "./NgrokPlugin";
 export * from "./PageKitePlugin";
-export * from "./PostgresPlugin";
-export * from "./PostgresPlugin";
 export * from "./ProxmoxPlugin";
 export * from "./RedisPlugin";

package/lib/plugins/index.js

@@ -20,7 +20,5 @@ __exportStar(require("./MaildevPlugin"), exports);
 __exportStar(require("./MongodbPlugin"), exports);
 __exportStar(require("./NgrokPlugin"), exports);
 __exportStar(require("./PageKitePlugin"), exports);
-__exportStar(require("./PostgresPlugin"), exports);
-__exportStar(require("./PostgresPlugin"), exports);
 __exportStar(require("./ProxmoxPlugin"), exports);
 __exportStar(require("./RedisPlugin"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,8 +1,8 @@
-import { Config, EnvConfig } from "../types";
+import { AppConfig as Config, EnvConfig } from "@wocker/core";
 type TypeMap = {
     [type: string]: string;
 };
-declare class AppConfigService {
+export declare class AppConfigService {
     protected pwd: string;
     protected mapTypes: TypeMap;
     constructor();
@@ -25,4 +25,4 @@ declare class AppConfigService {
     activatePlugin(name: string): Promise<void>;
     deactivatePlugin(name: string): Promise<void>;
 }
-export { AppConfigService };
+export {};

package/lib/services/AppConfigService.js

@@ -15,6 +15,12 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -22,12 +28,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigService = void 0;
+const core_1 = require("@wocker/core");
 const Path = __importStar(require("path"));
 const env_1 = require("../env");
 const makes_1 = require("../makes");
-class AppConfigService {
+let AppConfigService = class AppConfigService {
     constructor() {
         this.mapTypes = {
             image: "Image",
@@ -163,5 +173,9 @@ class AppConfigService {
             ...rest
         });
     }
-}
+};
 exports.AppConfigService = AppConfigService;
+exports.AppConfigService = AppConfigService = __decorate([
+    (0, core_1.Injectable)("APP_CONFIG"),
+    __metadata("design:paramtypes", [])
+], AppConfigService);

package/lib/services/AppEventsService.d.ts

@@ -1,5 +1,5 @@
 import { AppEventsService as CoreAppEventsService, AppEventHandle } from "@wocker/core";
-declare class AppEventsService extends CoreAppEventsService {
+export declare class AppEventsService extends CoreAppEventsService {
     protected handles: ({
         [event: string]: AppEventHandle[];
     });
@@ -7,4 +7,3 @@ declare class AppEventsService extends CoreAppEventsService {
     off(event: string, handle: AppEventHandle): void;
     emit(event: string, ...args: any[]): Promise<void>;
 }
-export { AppEventsService };

package/lib/services/AppEventsService.js

@@ -1,8 +1,14 @@
 "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.AppEventsService = void 0;
 const core_1 = require("@wocker/core");
-class AppEventsService extends core_1.AppEventsService {
+let AppEventsService = class AppEventsService extends core_1.AppEventsService {
     constructor() {
         super(...arguments);
         this.handles = {};
@@ -26,5 +32,8 @@ class AppEventsService extends core_1.AppEventsService {
             await handles[i](...args);
         }
     }
-}
+};
 exports.AppEventsService = AppEventsService;
+exports.AppEventsService = AppEventsService = __decorate([
+    (0, core_1.Injectable)("APP_EVENTS_SERVICE")
+], AppEventsService);

package/lib/services/DockerService.d.ts

@@ -1,51 +1,21 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import Docker, { Container } from "dockerode";
-import { DI } from "../makes";
-declare namespace Params {
-    type CreateContainer = {
-        name: string;
-        image: string;
-        restart?: "always";
-        projectId?: string;
-        tty?: boolean;
-        ulimits?: {
-            [key: string]: {
-                hard?: number;
-                soft?: number;
-            };
-        };
-        links?: string[];
-        env?: {
-            [key: string]: string;
-        };
-        networkMode?: string;
-        extraHosts?: any;
-        volumes?: string[];
-        ports?: string[];
-        cmd?: string[];
-    };
-    type BuildImage = {
-        tag: string;
-        buildArgs?: {
-            [key: string]: string;
-        };
-        labels?: {
-            [key: string]: string;
-        };
-        context: string;
-        src: string;
-    };
-}
-declare class DockerService {
+import { DockerServiceParams as Params } from "@wocker/core";
+import { LogService } from "./LogService";
+export declare class DockerService {
+    protected readonly logService: LogService;
     protected docker: Docker;
-    constructor(di: DI);
+    constructor(logService: LogService);
     createContainer(params: Params.CreateContainer): Promise<Container>;
     getContainer(name: string): Promise<Container | null>;
     removeContainer(name: string): Promise<void>;
     buildImage(params: Params.BuildImage): Promise<void>;
     imageExists(tag: string): Promise<boolean>;
     imageRm(tag: string): Promise<void>;
+    imageLs(options?: Params.ImageList): Promise<Docker.ImageInfo[]>;
     pullImage(tag: string): Promise<void>;
+    attach(name: string): Promise<void>;
     attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
+    exec(name: string, args?: string[], tty?: boolean): Promise<import("stream").Duplex>;
 }
-export { DockerService };

package/lib/services/DockerService.js

@@ -1,20 +1,32 @@
 "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.DockerService = void 0;
 const dockerode_1 = __importDefault(require("dockerode"));
+const core_1 = require("@wocker/core");
 const utils_1 = require("../utils");
 const makes_1 = require("../makes");
-class DockerService {
-    constructor(di) {
+const LogService_1 = require("./LogService");
+let DockerService = class DockerService {
+    constructor(logService) {
+        this.logService = logService;
         this.docker = new dockerode_1.default({
             socketPath: "/var/run/docker.sock"
         });
     }
     async createContainer(params) {
-        const { name, tty, image, projectId, restart, ulimits, extraHosts, networkMode, links = [], env = {}, volumes = [], ports = [], cmd = [] } = params;
+        const { name, user, entrypoint, tty, image, projectId, restart, ulimits, extraHosts, networkMode, links = [], env = {}, volumes = [], ports = [], cmd = [] } = params;
         const network = this.docker.getNetwork("workspace");
         try {
             await network.inspect();
@@ -29,6 +41,7 @@ class DockerService {
         await this.pullImage(image);
         return this.docker.createContainer({
             name,
+            User: user,
             Image: image,
             Hostname: name,
             Labels: {
@@ -39,6 +52,7 @@ class DockerService {
             AttachStderr: true,
             OpenStdin: true,
             StdinOnce: false,
+            Entrypoint: entrypoint,
             Tty: tty,
             Cmd: cmd,
             Env: Object.keys(env).map((key) => {
@@ -164,6 +178,31 @@ class DockerService {
         }
         await image.remove();
     }
+    async imageLs(options) {
+        const { tag, reference, labels } = options || {};
+        const filters = {};
+        if (reference) {
+            filters.reference = [
+                ...filters.reference || [],
+                reference
+            ];
+        }
+        if (tag) {
+            filters.reference = [
+                ...filters.reference || [],
+                tag
+            ];
+        }
+        if (labels) {
+            filters.label = [];
+            for (const i in labels) {
+                filters.label.push(`${i}=${labels[i]}`);
+            }
+        }
+        return this.docker.listImages({
+            filters: JSON.stringify(filters)
+        });
+    }
     async pullImage(tag) {
         const exists = await this.imageExists(tag);
         if (exists) {
@@ -172,6 +211,43 @@ class DockerService {
         const stream = await this.docker.pull(tag);
         await (0, utils_1.followProgress)(stream);
     }
+    async attach(name) {
+        const container = await this.getContainer(name);
+        const stream = await container.attach({
+            logs: true,
+            stream: true,
+            hijack: true,
+            stdin: true,
+            stdout: true,
+            stderr: true
+        });
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.setRawMode(true);
+        process.stdin.pipe(stream);
+        process.stdin.on("data", (data) => {
+            if (data.toString() === "\u0003") {
+                process.stdin.setRawMode(false);
+            }
+        });
+        stream.setEncoding("utf8");
+        stream.pipe(process.stdout);
+        const [width, height] = process.stdout.getWindowSize();
+        await container.resize({
+            w: width,
+            h: height
+        });
+        stream.on("end", async () => {
+            process.exit();
+        });
+        process.stdout.on("resize", () => {
+            const [width, height] = process.stdout.getWindowSize();
+            container.resize({
+                w: width,
+                h: height
+            });
+        });
+    }
     async attachStream(stream) {
         process.stdin.resume();
         process.stdin.setEncoding("utf8");
@@ -196,5 +272,47 @@ class DockerService {
             stream.on("error", reject);
         });
     }
-}
+    async exec(name, args, tty = false) {
+        const container = await this.getContainer(name);
+        if (!container) {
+            return;
+        }
+        const exec = await container.exec({
+            AttachStdin: true,
+            AttachStdout: true,
+            AttachStderr: tty,
+            Tty: tty,
+            Cmd: args || []
+        });
+        const stream = await exec.start({
+            hijack: true,
+            stdin: tty,
+            Tty: tty
+        });
+        if (tty) {
+            stream.setEncoding("utf-8");
+            process.stdin.resume();
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.setEncoding("utf-8");
+            process.stdin.pipe(stream);
+            stream.pipe(process.stdout);
+            stream.on("error", (err) => {
+                makes_1.Logger.error(err.message);
+            });
+            stream.on("end", async () => {
+                process.stdin.setRawMode(false);
+            });
+            stream.on("end", async () => {
+                process.exit();
+            });
+        }
+        return stream;
+    }
+};
 exports.DockerService = DockerService;
+exports.DockerService = DockerService = __decorate([
+    (0, core_1.Injectable)("DOCKER_SERVICE"),
+    __metadata("design:paramtypes", [LogService_1.LogService])
+], DockerService);

package/lib/services/LogService.d.ts

@@ -1,12 +1,10 @@
-import { DI } from "../makes";
 import { AppConfigService } from "./AppConfigService";
-declare class LogService {
-    protected appConfigService: AppConfigService;
-    constructor(di: DI);
+export declare class LogService {
+    protected readonly appConfigService: AppConfigService;
+    constructor(appConfigService: AppConfigService);
     log(...data: any[]): void;
     info(...data: any[]): void;
     warn(...data: any[]): void;
     error(...data: any[]): void;
     protected _log(type: string, ...data: any[]): void;
 }
-export { LogService };

package/lib/services/LogService.js

@@ -1,15 +1,26 @@
 "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.LogService = void 0;
+const core_1 = require("@wocker/core");
 const format_1 = __importDefault(require("date-fns/format"));
 const makes_1 = require("../makes");
 const AppConfigService_1 = require("./AppConfigService");
-class LogService {
-    constructor(di) {
-        this.appConfigService = di.resolveService(AppConfigService_1.AppConfigService);
+let LogService = class LogService {
+    constructor(appConfigService) {
+        this.appConfigService = appConfigService;
+        makes_1.Logger.install(this);
     }
     log(...data) {
         this._log("log", ...data);
@@ -34,5 +45,9 @@ class LogService {
         }
         makes_1.FS.appendFileSync(logPath, `[${time}] ${type}: ${logData}\n`);
     }
-}
+};
 exports.LogService = LogService;
+exports.LogService = LogService = __decorate([
+    (0, core_1.Injectable)("LOG_SERVICE"),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService])
+], LogService);

package/lib/services/PluginService.d.ts

@@ -1,11 +1,6 @@
 import { Cli } from "@wocker/core";
-import { DI, Controller } from "../makes";
-declare class PluginService {
-    protected di: DI;
-    protected cli: Cli;
-    constructor(di: DI);
-    use(Constructor: {
-        new (...params: any[]): Controller;
-    }): void;
+export declare class PluginService {
+    protected readonly cli: Cli;
+    constructor(cli: Cli);
+    use(): void;
 }
-export { PluginService };

package/lib/services/PluginService.js

@@ -1,15 +1,25 @@
 "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.PluginService = void 0;
 const core_1 = require("@wocker/core");
-class PluginService {
-    constructor(di) {
-        this.di = di;
-        this.cli = di.resolveService(core_1.Cli);
+let PluginService = class PluginService {
+    constructor(cli) {
+        this.cli = cli;
     }
-    use(Constructor) {
-        const controller = new Constructor(this.di);
-        controller.install(this.cli);
+    use() {
     }
-}
+};
 exports.PluginService = PluginService;
+exports.PluginService = PluginService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Cli])
+], PluginService);

package/lib/services/PresetService.d.ts

@@ -1,14 +1,14 @@
-import { EnvConfig } from "../types";
-import { DI, Preset } from "../makes";
+import { EnvConfig } from "@wocker/core";
+import { Preset } from "../makes";
 type SearchOptions = Partial<{
     name: string;
 }>;
-declare class PresetService {
-    constructor(di: DI);
+export declare class PresetService {
+    constructor();
     getImageName(preset: Preset, buildArgs?: EnvConfig): string;
     save(preset: Preset): Promise<void>;
     get(name: string): Promise<Preset>;
     search(options?: SearchOptions): Promise<Preset[]>;
     searchOne(options?: SearchOptions): Promise<Preset | null>;
 }
-export { PresetService, SearchOptions as PresetServiceSearchOptions };
+export { SearchOptions as PresetServiceSearchOptions };

package/lib/services/PresetService.js

@@ -8,7 +8,9 @@ const md5_1 = __importDefault(require("md5"));
 const env_1 = require("../env");
 const makes_1 = require("../makes");
 class PresetService {
-    constructor(di) { }
+    constructor() {
+        makes_1.Preset.install(this);
+    }
     getImageName(preset, buildArgs = {}) {
         const rawValues = [];
         const hashValues = [];
@@ -34,7 +36,14 @@ class PresetService {
     }
     async get(name) {
         const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, name, "config.json");
-        return new makes_1.Preset({
+        return new class extends makes_1.Preset {
+            constructor(presetService, data) {
+                super(data);
+                this.presetService = presetService;
+            }
+            async save() {
+            }
+        }(this, {
             name,
             ...config
         });