@wocker/core 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kris Papercut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @wocker/core

package/lib/controllers/ProjectController.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,33 @@
+"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

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

package/lib/decorators/Controller.js

@@ -0,0 +1,28 @@
+"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/Inject.d.ts

@@ -0,0 +1 @@
+export declare const Inject: () => (target: any) => void;

package/lib/decorators/Inject.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = void 0;
+const Inject = () => {
+    return (target) => {
+    };
+};
+exports.Inject = Inject;

package/lib/decorators/Injectable.d.ts

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

package/lib/decorators/Injectable.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = void 0;
+const Injectable = (ddi) => {
+    return (Target) => {
+        // @ts-ignore
+        return class extends Target {
+            constructor(di) {
+                const types = Reflect.getMetadata("design:paramtypes", Target);
+                const params = types.map((type) => {
+                    return (di).resolveService(type);
+                });
+                super(...params);
+            }
+        };
+    };
+};
+exports.Injectable = Injectable;

package/lib/decorators/Module.d.ts

@@ -0,0 +1,9 @@
+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/decorators/Module.js

@@ -0,0 +1,30 @@
+"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.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) {
+        //
+    }
+    return (Target) => {
+        // @ts-ignore
+        return class extends Target {
+            run(parts) {
+                return __awaiter(this, void 0, void 0, function* () {
+                });
+            }
+        };
+    };
+};
+exports.Module = Module;

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export { Cli } from "@kearisp/cli";
+export * from "./decorators/Inject";
+export * from "./decorators/Injectable";
+export * from "./makes/Controller";
+export * from "./makes/DI";
+export * from "./makes/Plugin";
+export * from "./models/Project";
+export * from "./services/AppConfigService";
+export * from "./services/AppEventsService";
+export * from "./services/ProjectService";
+export * from "./services/ProjectServiceInterface";
+export * from "./types/AppConfig";

package/lib/index.js

@@ -0,0 +1,30 @@
+"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 __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 });
+exports.Cli = void 0;
+var cli_1 = require("@kearisp/cli");
+Object.defineProperty(exports, "Cli", { enumerable: true, get: function () { return cli_1.Cli; } });
+__exportStar(require("./decorators/Inject"), exports);
+__exportStar(require("./decorators/Injectable"), exports);
+__exportStar(require("./makes/Controller"), exports);
+__exportStar(require("./makes/DI"), exports);
+__exportStar(require("./makes/Plugin"), exports);
+__exportStar(require("./models/Project"), exports);
+__exportStar(require("./services/AppConfigService"), exports);
+__exportStar(require("./services/AppEventsService"), exports);
+__exportStar(require("./services/ProjectService"), exports);
+__exportStar(require("./services/ProjectServiceInterface"), exports);
+__exportStar(require("./types/AppConfig"), exports);

package/lib/makes/Controller.d.ts

@@ -0,0 +1,5 @@
+import { Cli } from "@kearisp/cli";
+declare class Controller {
+    install(cli: Cli): void;
+}
+export { Controller };

package/lib/makes/Controller.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+class Controller {
+    install(cli) {
+        //
+    }
+}
+exports.Controller = Controller;

package/lib/makes/DI.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DI = void 0;
+require("reflect-metadata");
+class DI {
+    constructor() {
+        this.services = new Map();
+    }
+    resolveService(key) {
+        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);
+            }) : [];
+            res = new key(this);
+            this.services.set(key, res);
+        }
+        return res;
+    }
+    registerService(key, service) {
+        this.services.set(key, service);
+    }
+    use() {
+    }
+}
+exports.DI = DI;

package/lib/makes/FS.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { PathOrFileDescriptor } from "fs";
+declare class FS {
+    static readJSON(filePath: PathOrFileDescriptor): Promise<any>;
+    static writeJSON(filePath: PathOrFileDescriptor, data: any): Promise<void>;
+}
+export { FS };

