@wocker/core 1.0.1 → 1.0.3

package/lib/decorators/Injectable.d.ts

@@ -1,4 +1,4 @@
 import { DI } from "../makes/DI";
-export declare const Injectable: (ddi?: DI) => <T extends new (...rest: any[]) => {}>(Target: T) => {
+export declare const Injectable: () => <T extends new (...rest: any[]) => {}>(Target: T) => {
     new (di: DI): {};
 } & T;

package/lib/decorators/Injectable.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Injectable = void 0;
-const Injectable = (ddi) => {
+const Injectable = () => {
     return (Target) => {
         // @ts-ignore
         return class extends Target {

package/lib/index.d.ts

@@ -3,10 +3,16 @@ export * from "./decorators/Inject";
 export * from "./decorators/Injectable";
 export * from "./makes/Controller";
 export * from "./makes/DI";
+export * from "./makes/FSManager";
+export * from "./makes/Logger";
 export * from "./makes/Plugin";
+export * from "./models/Preset";
 export * from "./models/Project";
 export * from "./services/AppConfigService";
 export * from "./services/AppEventsService";
+export * from "./services/DockerService";
+export * from "./services/LogService";
+export * from "./services/PresetService";
 export * from "./services/ProjectService";
-export * from "./services/ProjectServiceInterface";
 export * from "./types/AppConfig";
+export * from "./types/EnvConfig";

package/lib/index.js

@@ -21,10 +21,16 @@ __exportStar(require("./decorators/Inject"), exports);
 __exportStar(require("./decorators/Injectable"), exports);
 __exportStar(require("./makes/Controller"), exports);
 __exportStar(require("./makes/DI"), exports);
+__exportStar(require("./makes/FSManager"), exports);
+__exportStar(require("./makes/Logger"), exports);
 __exportStar(require("./makes/Plugin"), exports);
+__exportStar(require("./models/Preset"), exports);
 __exportStar(require("./models/Project"), exports);
 __exportStar(require("./services/AppConfigService"), exports);
 __exportStar(require("./services/AppEventsService"), exports);
+__exportStar(require("./services/DockerService"), exports);
+__exportStar(require("./services/LogService"), exports);
+__exportStar(require("./services/PresetService"), exports);
 __exportStar(require("./services/ProjectService"), exports);
-__exportStar(require("./services/ProjectServiceInterface"), exports);
 __exportStar(require("./types/AppConfig"), exports);
+__exportStar(require("./types/EnvConfig"), exports);

package/lib/makes/DI.d.ts

@@ -3,6 +3,5 @@ declare class DI {
     private services;
     resolveService<T>(key: any): T;
     registerService(key: any, service: any): void;
-    use(): void;
 }
 export { DI };

package/lib/makes/DI.js

@@ -10,9 +10,11 @@ class DI {
         let res = this.services.get(key);
         if (!res) {
             const types = Reflect.getMetadata("design:paramtypes", key);
-            const params = types ? types.map((type) => {
-                return this.resolveService(type);
-            }) : [];
+            if (types && types.length > 0) {
+                types.forEach((type) => {
+                    this.resolveService(type);
+                });
+            }
             res = new key(this);
             this.services.set(key, res);
         }
@@ -21,7 +23,5 @@ class DI {
     registerService(key, service) {
         this.services.set(key, service);
     }
-    use() {
-    }
 }
 exports.DI = DI;

package/lib/makes/FSManager.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import fs, { createReadStream, MakeDirectoryOptions, RmOptions } from "fs";
+declare class FSManager {
+    protected source: string;
+    protected destination: string;
+    constructor(source: string, destination: string);
+    path(...parts: string[]): string;
+    mkdir(path: string, options?: MakeDirectoryOptions): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    exists(path: string): boolean;
+    copy(path: string): Promise<void>;
+    readJSON(path: string): Promise<any>;
+    writeJSON(path: string, data: any): Promise<void>;
+    rm(path: string, options?: RmOptions): Promise<unknown>;
+    createWriteStream(...parts: string[]): fs.WriteStream;
+    createReadStream(path: string, options?: Parameters<typeof createReadStream>[1]): fs.ReadStream;
+}
+export { FSManager };

package/lib/makes/FSManager.js

@@ -0,0 +1,146 @@
+"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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSManager = void 0;
+const fs_1 = __importStar(require("fs"));
+const Path = __importStar(require("path"));
+class FSManager {
+    constructor(source, destination) {
+        this.source = source;
+        this.destination = destination;
+    }
+    path(...parts) {
+        return Path.join(this.destination, ...parts);
+    }
+    mkdir(path, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullPath = Path.join(this.destination, path);
+            return new Promise((resolve, reject) => {
+                (0, fs_1.mkdir)(fullPath, options, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                });
+            });
+        });
+    }
+    readdir(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = Path.join(this.destination, path);
+            return new Promise((resolve, reject) => {
+                (0, fs_1.readdir)(filePath, (err, files) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(files);
+                });
+            });
+        });
+    }
+    exists(path) {
+        const fullPath = Path.join(this.destination, path);
+        return (0, fs_1.existsSync)(fullPath);
+    }
+    copy(path) {
+        const destination = Path.join(this.destination, path);
+        if ((0, fs_1.existsSync)(destination)) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            (0, fs_1.copyFile)(Path.join(this.source, path), destination, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(undefined);
+            });
+        });
+    }
+    readJSON(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = Path.join(this.destination, ...path);
+            const res = yield new Promise((resolve, reject) => {
+                (0, fs_1.readFile)(filePath, (err, data) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(data);
+                });
+            });
+            return JSON.parse(res.toString());
+        });
+    }
+    writeJSON(path, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const json = JSON.stringify(data, null, 4);
+            const filePath = Path.join(this.destination, path);
+            return new Promise((resolve, reject) => {
+                (0, fs_1.writeFile)(filePath, json, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                });
+            });
+        });
+    }
+    rm(path, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = Path.join(this.destination, path);
+            return new Promise((resolve, reject) => {
+                fs_1.default.rm(filePath, options, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                });
+            });
+        });
+    }
+    createWriteStream(...parts) {
+        const filePath = Path.join(this.destination, ...parts);
+        return (0, fs_1.createWriteStream)(filePath);
+    }
+    createReadStream(path, options) {
+        const filePath = Path.join(this.destination, path);
+        return (0, fs_1.createReadStream)(filePath, options);
+    }
+}
+exports.FSManager = FSManager;

