@wocker/core 1.0.1 → 1.0.2

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,15 @@ export * from "./decorators/Inject";
 export * from "./decorators/Injectable";
 export * from "./makes/Controller";
 export * from "./makes/DI";
+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,15 @@ __exportStar(require("./decorators/Inject"), exports);
 __exportStar(require("./decorators/Injectable"), exports);
 __exportStar(require("./makes/Controller"), exports);
 __exportStar(require("./makes/DI"), 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/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,16 @@ declare class Project {
     name: string;
     type: string;
     path: string;
+    preset?: string;
     imageName?: string;
     dockerfile?: string;
     env: EnvConfig;
     buildArgs?: 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,19 @@ 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.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,18 @@ 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>;
 }
 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,42 @@
+/// <reference types="node" />
+import { Container } from "dockerode";
+declare namespace DockerServiceParams {
+    type CreateContainer = {
+        name: string;
+        image: string;
+        restart?: "always";
+        projectId?: string;
+        tty?: boolean;
+        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/services/{ProjectServiceInterface.js → PresetService.js}

@@ -9,27 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectServiceInterface = void 0;
-class ProjectServiceInterface {
-    cdProject(name) {
+exports.PresetService = void 0;
+class PresetService {
+    searchOne(options) {
         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");
+            const [preset] = yield this.search(options);
+            return preset || null;
         });
     }
 }
-exports.ProjectServiceInterface = ProjectServiceInterface;
+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,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "description": "Wocker Core",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -19,6 +19,7 @@
         "reflect-metadata": "^0.1.13"
     },
     "devDependencies": {
+        "@types/dockerode": "^3.3.23",
         "@types/node": "^20.8.9",
         "typescript": "^5.2.2"
     }

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 };