@wocker/core 1.0.9 → 1.0.11

package/lib/decorators/Command.d.ts

@@ -1 +1,2 @@
+import "reflect-metadata";
 export declare const Command: (command: string) => MethodDecorator;

package/lib/decorators/Command.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
+require("reflect-metadata");
 const env_1 = require("../env");
 const Command = (command) => {
     return (target, key, descriptor) => {

package/lib/decorators/Completion.d.ts

@@ -1 +1,2 @@
+import "reflect-metadata";
 export declare const Completion: (name: string, command?: string) => MethodDecorator;

package/lib/decorators/Completion.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Completion = void 0;
+require("reflect-metadata");
 const Completion = (name, command) => {
     return (target, propertyKey, descriptor) => {
         Reflect.defineMetadata("completion", [

package/lib/decorators/Description.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+export declare const Description: (description: string) => MethodDecorator;

package/lib/decorators/Description.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Description = void 0;
+require("reflect-metadata");
+const env_1 = require("../env");
+const Description = (description) => {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, descriptor);
+    };
+};
+exports.Description = Description;

package/lib/decorators/Module.js

@@ -5,8 +5,10 @@ const env_1 = require("../env");
 const Module = (config) => {
     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.PLUGIN_NAME_METADATA, 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);

package/lib/decorators/Param.d.ts

@@ -1 +1,2 @@
-export declare const Param: (name: string) => MethodDecorator;
+import "reflect-metadata";
+export declare const Param: (name: string) => ParameterDecorator;

package/lib/decorators/Param.js

@@ -1,8 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Param = void 0;
+require("reflect-metadata");
+const env_1 = require("../env");
 const Param = (name) => {
-    return (target, propertyKey, descriptor) => {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            return;
+        }
+        Reflect.defineMetadata(env_1.ARGS_METADATA, [
+            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, propertyKey) || [],
+            {
+                type: "param",
+                name,
+                index: parameterIndex
+            }
+        ], target.constructor, propertyKey);
     };
 };
 exports.Param = Param;

package/lib/decorators/Plugin.js

@@ -18,7 +18,7 @@ const Plugin = (config) => {
     const { name } = config, rest = __rest(config, ["name"]);
     return (target) => {
         Reflect.defineMetadata("isPlugin", true, target);
-        Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, true, target);
+        Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
         (0, Module_1.Module)(rest)(target);
     };
 };

package/lib/decorators/index.d.ts

@@ -1,8 +1,10 @@
 export * from "./Command";
 export * from "./Completion";
 export * from "./Controller";
+export * from "./Description";
 export * from "./Inject";
 export * from "./Injectable";
 export * from "./Module";
 export * from "./Option";
+export * from "./Param";
 export * from "./Plugin";

package/lib/decorators/index.js

@@ -17,8 +17,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Command"), exports);
 __exportStar(require("./Completion"), exports);
 __exportStar(require("./Controller"), exports);
+__exportStar(require("./Description"), exports);
 __exportStar(require("./Inject"), exports);
 __exportStar(require("./Injectable"), exports);
 __exportStar(require("./Module"), exports);
 __exportStar(require("./Option"), exports);
+__exportStar(require("./Param"), exports);
 __exportStar(require("./Plugin"), exports);

package/lib/env.d.ts

@@ -2,6 +2,7 @@ export declare const IS_MODULE = "IS_MODULE";
 export declare const INJECTABLE_WATERMARK = "__injectable__";
 export declare const ARGS_META = "__ARGS__";
 export declare const COMMAND_METADATA = "command";
+export declare const COMMAND_DESCRIPTION_METADATA = "__COMMAND_DESCRIPTION__";
 export declare const COMPLETION_METADATA = "completion";
 export declare const ARGS_METADATA = "__ARGS__";
 export declare const OPTION_META = "__OPTION_META__";

package/lib/env.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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_DESCRIPTION_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__";
 exports.COMMAND_METADATA = "command";
+exports.COMMAND_DESCRIPTION_METADATA = "__COMMAND_DESCRIPTION__";
 exports.COMPLETION_METADATA = "completion";
 exports.ARGS_METADATA = "__ARGS__";
 exports.OPTION_META = "__OPTION_META__";

package/lib/makes/ApplicationContext.d.ts

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

package/lib/makes/ApplicationContext.js

@@ -17,8 +17,11 @@ class ApplicationContext {
         this.container = container;
     }
     get(typeOrToken) {
-        var _a;
-        const res = (_a = this.container.getModule(this.module)) === null || _a === void 0 ? void 0 : _a.get(typeOrToken);
+        const module = this.container.getModule(this.module);
+        if (!module) {
+            throw new Error("Module not found");
+        }
+        const res = module.get(typeOrToken);
         if (!res) {
             throw new Error("Instance not found");
         }

package/lib/makes/Config.d.ts

@@ -1,5 +1,7 @@
 import { EnvConfig, PickProperties } from "../types";
-export type ConfigProperties = PickProperties<Config>;
+export type ConfigProperties = Omit<PickProperties<Config>, "logLevel"> & {
+    logLevel?: Config["logLevel"];
+};
 export declare abstract class Config {
     debug?: boolean;
     logLevel: "off" | "info" | "warn" | "error";
@@ -13,7 +15,7 @@ export declare abstract class Config {
     env?: EnvConfig;
     protected constructor(data: ConfigProperties);
     addPlugin(plugin: string): void;
-    removePlugin(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;

package/lib/makes/Config.js

@@ -9,10 +9,16 @@ class Config {
         Object.assign(this, data);
     }
     addPlugin(plugin) {
+        if (!this.plugins) {
+            this.plugins = [];
+        }
+        if (this.plugins.includes(plugin)) {
+            return;
+        }
         this.plugins.push(plugin);
     }
-    removePlugin(plugin) {
-        this.plugins = this.plugins.filter((plugin) => plugin !== plugin);
+    removePlugin(removePlugin) {
+        this.plugins = this.plugins.filter((plugin) => plugin !== removePlugin);
     }
     setProject(id, path) {
         this.projects = [

package/lib/makes/Container.d.ts

@@ -4,5 +4,4 @@ export declare class Container {
     hasModule(type: any): boolean;
     getModule(type: any): Module | undefined;
     addModule(type: any, module: Module): void;
-    addController(moduleType: any, type: any): void;
 }

package/lib/makes/Container.js

@@ -4,6 +4,15 @@ exports.Container = void 0;
 class Container {
     constructor() {
         this.modules = new Map();
+        // public addController(moduleType: any, type: any): void {
+        //     const module = this.getModule(moduleType);
+        //
+        //     if(!module) {
+        //         return;
+        //     }
+        //
+        //     module.addController(type);
+        // }
     }
     hasModule(type) {
         return this.modules.has(type);
@@ -14,12 +23,5 @@ class Container {
     addModule(type, module) {
         this.modules.set(type, module);
     }
-    addController(moduleType, type) {
-        const module = this.getModule(moduleType);
-        if (!module) {
-            return;
-        }
-        module.addController(type);
-    }
 }
 exports.Container = Container;

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

@@ -12,9 +12,8 @@ export declare class Factory {
     scanModuleDependencies(module: Module): Promise<void>;
     scanDynamicModules(): Promise<void>;
     scanRoutes(): Promise<void>;
-    log(...args: any[]): void;
     init(): Promise<void>;
-    run(args: string[]): Promise<any>;
+    run(args: string[]): Promise<string>;
     getContainer(): Container;
     static create(module: any): Promise<ApplicationContext>;
 }

package/lib/makes/Factory.js

@@ -58,8 +58,10 @@ class Factory {
     scanModuleDependencies(module) {
         return __awaiter(this, void 0, void 0, function* () {
             const providers = Reflect.getMetadata(env_1.MODULE_METADATA.PROVIDERS, module.type) || [];
+            // Logger.info(module.type.name, providers);
             module.addProvider(cli_1.Cli, this.cli);
             providers.forEach((providerType) => {
+                // Logger.info(" ->", (providerType as any).name);
                 module.addProvider(providerType);
             });
             const controllers = Reflect.getMetadata(env_1.MODULE_METADATA.CONTROLLERS, module.type) || [];
@@ -115,6 +117,9 @@ class Factory {
                             });
                             const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, type, name) || [];
                             const command = this.cli.command(commandName);
+                            command.help({
+                                description: "Des"
+                            });
                             for (const argMeta of argsMeta) {
                                 if (argMeta.type === "option") {
                                     command.option(argMeta.name, argMeta.params);
@@ -136,11 +141,15 @@ class Factory {
                     for (const controllerCommand of controllerCommands) {
                         const { command: commandName, method, argsMeta } = controllerCommand;
                         this.cli.command(commandName)
-                            .action((options, ...params) => {
+                            .action((input) => {
                             const args = [];
+                            const params = Object.values(input.arguments());
                             argsMeta.forEach((argMeta) => {
-                                if (argMeta.type === "option") {
-                                    args[argMeta.index] = options[argMeta.name];
+                                if (argMeta.type === "param") {
+                                    args[argMeta.index] = input.argument(argMeta.name);
+                                }
+                                else if (argMeta.type === "option") {
+                                    args[argMeta.index] = input.option(argMeta.name);
                                 }
                             });
                             return controller.instance[method](...args, ...params);
@@ -166,15 +175,6 @@ class Factory {
             }
         });
     }
-    log(...args) {
-        for (const [, module] of this.container.modules) {
-            module.providers.forEach((provider) => {
-                if (provider.instance.info) {
-                    provider.instance.info(...args);
-                }
-            });
-        }
-    }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             for (const [, module] of this.container.modules) {

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/InstanceWrapper.d.ts

@@ -1,10 +1,10 @@
+import "reflect-metadata";
 import { Module } from "./Module";
 export declare class InstanceWrapper {
     private readonly module;
-    private readonly token;
     private readonly provider;
     private _instance?;
-    constructor(module: Module, token: any, provider: any, _instance?: any);
+    constructor(module: Module, provider: any, _instance?: any);
     get instance(): any;
     set instance(instance: any);
 }

package/lib/makes/InstanceWrapper.js

@@ -1,18 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceWrapper = void 0;
+require("reflect-metadata");
 const env_1 = require("../env");
 class InstanceWrapper {
-    constructor(module, token, provider, _instance) {
+    constructor(module, provider, _instance) {
         this.module = module;
-        this.token = token;
         this.provider = provider;
         this._instance = _instance;
     }
     get instance() {
-        if (!this.provider) {
-            return null;
-        }
         if (!this._instance) {
             const types = [
                 ...Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.provider) || []

package/lib/makes/Logger.d.ts

@@ -1,4 +1,4 @@
-import { LogService } from "../services/LogService";
+import { LogService } from "../services";
 export declare class Logger {
     static install(ls: LogService): void;
     static log(...data: any[]): void;

package/lib/makes/Module.js

@@ -34,19 +34,24 @@ class Module {
     }
     addProvider(provider, instance) {
         if ("provide" in provider && "useValue" in provider) {
-            const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider.provide, provider.provide, provider.useValue);
+            const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider.provide, provider.useValue);
+            this.providers.set(provider.provide, wrapper);
+            return;
+        }
+        if ("provide" in provider && "useClass" in provider) {
+            const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider.useClass);
             this.providers.set(provider.provide, wrapper);
             return;
         }
         const token = Reflect.getMetadata("INJECT_TOKEN", provider) || provider;
-        const wrapper = new InstanceWrapper_1.InstanceWrapper(this, token, provider, instance);
+        const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider, instance);
         this.providers.set(token, wrapper);
     }
     addInjection() {
         //
     }
     addController(type) {
-        this.controllers.set(type, new InstanceWrapper_1.InstanceWrapper(this, type, type));
+        this.controllers.set(type, new InstanceWrapper_1.InstanceWrapper(this, type));
         for (const name of Object.getOwnPropertyNames(type.prototype)) {
             const descriptor = Object.getOwnPropertyDescriptor(type.prototype, name);
             if (!descriptor) {

package/lib/makes/Preset.d.ts

@@ -1,6 +1,3 @@
-import { DI } from "./DI";
-import { PresetServiceSearchOptions as SearchOptions } from "../services/PresetService";
-import { EnvConfig } from "../types";
 type TextOption = {
     type: "string" | "number" | "int";
     message?: string;
@@ -23,7 +20,7 @@ type SelectOption = {
     default?: string;
 };
 type AnyOption = TextOption | ConfirmOption | SelectOption;
-declare class Preset {
+export declare abstract class Preset {
     id: string;
     name: string;
     version: string;
@@ -36,11 +33,7 @@ declare class Preset {
     };
     volumes?: string[];
     volumeOptions?: string[];
-    constructor(data: any);
-    save(): Promise<void>;
-    getImageName(buildArgs?: EnvConfig): string;
-    static install(di: DI): void;
-    static search(options: SearchOptions): Promise<any[]>;
-    static searchOne(options: SearchOptions): Promise<any>;
+    protected constructor(data: any);
+    abstract save(): Promise<void>;
 }
-export { Preset };
+export {};

package/lib/makes/Preset.js

@@ -1,17 +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.Preset = void 0;
-const PresetService_1 = require("../services/PresetService");
-let _di;
 class Preset {
     constructor(data) {
         this.id = data.id;
@@ -23,22 +12,5 @@ class Preset {
         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/makes/Project.d.ts

@@ -1,4 +1,5 @@
 import { PickProperties, EnvConfig } from "../types";
+export type ProjectProperties = Omit<PickProperties<Project>, "containerName">;
 export declare abstract class Project {
     id: string;
     name: string;
@@ -13,7 +14,7 @@ export declare abstract 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;
@@ -28,6 +29,7 @@ export declare abstract class Project {
     volumeMount(...volumes: string[]): void;
     volumeUnmount(...volumes: string[]): void;
     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

@@ -106,6 +106,23 @@ class Project {
             return !volumes.includes(mounted);
         });
     }
+    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;
 exports.PROJECT_TYPE_DOCKERFILE = "dockerfile";

package/lib/makes/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./Config";
 export * from "./Container";
-export * from "./DI";
+export * from "./FileSystem";
 export * from "./FS";
 export * from "./FSManager";
 export * from "./Logger";

package/lib/makes/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.9",
+    "version": "1.0.11",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of wocker",
     "license": "MIT",
@@ -19,19 +19,24 @@
     },
     "scripts": {
         "prepare": "npm run build",
-        "watch": "tsc -w",
-        "build": "tsc",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "build": "tsc --project tsconfig.build.json",
+        "watch": "tsc -w --project tsconfig.build.json",
+        "watch:test": "jest --colors --watchAll --coverage",
+        "test": "jest --colors"
     },
     "dependencies": {
-        "@kearisp/cli": "^1.0.7",
+        "@kearisp/cli": "^2.0.4",
         "fs": "^0.0.1-security",
         "path": "^0.12.7",
         "reflect-metadata": "^0.2.1"
     },
     "devDependencies": {
         "@types/dockerode": "^3.3.23",
+        "@types/jest": "^29.5.12",
         "@types/node": "^20.11.7",
-        "typescript": "^5.4.4"
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.2",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.4.5"
     }
 }

package/lib/makes/DI.d.ts

@@ -1,7 +0,0 @@
-import "reflect-metadata";
-declare class DI {
-    private services;
-    resolveService<T>(key: any): T;
-    registerService(key: any, service: any): void;
-}
-export { DI };

package/lib/makes/DI.js

@@ -1,27 +0,0 @@
-"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);
-            if (types && types.length > 0) {
-                types.forEach((type) => {
-                    this.resolveService(type);
-                });
-            }
-            res = new key(this);
-            this.services.set(key, res);
-        }
-        return res;
-    }
-    registerService(key, service) {
-        this.services.set(key, service);
-    }
-}
-exports.DI = DI;