package/lib/makes/Logger.d.ts

@@ -0,0 +1,9 @@
+import { DI } from "./DI";
+declare class Logger {
+    static install(di: DI): void;
+    static log(...data: any[]): void;
+    static info(...data: any[]): void;
+    static warning(...data: any[]): void;
+    static error(...data: any[]): void;
+}
+export { Logger };

package/lib/makes/Logger.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const LogService_1 = require("../services/LogService");
+let _di;
+class Logger {
+    static install(di) {
+        _di = di;
+    }
+    static log(...data) {
+        _di.resolveService(LogService_1.LogService).log(...data);
+    }
+    static info(...data) {
+        _di.resolveService(LogService_1.LogService).info(...data);
+    }
+    static warning(...data) {
+        _di.resolveService(LogService_1.LogService).warning(...data);
+    }
+    static error(...data) {
+        _di.resolveService(LogService_1.LogService).error(...data);
+    }
+}
+exports.Logger = Logger;

package/lib/models/Preset.d.ts

@@ -0,0 +1,46 @@
+import { DI } from "../makes/DI";
+import { PresetServiceSearchOptions as SearchOptions } from "../services/PresetService";
+import { EnvConfig } from "../types/EnvConfig";
+type TextOption = {
+    type: "string" | "number" | "int";
+    message?: string;
+    default?: string | number;
+};
+type ConfirmOption = {
+    type: "boolean";
+    message?: string;
+    default?: boolean;
+};
+type SelectOption = {
+    type: "select";
+    options: string[] | {
+        label?: string;
+        value: string;
+    }[] | {
+        [name: string]: string;
+    };
+    message?: string;
+    default?: string;
+};
+type AnyOption = TextOption | ConfirmOption | SelectOption;
+declare class Preset {
+    id: string;
+    name: string;
+    version: string;
+    dockerfile?: string;
+    buildArgsOptions?: {
+        [name: string]: AnyOption;
+    };
+    envOptions?: {
+        [name: string]: AnyOption;
+    };
+    volumes?: string[];
+    volumeOptions?: string[];
+    constructor(data: any);
+    save(): Promise<void>;
+    getImageName(buildArgs?: EnvConfig): string;
+    static install(di: DI): void;
+    static search(options: SearchOptions): Promise<Preset[]>;
+    static searchOne(options: SearchOptions): Promise<Preset | null | undefined>;
+}
+export { Preset };