package/lib/makes/FS.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.FS = void 0;
+const fs_1 = require("fs");
+class FS {
+    static readJSON(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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());
+        });
+    }
+    static writeJSON(filePath, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const json = JSON.stringify(data, null, 4);
+            return new Promise((resolve, reject) => {
+                (0, fs_1.writeFile)(filePath, json, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                });
+            });
+        });
+    }
+}
+exports.FS = FS;

package/lib/makes/Plugin.d.ts

@@ -0,0 +1,6 @@
+import { Cli } from "@kearisp/cli";
+import { Controller } from "./Controller";
+declare class Plugin extends Controller {
+    install(cli: Cli): void;
+}
+export { Plugin };

package/lib/makes/Plugin.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const Controller_1 = require("./Controller");
+class Plugin extends Controller_1.Controller {
+    install(cli) {
+        super.install(cli);
+    }
+}
+exports.Plugin = Plugin;

package/lib/models/Project.d.ts

@@ -0,0 +1,36 @@
+import "reflect-metadata";
+import { DI } from "../makes/DI";
+import { EnvConfig } from "../types/EnvConfig";
+type SearchOptions = {
+    id: string;
+    name: string;
+    path: string;
+};
+declare class Project {
+    id: string;
+    name: string;
+    type: string;
+    path: string;
+    imageName?: string;
+    dockerfile?: string;
+    env: EnvConfig;
+    buildArgs?: EnvConfig;
+    volumes?: string[];
+    static di?: DI;
+    constructor(data: any);
+    getEnv(name: string, defaultValue?: string): string | undefined;
+    setEnv(name: string, value: string | boolean): void;
+    unsetEnv(name: string): void;
+    volumeMount(...volumes: string[]): void;
+    getVolumeBySource(source: string): string | undefined;
+    getVolumeByDestination(destination: string): string | undefined;
+    volumeUnmount(...volumes: string[]): void;
+    save(): Promise<void>;
+    static install(di: DI): void;
+    static fromObject(data: any): Project;
+    static search(params?: Partial<SearchOptions>): Promise<Project[]>;
+    static searchOne(params: Partial<SearchOptions>): Promise<Project | null>;
+}
+export { Project };
+export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
+export declare const PROJECT_TYPE_IMAGE = "image";

package/lib/models/Project.js

@@ -0,0 +1,104 @@
+"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.PROJECT_TYPE_IMAGE = exports.PROJECT_TYPE_DOCKERFILE = exports.Project = void 0;
+require("reflect-metadata");
+const AppConfigService_1 = require("../services/AppConfigService");
+const ProjectService_1 = require("../services/ProjectService");
+const volumeParse_1 = require("../utils/volumeParse");
+let appConfig;
+let projectService;
+class Project {
+    constructor(data) {
+        this.id = data.id;
+        this.name = data.name;
+        this.type = data.type;
+        this.path = data.path;
+        this.imageName = data.imageName;
+        this.env = data.env || {};
+        this.buildArgs = data.buildArgs;
+    }
+    getEnv(name, defaultValue) {
+        const { [name]: value = defaultValue } = this.env;
+        return value;
+    }
+    setEnv(name, value) {
+        this.env = Object.assign(Object.assign({}, this.env), { [name]: typeof value === "boolean"
+                ? (value ? "true" : "false")
+                : value });
+    }
+    unsetEnv(name) {
+        if (name in this.env) {
+            delete this.env[name];
+        }
+    }
+    volumeMount(...volumes) {
+        if (volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const { destination } = (0, volumeParse_1.volumeParse)(volume);
+        this.volumes = [
+            ...(this.volumes || []).filter((v) => {
+                return v !== this.getVolumeByDestination(destination);
+            }),
+            volume
+        ];
+        this.volumeMount(...restVolumes);
+    }
+    getVolumeBySource(source) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).source === source;
+        });
+    }
+    getVolumeByDestination(destination) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
+        });
+    }
+    volumeUnmount(...volumes) {
+        this.volumes = (this.volumes || []).filter((mounted) => {
+            return !volumes.includes(mounted);
+        });
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!projectService) {
+                throw new Error("Dependency is missing");
+            }
+            yield projectService.save(this);
+        });
+    }
+    static install(di) {
+        appConfig = di.resolveService(AppConfigService_1.AppConfigService);
+        projectService = di.resolveService(ProjectService_1.ProjectService);
+    }
+    static fromObject(data) {
+        return new Project(data);
+    }
+    static search(params = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!projectService) {
+                throw new Error("Dependency is missing");
+            }
+            return projectService.search(params);
+        });
+    }
+    static searchOne(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [project] = yield Project.search(params);
+            return project || null;
+        });
+    }
+}
+exports.Project = Project;
+exports.PROJECT_TYPE_DOCKERFILE = "dockerfile";
+exports.PROJECT_TYPE_IMAGE = "image";

