@wocker/core 1.0.8 → 1.0.10

package/lib/decorators/Module.d.ts

@@ -1,15 +1,13 @@
-import { MODULE_METADATA } from "../env";
+import { MODULE_METADATA, PLUGIN_NAME_METADATA } from "../env";
 import { Provider } from "../types/Provider";
-import { Type } from "../types/Type";
-type Config = {
-    [MODULE_METADATA.NAME]?: string;
+export type ModuleConfig = {
+    /**
+     * @deprecated
+     */
+    [PLUGIN_NAME_METADATA]?: string;
     [MODULE_METADATA.CONTROLLERS]?: any[];
     [MODULE_METADATA.PROVIDERS]?: Provider[];
     [MODULE_METADATA.IMPORTS]?: any[];
     [MODULE_METADATA.EXPORTS]?: any[];
 };
-export type DynamicModule = {
-    providers?: any[];
-};
-export declare const Module: (config: Config) => <T extends Type>(Target: T) => void;
-export {};
+export declare const Module: (config: ModuleConfig) => ClassDecorator;

package/lib/decorators/Module.js

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Module = void 0;
 const env_1 = require("../env");
 const Module = (config) => {
-    const { [env_1.MODULE_METADATA.NAME]: name, [env_1.MODULE_METADATA.CONTROLLERS]: controllers = [], [env_1.MODULE_METADATA.PROVIDERS]: providers = [], [env_1.MODULE_METADATA.IMPORTS]: imports = [], [env_1.MODULE_METADATA.EXPORTS]: exports = [] } = config;
-    return (Target) => {
-        Reflect.defineMetadata("isModule", true, Target);
-        Reflect.defineMetadata(env_1.MODULE_METADATA.NAME, name, Target);
-        Reflect.defineMetadata(env_1.MODULE_METADATA.IMPORTS, imports, Target);
-        Reflect.defineMetadata(env_1.MODULE_METADATA.CONTROLLERS, controllers, Target);
-        Reflect.defineMetadata(env_1.MODULE_METADATA.PROVIDERS, providers, Target);
-        Reflect.defineMetadata(env_1.MODULE_METADATA.EXPORTS, exports, Target);
+    const { [env_1.PLUGIN_NAME_METADATA]: name, [env_1.MODULE_METADATA.CONTROLLERS]: controllers = [], [env_1.MODULE_METADATA.PROVIDERS]: providers = [], [env_1.MODULE_METADATA.IMPORTS]: imports = [], [env_1.MODULE_METADATA.EXPORTS]: exports = [] } = config;
+    return (target) => {
+        if (name) {
+            Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
+        }
+        Reflect.defineMetadata("isModule", true, target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.IMPORTS, imports, target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.CONTROLLERS, controllers, target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.PROVIDERS, providers, target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.EXPORTS, exports, target);
     };
 };
 exports.Module = Module;

package/lib/decorators/Plugin.d.ts

@@ -0,0 +1,7 @@
+import { ModuleConfig } from "./Module";
+import { PLUGIN_NAME_METADATA } from "../env";
+type PluginConfig = ModuleConfig & {
+    [PLUGIN_NAME_METADATA]: string;
+};
+export declare const Plugin: (config: PluginConfig) => ClassDecorator;
+export {};

package/lib/decorators/Plugin.js

@@ -0,0 +1,25 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const Module_1 = require("./Module");
+const env_1 = require("../env");
+const Plugin = (config) => {
+    const { name } = config, rest = __rest(config, ["name"]);
+    return (target) => {
+        Reflect.defineMetadata("isPlugin", true, target);
+        Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
+        (0, Module_1.Module)(rest)(target);
+    };
+};
+exports.Plugin = Plugin;

package/lib/decorators/index.d.ts

@@ -5,3 +5,4 @@ export * from "./Inject";
 export * from "./Injectable";
 export * from "./Module";
 export * from "./Option";
+export * from "./Plugin";

package/lib/decorators/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./Inject"), exports);
 __exportStar(require("./Injectable"), exports);
 __exportStar(require("./Module"), exports);
 __exportStar(require("./Option"), exports);
+__exportStar(require("./Plugin"), exports);

package/lib/env.d.ts

@@ -9,6 +9,7 @@ export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
 export declare const INJECT_TOKEN_METADATA = "INJECT_TOKEN";
 export declare const PLUGIN_DIR_KEY = "PLUGIN_DIR";
+export declare const PLUGIN_NAME_METADATA = "name";
 export declare enum MODULE_METADATA {
     NAME = "name",
     IMPORTS = "imports",

package/lib/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODULE_METADATA = exports.PLUGIN_DIR_KEY = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.OPTION_META = exports.ARGS_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_METADATA = exports.ARGS_META = exports.INJECTABLE_WATERMARK = exports.IS_MODULE = void 0;
+exports.MODULE_METADATA = exports.PLUGIN_NAME_METADATA = exports.PLUGIN_DIR_KEY = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.OPTION_META = exports.ARGS_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_METADATA = exports.ARGS_META = exports.INJECTABLE_WATERMARK = exports.IS_MODULE = void 0;
 exports.IS_MODULE = "IS_MODULE";
 exports.INJECTABLE_WATERMARK = "__injectable__";
 exports.ARGS_META = "__ARGS__";
@@ -12,6 +12,7 @@ exports.PARAMTYPES_METADATA = "design:paramtypes";
 exports.SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
 exports.INJECT_TOKEN_METADATA = "INJECT_TOKEN";
 exports.PLUGIN_DIR_KEY = "PLUGIN_DIR";
+exports.PLUGIN_NAME_METADATA = "name";
 var MODULE_METADATA;
 (function (MODULE_METADATA) {
     MODULE_METADATA["NAME"] = "name";

package/lib/makes/ApplicationContext.d.ts

@@ -0,0 +1,9 @@
+import { Type } from "../types/Type";
+import { Container } from "./Container";
+export declare class ApplicationContext {
+    protected module: any;
+    protected container: Container;
+    constructor(module: any, container: Container);
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
+    run(args: string[]): Promise<any>;
+}

package/lib/makes/ApplicationContext.js

@@ -0,0 +1,34 @@
+"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.ApplicationContext = void 0;
+const cli_1 = require("@kearisp/cli");
+class ApplicationContext {
+    constructor(module, container) {
+        this.module = module;
+        this.container = container;
+    }
+    get(typeOrToken) {
+        var _a;
+        const res = (_a = this.container.getModule(this.module)) === null || _a === void 0 ? void 0 : _a.get(typeOrToken);
+        if (!res) {
+            throw new Error("Instance not found");
+        }
+        return res;
+    }
+    run(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cli = this.get(cli_1.Cli);
+            return cli.run(args);
+        });
+    }
+}
+exports.ApplicationContext = ApplicationContext;

package/lib/makes/Config.d.ts

@@ -0,0 +1,26 @@
+import { EnvConfig, PickProperties } from "../types";
+export type ConfigProperties = PickProperties<Config>;
+export declare abstract class Config {
+    debug?: boolean;
+    logLevel: "off" | "info" | "warn" | "error";
+    plugins: string[];
+    projects: {
+        id: string;
+        name?: string;
+        src: string;
+    }[];
+    meta?: EnvConfig;
+    env?: EnvConfig;
+    protected constructor(data: ConfigProperties);
+    addPlugin(plugin: string): void;
+    removePlugin(removePlugin: string): void;
+    setProject(id: string, path: string): void;
+    getMeta(name: string, defaultValue: string): string;
+    setMeta(name: string, value: string): void;
+    unsetMeta(name: string): void;
+    getEnv(name: string, defaultValue: string): string;
+    setEnv(name: string, value: string): void;
+    unsetEnv(name: string): void;
+    abstract save(): Promise<void>;
+    toJson(): ConfigProperties;
+}

package/lib/makes/Config.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+class Config {
+    constructor(data) {
+        this.logLevel = "off";
+        this.plugins = [];
+        this.projects = [];
+        Object.assign(this, data);
+    }
+    addPlugin(plugin) {
+        if (!this.plugins) {
+            this.plugins = [];
+        }
+        if (this.plugins.includes(plugin)) {
+            return;
+        }
+        this.plugins.push(plugin);
+    }
+    removePlugin(removePlugin) {
+        this.plugins = this.plugins.filter((plugin) => plugin !== removePlugin);
+    }
+    setProject(id, path) {
+        this.projects = [
+            ...this.projects.filter((project) => {
+                return project.id !== id && project.src !== path;
+            }),
+            {
+                id,
+                src: path
+            }
+        ];
+    }
+    getMeta(name, defaultValue) {
+        if (!this.meta || !(name in this.meta)) {
+            return defaultValue;
+        }
+        return this.meta[name];
+    }
+    setMeta(name, value) {
+        if (!this.meta) {
+            this.meta = {};
+        }
+        this.meta[name] = value;
+    }
+    unsetMeta(name) {
+        if (!this.meta || !(name in this.meta)) {
+            return;
+        }
+        delete this.meta[name];
+        if (Object.keys(this.meta).length === 0) {
+            delete this.meta;
+        }
+    }
+    getEnv(name, defaultValue) {
+        if (!this.env || !(name in this.env)) {
+            return defaultValue;
+        }
+        return this.env[name];
+    }
+    setEnv(name, value) {
+        if (!this.env) {
+            this.env = {};
+        }
+        this.env[name] = value;
+    }
+    unsetEnv(name) {
+        if (!this.env || !(name in this.env)) {
+            return;
+        }
+        delete this.env[name];
+        if (Object.keys(this.env).length === 0) {
+            delete this.env;
+        }
+    }
+    toJson() {
+        return {
+            debug: this.debug,
+            logLevel: this.logLevel,
+            plugins: this.plugins,
+            projects: this.projects,
+            meta: this.meta,
+            env: this.env
+        };
+    }
+}
+exports.Config = Config;

package/lib/makes/FS.d.ts

@@ -8,12 +8,13 @@ type ReadFileOptions = Abortable & {
     encoding?: BufferEncoding;
     flag?: string;
 };
-declare class FS {
+export declare class FS {
     static mkdir(path: PathLike, options?: MakeDirectoryOptions): Promise<unknown>;
     static readFile(filePath: PathOrFileDescriptor, options?: ReadFileOptions): Promise<string | Buffer>;
     static writeFile(filePath: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<unknown>;
     static readJSON(...paths: string[]): Promise<any>;
     static writeJSON(filePath: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<void>;
+    static readdir(path: PathLike): Promise<string[]>;
     static rm(path: PathLike, options?: RmOptions): Promise<void>;
 }
-export { FS };
+export {};

package/lib/makes/FS.js

@@ -31,15 +31,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
-const fs_1 = require("fs");
+const fs_1 = __importDefault(require("fs"));
 const Path = __importStar(require("path"));
 class FS {
     static mkdir(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                (0, fs_1.mkdir)(path, options, (err) => {
+                fs_1.default.mkdir(path, options, (err) => {
                     if (err) {
                         reject(err);
                         return;
@@ -52,7 +55,7 @@ class FS {
     static readFile(filePath, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                (0, fs_1.readFile)(filePath, options, (err, res) => {
+                fs_1.default.readFile(filePath, options, (err, res) => {
                     if (err) {
                         reject(err);
                         return;
@@ -73,10 +76,10 @@ class FS {
                     resolve(undefined);
                 };
                 if (options) {
-                    (0, fs_1.writeFile)(filePath, data, options, callback);
+                    fs_1.default.writeFile(filePath, data, options, callback);
                 }
                 else {
-                    (0, fs_1.writeFile)(filePath, data, callback);
+                    fs_1.default.writeFile(filePath, data, callback);
                 }
             });
         });
@@ -85,7 +88,7 @@ class FS {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield new Promise((resolve, reject) => {
                 const filePath = Path.join(...paths);
-                (0, fs_1.readFile)(filePath, (err, data) => {
+                fs_1.default.readFile(filePath, (err, data) => {
                     if (err) {
                         reject(err);
                         return;
@@ -108,14 +111,28 @@ class FS {
                     resolve(undefined);
                 };
                 if (options) {
-                    (0, fs_1.writeFile)(filePath, json, options, callback);
+                    fs_1.default.writeFile(filePath, json, options, callback);
                 }
                 else {
-                    (0, fs_1.writeFile)(filePath, json, callback);
+                    fs_1.default.writeFile(filePath, json, callback);
                 }
             });
         });
     }
+    static readdir(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fs_1.default.readdir(path, (err, files) => {
+                    if (!err) {
+                        resolve(files);
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        });
+    }
     static rm(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
@@ -127,10 +144,10 @@ class FS {
                     resolve(undefined);
                 };
                 if (options) {
-                    (0, fs_1.rm)(path, options, callback);
+                    fs_1.default.rm(path, options, callback);
                 }
                 else {
-                    (0, fs_1.rm)(path, callback);
+                    fs_1.default.rm(path, callback);
                 }
             });
         });

package/lib/makes/FSManager.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import fs, { createReadStream, MakeDirectoryOptions, RmOptions } from "fs";
-declare class FSManager {
-    protected source: string;
-    protected destination: string;
+import { FileSystem } from "./FileSystem";
+export declare class FSManager {
+    readonly source: FileSystem;
+    readonly destination: FileSystem;
     constructor(source: string, destination: string);
     path(...parts: string[]): string;
     mkdir(path: string, options?: MakeDirectoryOptions): Promise<unknown>;
@@ -15,4 +16,3 @@ declare class FSManager {
     createWriteStream(...parts: string[]): fs.WriteStream;
     createReadStream(path: string, options?: Parameters<typeof createReadStream>[1]): fs.ReadStream;
 }
-export { FSManager };

package/lib/makes/FSManager.js

@@ -34,18 +34,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FSManager = void 0;
 const fs_1 = __importStar(require("fs"));
-const Path = __importStar(require("path"));
+const FileSystem_1 = require("./FileSystem");
 class FSManager {
     constructor(source, destination) {
-        this.source = source;
-        this.destination = destination;
+        this.source = new FileSystem_1.FileSystem(source);
+        this.destination = new FileSystem_1.FileSystem(destination);
     }
     path(...parts) {
-        return Path.join(this.destination, ...parts);
+        return this.destination.path(...parts);
     }
     mkdir(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, options = {}) {
-            const fullPath = Path.join(this.destination, path);
+            const fullPath = this.path(path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.mkdir)(fullPath, options, (err) => {
                     if (err) {
@@ -59,7 +59,7 @@ class FSManager {
     }
     readdir(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filePath = Path.join(this.destination, path);
+            const filePath = this.path(path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.readdir)(filePath, (err, files) => {
                     if (err) {
@@ -72,16 +72,16 @@ class FSManager {
         });
     }
     exists(path) {
-        const fullPath = Path.join(this.destination, path);
+        const fullPath = this.path(path);
         return (0, fs_1.existsSync)(fullPath);
     }
     copy(path) {
-        const destination = Path.join(this.destination, path);
+        const destination = this.path(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) => {
+            (0, fs_1.copyFile)(this.source.path(path), destination, (err) => {
                 if (err) {
                     reject(err);
                     return;
@@ -92,7 +92,7 @@ class FSManager {
     }
     readJSON(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filePath = Path.join(this.destination, ...path);
+            const filePath = this.path(path);
             const res = yield new Promise((resolve, reject) => {
                 (0, fs_1.readFile)(filePath, (err, data) => {
                     if (err) {
@@ -108,7 +108,7 @@ class FSManager {
     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);
+            const filePath = this.path(path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.writeFile)(filePath, json, (err) => {
                     if (err) {
@@ -122,7 +122,7 @@ class FSManager {
     }
     rm(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, options = {}) {
-            const filePath = Path.join(this.destination, path);
+            const filePath = this.path(path);
             return new Promise((resolve, reject) => {
                 fs_1.default.rm(filePath, options, (err) => {
                     if (err) {
@@ -135,11 +135,11 @@ class FSManager {
         });
     }
     createWriteStream(...parts) {
-        const filePath = Path.join(this.destination, ...parts);
+        const filePath = this.path(...parts);
         return (0, fs_1.createWriteStream)(filePath);
     }
     createReadStream(path, options) {
-        const filePath = Path.join(this.destination, path);
+        const filePath = this.path(path);
         return (0, fs_1.createReadStream)(filePath, options);
     }
 }

package/lib/makes/Factory.d.ts

@@ -1,3 +1,5 @@
+import { ApplicationContext } from "./ApplicationContext";
+import { Container } from "./Container";
 import { Module } from "./Module";
 export declare class Factory {
     private readonly cli;
@@ -13,5 +15,6 @@ export declare class Factory {
     log(...args: any[]): void;
     init(): Promise<void>;
     run(args: string[]): Promise<any>;
-    static create(module: any): Promise<Factory>;
+    getContainer(): Container;
+    static create(module: any): Promise<ApplicationContext>;
 }

package/lib/makes/Factory.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Factory = void 0;
 const cli_1 = require("@kearisp/cli");
+const ApplicationContext_1 = require("./ApplicationContext");
 const Container_1 = require("./Container");
 const Module_1 = require("./Module");
 const env_1 = require("../env");
@@ -98,7 +99,8 @@ class Factory {
                             continue;
                         }
                         const commandName = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value);
-                        const completions = (Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || []).map((completion) => {
+                        const completions = (Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || [])
+                            .map((completion) => {
                             return Object.assign(Object.assign({}, completion), { method: name });
                         });
                         if (completions.length > 0) {
@@ -190,11 +192,14 @@ class Factory {
             return this.cli.run(args);
         });
     }
+    getContainer() {
+        return this.container;
+    }
     static create(module) {
         return __awaiter(this, void 0, void 0, function* () {
             const factory = new this();
             yield factory.scan(module);
-            return factory;
+            return new ApplicationContext_1.ApplicationContext(module, factory.getContainer());
         });
     }
 }

package/lib/makes/FileSystem.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import * as fs from "fs";
+type ReaddirOptions = fs.ObjectEncodingOptions & {
+    recursive?: boolean | undefined;
+};
+export declare class FileSystem {
+    protected readonly source: string;
+    constructor(source: string);
+    path(...parts: string[]): string;
+    exists(...parts: string[]): boolean;
+    stat(...parts: string[]): fs.Stats;
+    mkdir(path: string, options?: fs.MakeDirectoryOptions): void;
+    readdir(...parts: string[]): Promise<unknown>;
+    readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
+}
+export {};

package/lib/makes/FileSystem.js

@@ -0,0 +1,90 @@
+"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.FileSystem = void 0;
+const fs = __importStar(require("fs"));
+const Path = __importStar(require("path"));
+class FileSystem {
+    constructor(source) {
+        this.source = source;
+    }
+    path(...parts) {
+        return Path.join(this.source, ...parts);
+    }
+    exists(...parts) {
+        const fullPath = this.path(...parts);
+        return fs.existsSync(fullPath);
+    }
+    stat(...parts) {
+        const fullPath = this.path(...parts);
+        return fs.statSync(fullPath);
+    }
+    mkdir(path, options) {
+        const fullPath = this.path(path);
+        fs.mkdirSync(fullPath, options);
+    }
+    readdir(...parts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullPath = this.path(...parts);
+            return new Promise((resolve, reject) => {
+                fs.readdir(fullPath, (err, files) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(files);
+                });
+            });
+        });
+    }
+    readdirFiles() {
+        return __awaiter(this, arguments, void 0, function* (path = "", options) {
+            const fullPath = this.path(path);
+            return new Promise((resolve, reject) => {
+                fs.readdir(fullPath, options, (err, files) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    files = files.filter((path) => {
+                        const stat = this.stat(path);
+                        return stat.isFile();
+                    });
+                    resolve(files);
+                });
+            });
+        });
+    }
+}
+exports.FileSystem = FileSystem;

package/lib/makes/Project.d.ts

@@ -1,11 +1,6 @@
 import { PickProperties, EnvConfig } from "../types";
-import { DI } from "./DI";
-type SearchOptions = {
-    id: string;
-    name: string;
-    path: string;
-};
-export declare class Project {
+type ProjectProperties = Omit<PickProperties<Project>, "containerName">;
+export declare abstract class Project {
     id: string;
     name: string;
     type: string;
@@ -19,7 +14,7 @@ export declare class Project {
     ports?: string[];
     volumes?: string[];
     metadata?: EnvConfig;
-    protected constructor(data: PickProperties<Project>);
+    protected constructor(data: ProjectProperties);
     get containerName(): string;
     hasEnv(name: string): boolean;
     getEnv(name: string, defaultValue?: string): string | undefined;
@@ -33,11 +28,8 @@ export declare class Project {
     getVolumeByDestination(destination: string): string | undefined;
     volumeMount(...volumes: string[]): void;
     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>;
+    abstract save(): Promise<void>;
+    toJSON(): ProjectProperties;
 }
 export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
 export declare const PROJECT_TYPE_IMAGE = "image";

package/lib/makes/Project.js

@@ -1,18 +1,7 @@
 "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;
 const volumeParse_1 = require("../utils/volumeParse");
-const services_1 = require("../services");
-let projectService;
 class Project {
     constructor(data) {
         this.id = data.id;
@@ -117,33 +106,22 @@ class Project {
             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) {
-        projectService = di.resolveService(services_1.ProjectService);
-    }
-    static fromObject(data) {
-        return new Project(data);
-    }
-    static search() {
-        return __awaiter(this, arguments, void 0, function* (params = {}) {
-            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;
-        });
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            path: this.path,
+            preset: this.preset,
+            imageName: this.imageName,
+            dockerfile: this.dockerfile,
+            scripts: this.scripts,
+            buildArgs: this.buildArgs,
+            env: this.env,
+            ports: this.ports,
+            volumes: this.volumes,
+            metadata: this.metadata
+        };
     }
 }
 exports.Project = Project;

package/lib/makes/index.d.ts

@@ -1,9 +1,10 @@
+export * from "./Config";
 export * from "./Container";
 export * from "./DI";
+export * from "./FileSystem";
 export * from "./FS";
 export * from "./FSManager";
 export * from "./Logger";
-export * from "./Plugin";
 export * from "./Preset";
 export * from "./Project";
 export * from "./Factory";

package/lib/makes/index.js

@@ -14,12 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Config"), exports);
 __exportStar(require("./Container"), exports);
 __exportStar(require("./DI"), exports);
+__exportStar(require("./FileSystem"), exports);
 __exportStar(require("./FS"), exports);
 __exportStar(require("./FSManager"), exports);
 __exportStar(require("./Logger"), exports);
-__exportStar(require("./Plugin"), exports);
 __exportStar(require("./Preset"), exports);
 __exportStar(require("./Project"), exports);
 __exportStar(require("./Factory"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,22 +1,16 @@
-import { AppConfig } from "../types";
+import { Config } from "../makes";
 type TypeMap = {
     [type: string]: string;
 };
 declare abstract class AppConfigService {
+    protected config?: Config;
     abstract dataPath(...args: string[]): string;
     abstract pluginsPath(...args: string[]): string;
     abstract getPWD(): string;
     abstract setPWD(pwd: string): void;
-    abstract getAppConfig(): Promise<AppConfig>;
-    abstract getMeta(name: string, defaultValue?: string): Promise<string | undefined>;
-    abstract setMeta(name: string, value: string | number | undefined): Promise<void>;
-    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>;
+    protected abstract loadConfig(): Promise<Config>;
+    getConfig(): Promise<Config>;
 }
 export { AppConfigService };

package/lib/services/AppConfigService.js

@@ -5,10 +5,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 __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 decorators_1 = require("../decorators");
 let AppConfigService = class AppConfigService {
+    getConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.config) {
+                this.config = yield this.loadConfig();
+            }
+            return this.config;
+        });
+    }
 };
 exports.AppConfigService = AppConfigService;
 exports.AppConfigService = AppConfigService = __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.8",
+    "version": "1.0.10",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of wocker",
     "license": "MIT",
@@ -32,6 +32,6 @@
     "devDependencies": {
         "@types/dockerode": "^3.3.23",
         "@types/node": "^20.11.7",
-        "typescript": "^5.4.3"
+        "typescript": "^5.4.4"
     }
 }

package/lib/makes/Plugin.d.ts

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

package/lib/makes/Plugin.js

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