package/lib/models/Preset.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Preset = void 0;
+const PresetService_1 = require("../services/PresetService");
+let _di;
+class Preset {
+    constructor(data) {
+        this.id = data.id;
+        this.name = data.name;
+        this.version = data.version;
+        this.dockerfile = data.dockerfile;
+        this.buildArgsOptions = data.buildArgsOptions;
+        this.envOptions = data.envOptions;
+        this.volumes = data.volumes;
+        this.volumeOptions = data.volumeOptions;
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return _di.resolveService(PresetService_1.PresetService).save(this);
+        });
+    }
+    getImageName(buildArgs) {
+        return _di.resolveService(PresetService_1.PresetService).getImageName(this, buildArgs);
+    }
+    static install(di) {
+        _di = di;
+    }
+    static search(options) {
+        return _di.resolveService(PresetService_1.PresetService).search(options);
+    }
+    static searchOne(options) {
+        return _di.resolveService(PresetService_1.PresetService).searchOne(options);
+    }
+}
+exports.Preset = Preset;

package/lib/models/Project.d.ts

@@ -11,13 +11,17 @@ declare class Project {
     name: string;
     type: string;
     path: string;
+    preset?: string;
     imageName?: string;
     dockerfile?: string;
-    env: EnvConfig;
+    scripts?: string[];
     buildArgs?: EnvConfig;
+    env: EnvConfig;
     volumes?: string[];
+    ports?: string[];
     static di?: DI;
     constructor(data: any);
+    hasEnv(name: string): boolean;
     getEnv(name: string, defaultValue?: string): string | undefined;
     setEnv(name: string, value: string | boolean): void;
     unsetEnv(name: string): void;

package/lib/models/Project.js

@@ -22,9 +22,20 @@ class Project {
         this.name = data.name;
         this.type = data.type;
         this.path = data.path;
+        this.preset = data.preset;
+        this.dockerfile = data.dockerfile;
         this.imageName = data.imageName;
-        this.env = data.env || {};
+        this.scripts = data.scripts;
         this.buildArgs = data.buildArgs;
+        this.env = data.env || {};
+        this.ports = data.ports;
+        this.volumes = data.volumes;
+    }
+    hasEnv(name) {
+        if (!this.env) {
+            return false;
+        }
+        return this.env.hasOwnProperty(name);
     }
     getEnv(name, defaultValue) {
         const { [name]: value = defaultValue } = this.env;

package/lib/services/AppConfigService.d.ts

@@ -2,23 +2,19 @@ import { AppConfig } from "../types/AppConfig";
 type TypeMap = {
     [type: string]: string;
 };
-declare class AppConfigService {
-    protected DATA_DIR: string;
-    protected PLUGINS_DIR: string;
-    protected MAP_PATH: string;
-    protected pwd: string;
-    protected mapTypes: TypeMap;
-    constructor(DATA_DIR: string, PLUGINS_DIR: string, MAP_PATH: string);
-    dataPath(...args: string[]): string;
-    pluginsPath(...args: string[]): string;
-    getData(): string;
-    getPWD(): string;
-    setPWD(pwd: string): void;
-    getAppConfig(): Promise<AppConfig>;
-    setProject(): Promise<void>;
-    getAllEnvVariables(): Promise<AppConfig["env"]>;
-    getEnvVariable(name: string, defaultValue?: string): Promise<string | undefined>;
-    setProjectConfig(id: string, path: string): Promise<void>;
-    getProjectTypes(): TypeMap;
+declare abstract class AppConfigService {
+    abstract dataPath(...args: string[]): string;
+    abstract pluginsPath(...args: string[]): string;
+    abstract getPWD(): string;
+    abstract setPWD(pwd: string): void;
+    abstract getAppConfig(): Promise<AppConfig>;
+    abstract getAllEnvVariables(): Promise<AppConfig["env"]>;
+    abstract getEnvVariable(name: string, defaultValue?: string): Promise<string | undefined>;
+    abstract setEnvVariable(name: string, value: string | number): Promise<void>;
+    abstract setProjectConfig(id: string, path: string): Promise<void>;
+    abstract getProjectTypes(): TypeMap;
+    abstract registerProjectType(name: string, title?: string): void;
+    abstract activatePlugin(name: string): Promise<void>;
+    abstract deactivatePlugin(name: string): Promise<void>;
 }
 export { AppConfigService };

package/lib/services/AppConfigService.js

@@ -1,94 +1,6 @@
 "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 __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigService = void 0;
-const Path = __importStar(require("path"));
-const FS = __importStar(require("fs"));
 class AppConfigService {
-    constructor(DATA_DIR, PLUGINS_DIR, MAP_PATH) {
-        this.DATA_DIR = DATA_DIR;
-        this.PLUGINS_DIR = PLUGINS_DIR;
-        this.MAP_PATH = MAP_PATH;
-        this.mapTypes = {
-            image: "Image",
-            dockerfile: "Dockerfile"
-        };
-        this.pwd = (process.cwd() || process.env.PWD);
-    }
-    dataPath(...args) {
-        return Path.join(this.DATA_DIR, ...args);
-    }
-    pluginsPath(...args) {
-        return Path.join(this.PLUGINS_DIR, ...args);
-    }
-    getData() {
-        return "Test";
-    }
-    getPWD() {
-        return this.pwd;
-    }
-    setPWD(pwd) {
-        this.pwd = pwd;
-    }
-    getAppConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const content = yield FS.promises.readFile(this.MAP_PATH);
-            return JSON.parse(content.toString());
-        });
-    }
-    setProject() {
-        return __awaiter(this, void 0, void 0, function* () {
-            //
-        });
-    }
-    getAllEnvVariables() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {};
-        });
-    }
-    getEnvVariable(name, defaultValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return undefined;
-        });
-    }
-    setProjectConfig(id, path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("");
-        });
-    }
-    getProjectTypes() {
-        return this.mapTypes;
-    }
 }
 exports.AppConfigService = AppConfigService;