package/lib/services/AppConfigInterface.js

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

package/lib/services/AppConfigService.d.ts

@@ -0,0 +1,24 @@
+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;
+}
+export { AppConfigService };

package/lib/services/AppConfigService.js

@@ -0,0 +1,94 @@
+"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

@@ -0,0 +1,10 @@
+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>;
+}
+export { EventHandle as AppEventHandle, AppEventsService };

package/lib/services/AppEventsService.js

@@ -0,0 +1,40 @@
+"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/ConfigService.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,43 @@
+"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

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

package/lib/services/DockerInterface.js

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

package/lib/services/ProjectService.d.ts

@@ -0,0 +1,15 @@
+import { Project } from "../models/Project";
+type SearchParams = {
+    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[]>;
+}
+export { ProjectService, SearchParams as ProjectServiceSearchParams };

package/lib/services/ProjectService.js

@@ -0,0 +1,45 @@
+"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.ProjectService = void 0;
+class ProjectService {
+    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");
+        });
+    }
+    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");
+        });
+    }
+}
+exports.ProjectService = ProjectService;

package/lib/services/ProjectServiceInterface.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,35 @@
+"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;

package/lib/types/AppConfig.d.ts

@@ -0,0 +1,10 @@
+import { EnvConfig } from "./EnvConfig";
+export type AppConfig = {
+    debug?: boolean;
+    env: EnvConfig;
+    projects: {
+        id: string;
+        name?: string;
+        src: string;
+    }[];
+};

package/lib/types/AppConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/EnvConfig.d.ts

@@ -0,0 +1,3 @@
+export type EnvConfig = {
+    [key: string]: string;
+};

package/lib/types/EnvConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/volumeFormat.d.ts

@@ -0,0 +1,6 @@
+export type Volume = {
+    source: string;
+    destination: string;
+    options?: string;
+};
+export declare const volumeFormat: (volume: Volume) => string;

package/lib/utils/volumeFormat.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.volumeFormat = void 0;
+const volumeFormat = (volume) => {
+    const { source, destination, options } = volume;
+    return `${source}:${destination}` + (options ? `:${options}` : "");
+};
+exports.volumeFormat = volumeFormat;

package/lib/utils/volumeParse.d.ts

@@ -0,0 +1,2 @@
+import { Volume } from "./volumeFormat";
+export declare const volumeParse: (volume: string) => Volume;

package/lib/utils/volumeParse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.volumeParse = void 0;
+const volumeParse = (volume) => {
+    const regVolume = /^([^:]+):([^:]+)(?::([^:]+))?$/;
+    const [, source, destination, options] = regVolume.exec(volume) || [];
+    return {
+        source,
+        destination,
+        options
+    };
+};
+exports.volumeParse = volumeParse;

package/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@wocker/core",
+    "version": "1.0.1",
+    "description": "Wocker Core",
+    "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",
+        "build": "tsc",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "dependencies": {
+        "@kearisp/cli": "^1.0.2",
+        "fs": "^0.0.1-security",
+        "path": "^0.12.7",
+        "reflect-metadata": "^0.1.13"
+    },
+    "devDependencies": {
+        "@types/node": "^20.8.9",
+        "typescript": "^5.2.2"
+    }
+}