package/lib/services/AppEventsService.d.ts

@@ -1,10 +1,7 @@
 type EventHandle = (...args: any[]) => Promise<void> | void;
-declare class AppEventsService {
-    protected handles: ({
-        [event: string]: EventHandle[];
-    });
-    on(event: string, handle: EventHandle): () => void;
-    off(event: string, handle: EventHandle): void;
-    emit(event: string, ...args: any[]): Promise<void>;
+declare abstract class AppEventsService {
+    abstract on(event: string, handle: EventHandle): void;
+    abstract off(event: string, handle: EventHandle): void;
+    abstract emit(event: string, ...args: any[]): Promise<void>;
 }
-export { EventHandle as AppEventHandle, AppEventsService };
+export { AppEventsService, EventHandle as AppEventHandle };

package/lib/services/AppEventsService.js

@@ -1,40 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppEventsService = void 0;
 class AppEventsService {
-    constructor() {
-        this.handles = {};
-    }
-    on(event, handle) {
-        this.handles[event] = [
-            ...this.handles[event] || [],
-            handle
-        ];
-        return () => {
-            this.handles[event] = this.handles[event].filter((filterHandle) => {
-                return filterHandle !== handle;
-            });
-        };
-    }
-    off(event, handle) {
-        //
-    }
-    emit(event, ...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handles = this.handles[event] || [];
-            for (const i in handles) {
-                yield handles[i](...args);
-            }
-        });
-    }
 }
 exports.AppEventsService = AppEventsService;

package/lib/services/DockerService.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { Container } from "dockerode";
+declare namespace DockerServiceParams {
+    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 abstract class DockerService {
+    abstract createContainer(params: DockerServiceParams.CreateContainer): Promise<Container>;
+    abstract getContainer(name: string): Promise<Container | null>;
+    abstract removeContainer(name: string): Promise<void>;
+    abstract buildImage(params: DockerServiceParams.BuildImage): Promise<any>;
+    abstract imageExists(tag: string): Promise<boolean>;
+    abstract imageRm(tag: string): Promise<void>;
+    abstract pullImage(tag: string): Promise<void>;
+    abstract attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
+}
+export { DockerService, DockerServiceParams };

package/lib/services/DockerService.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerService = void 0;
+class DockerService {
+}
+exports.DockerService = DockerService;

package/lib/services/LogService.d.ts

@@ -0,0 +1,7 @@
+declare abstract class LogService {
+    abstract log(...data: any[]): void;
+    abstract info(...data: any[]): void;
+    abstract warning(...data: any[]): void;
+    abstract error(...data: any[]): void;
+}
+export { LogService };

package/lib/services/LogService.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogService = void 0;
+class LogService {
+}
+exports.LogService = LogService;

package/lib/services/PresetService.d.ts

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

package/lib/{decorators/Module.js → services/PresetService.js}

@@ -9,22 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = void 0;
-const DI_1 = require("../makes/DI");
-const Module = (options) => {
-    const { services = [] } = options;
-    const di = new DI_1.DI();
-    for (const service of services) {
-        //
+exports.PresetService = void 0;
+class PresetService {
+    searchOne(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [preset] = yield this.search(options);
+            return preset || null;
+        });
     }
-    return (Target) => {
-        // @ts-ignore
-        return class extends Target {
-            run(parts) {
-                return __awaiter(this, void 0, void 0, function* () {
-                });
-            }
-        };
-    };
-};
-exports.Module = Module;
+}
+exports.PresetService = PresetService;

package/lib/services/ProjectService.d.ts

@@ -1,15 +1,16 @@
 import { Project } from "../models/Project";
-type SearchParams = {
+type SearchParams = Partial<{
     id: string;
     name: string;
     path: string;
-};
-declare class ProjectService {
-    cdProject(name: string): Promise<void>;
-    get(): Promise<Project>;
-    start(project: Project): Promise<void>;
-    stop(project: Project): Promise<void>;
-    save(project: Project): Promise<void>;
-    search(params?: Partial<SearchParams>): Promise<Project[]>;
+}>;
+declare abstract class ProjectService {
+    abstract cdProject(name: string): Promise<void>;
+    abstract get(): Promise<Project>;
+    abstract start(project: Project): Promise<void>;
+    abstract stop(project: Project): Promise<void>;
+    abstract save(project: Project): Promise<void>;
+    abstract search(params: SearchParams): Promise<Project[]>;
+    searchOne(params?: SearchParams): Promise<Project | null>;
 }
 export { ProjectService, SearchParams as ProjectServiceSearchParams };

package/lib/services/ProjectService.js

@@ -11,34 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectService = void 0;
 class ProjectService {
-    cdProject(name) {
+    searchOne(params = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    get() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    start(project) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    stop(project) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    save(project) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Dependency is missing");
-        });
-    }
-    search(params = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Dependency is missing");
+            const [project] = yield this.search(params);
+            return project || null;
         });
     }
 }

package/lib/types/AppConfig.d.ts

@@ -2,6 +2,7 @@ import { EnvConfig } from "./EnvConfig";
 export type AppConfig = {
     debug?: boolean;
     env: EnvConfig;
+    plugins: string[];
     projects: {
         id: string;
         name?: string;

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.1",
+    "version": "1.0.3",
+    "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Wocker Core",
+    "license": "MIT",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
-    "author": "Kris Papercut <krispcut@gmail.com>",
-    "license": "MIT",
     "scripts": {
         "prepare": "npm run build",
         "watch": "tsc -w",
@@ -13,12 +13,13 @@
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "dependencies": {
-        "@kearisp/cli": "^1.0.2",
+        "@kearisp/cli": "^1.0.3",
         "fs": "^0.0.1-security",
         "path": "^0.12.7",
         "reflect-metadata": "^0.1.13"
     },
     "devDependencies": {
+        "@types/dockerode": "^3.3.23",
         "@types/node": "^20.8.9",
         "typescript": "^5.2.2"
     }

package/lib/controllers/ProjectController.d.ts

@@ -1,9 +0,0 @@
-import { Cli } from "@kearisp/cli";
-import { ConfigService } from "../services/ConfigService";
-import { Controller } from "../makes/Controller";
-export declare class ProjectController extends Controller {
-    protected configService: ConfigService;
-    constructor(configService: ConfigService);
-    install(cli: Cli): void;
-    test(): string;
-}

package/lib/controllers/ProjectController.js

@@ -1,33 +0,0 @@
-"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.ProjectController = void 0;
-const Injectable_1 = require("../decorators/Injectable");
-const ConfigService_1 = require("../services/ConfigService");
-const Controller_1 = require("../makes/Controller");
-let ProjectController = class ProjectController extends Controller_1.Controller {
-    constructor(configService) {
-        super();
-        this.configService = configService;
-    }
-    install(cli) {
-        super.install(cli);
-        cli.command("test").action(() => this.test());
-    }
-    test() {
-        return this.configService.dataPath("data");
-    }
-};
-exports.ProjectController = ProjectController;
-exports.ProjectController = ProjectController = __decorate([
-    (0, Injectable_1.Injectable)(),
-    __metadata("design:paramtypes", [ConfigService_1.ConfigService])
-], ProjectController);

package/lib/decorators/Controller.d.ts

@@ -1,4 +0,0 @@
-import "reflect-metadata";
-export declare const Controller: () => <T extends new (...rest: any[]) => {}>(Target: T) => {
-    new (): {};
-} & T;

package/lib/decorators/Controller.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = void 0;
-require("reflect-metadata");
-const DI_1 = require("../makes/DI");
-const di = new DI_1.DI();
-const Controller = () => {
-    // return (Target: any) => {
-    //     const types = Reflect.getMetadata("design:paramtypes", Target);
-    //
-    //     const params = types.map((type: any) => {
-    //         return di.resolveService(type);
-    //     });
-    // };
-    return (Target) => {
-        const types = Reflect.getMetadata("design:paramtypes", Target);
-        const params = types.map((type) => {
-            return di.resolveService(type);
-        });
-        // @ts-ignore
-        return class extends Target {
-            constructor() {
-                super(...params);
-            }
-        };
-    };
-};
-exports.Controller = Controller;

package/lib/decorators/Module.d.ts

@@ -1,9 +0,0 @@
-type Options = {
-    services: any[];
-};
-export declare const Module: (options: Options) => <T extends new () => {}>(Target: T) => {
-    new (): {
-        run(parts: string[]): Promise<void>;
-    };
-} & T;
-export {};

package/lib/services/AppConfigInterface.js

@@ -1 +0,0 @@
-"use strict";

package/lib/services/ConfigService.d.ts

@@ -1,9 +0,0 @@
-declare class ConfigService {
-    protected DATA_DIR: string;
-    protected PLUGINS_DIR: string;
-    constructor(DATA_DIR: string, PLUGINS_DIR: string);
-    dataPath(...args: string[]): string;
-    pluginsPath(...args: string[]): string;
-    getData(): string;
-}
-export { ConfigService };

package/lib/services/ConfigService.js

@@ -1,43 +0,0 @@
-"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 __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigService = void 0;
-const Path = __importStar(require("path"));
-class ConfigService {
-    constructor(DATA_DIR, PLUGINS_DIR) {
-        this.DATA_DIR = DATA_DIR;
-        this.PLUGINS_DIR = PLUGINS_DIR;
-    }
-    dataPath(...args) {
-        return Path.join(this.DATA_DIR, ...args);
-    }
-    pluginsPath(...args) {
-        return Path.join(this.PLUGINS_DIR, ...args);
-    }
-    getData() {
-        return "Test";
-    }
-}
-exports.ConfigService = ConfigService;

package/lib/services/DockerInterface.d.ts

@@ -1,2 +0,0 @@
-declare class DockerInterface {
-}

package/lib/services/DockerInterface.js

@@ -1,3 +0,0 @@
-"use strict";
-class DockerInterface {
-}

package/lib/services/ProjectServiceInterface.d.ts

@@ -1,8 +0,0 @@
-import { Project } from "../models/Project";
-declare class ProjectServiceInterface {
-    cdProject(name: string): Promise<void>;
-    get(): Promise<Project>;
-    start(project: Project): Promise<void>;
-    stop(project: Project): Promise<void>;
-}
-export { ProjectServiceInterface };

package/lib/services/ProjectServiceInterface.js

@@ -1,35 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectServiceInterface = void 0;
-class ProjectServiceInterface {
-    cdProject(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    get() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    start(project) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-    stop(project) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Project not found");
-        });
-    }
-}
-exports.ProjectServiceInterface = ProjectServiceInterface;