@wocker/core 1.0.4 → 1.0.6

package/README.md

@@ -1 +1,29 @@
 # @wocker/core
+
+###### Docker workspace for web projects
+
+## Installation
+
+**Note:** It is recommended to install Wocker globally to ensure accessibility from any directory in your terminal.
+
+```shell
+npm i -g @wocker/ws
+```
+
+
+### Completion
+
+Wocker comes with shell completion support to enhance your development workflow. To enable shell completion, run the following command:
+
+```bash
+source <(ws completion script)
+```
+
+This will enable tab completion for `ws` commands, providing a more convenient and efficient way to interact with the tool.
+
+
+## Documentation
+
+Wocker is a powerful tool for managing your web project's Docker workspace. It provides a convenient and efficient way to set up and manage your Docker containers.
+
+For more information and detailed usage, please refer to the [documentation](https://kearisp.github.io/wocker).

package/lib/decorators/Command.d.ts

@@ -0,0 +1 @@
+export declare const Command: (command: string) => MethodDecorator;

package/lib/decorators/Command.js

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

package/lib/decorators/Completion.d.ts

@@ -0,0 +1 @@
+export declare const Completion: (name: string, command?: string) => MethodDecorator;

package/lib/decorators/Completion.js

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

package/lib/decorators/Controller.d.ts

@@ -0,0 +1,5 @@
+type Params = {
+    command?: string;
+};
+export declare const Controller: (params?: Params) => ClassDecorator;
+export {};

package/lib/decorators/Controller.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const Controller = (params) => {
+    const { command } = params || {};
+    return (target) => {
+        if (!command) {
+            return;
+        }
+        Reflect.defineMetadata("IS_CONTROLLER", true, target);
+        // TODO:
+    };
+};
+exports.Controller = Controller;

package/lib/decorators/Inject.d.ts

@@ -1 +1 @@
-export declare const Inject: () => (target: any) => void;
+export declare const Inject: <T = any>(token?: T) => ParameterDecorator;

package/lib/decorators/Inject.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Inject = void 0;
-const Inject = () => {
-    return (target) => {
+const env_1 = require("../env");
+const Inject = (token) => {
+    return (target, propertyKey, parameterIndex) => {
+        Reflect.defineMetadata(env_1.SELF_DECLARED_DEPS_METADATA, [
+            ...Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, target) || [],
+            {
+                token: token,
+                index: parameterIndex
+            }
+        ], target);
     };
 };
 exports.Inject = Inject;

package/lib/decorators/Injectable.d.ts

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

package/lib/decorators/Injectable.js

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Injectable = void 0;
-const Injectable = () => {
-    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);
-            }
-        };
+const env_1 = require("../env");
+const Injectable = (token) => {
+    return (target) => {
+        Reflect.defineMetadata(env_1.INJECTABLE_WATERMARK, true, target);
+        if (token) {
+            Reflect.defineMetadata(env_1.INJECT_TOKEN_METADATA, token, target);
+        }
     };
 };
 exports.Injectable = Injectable;

package/lib/decorators/Module.d.ts

@@ -0,0 +1,15 @@
+import { MODULE_METADATA } from "../env";
+import { Provider } from "../types/Provider";
+import { Type } from "../types/Type";
+type Config = {
+    [MODULE_METADATA.NAME]?: 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 {};

package/lib/decorators/Module.js

@@ -0,0 +1,16 @@
+"use strict";
+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);
+    };
+};
+exports.Module = Module;

package/lib/decorators/Option.d.ts

@@ -0,0 +1,4 @@
+import { Option as O } from "@kearisp/cli";
+type Params = Omit<O, "name">;
+export declare const Option: (name: string, params?: Partial<Params>) => ParameterDecorator;
+export {};

package/lib/decorators/Option.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Option = void 0;
+const env_1 = require("../env");
+const Option = (name, params) => {
+    return (target, key, index) => {
+        if (!key) {
+            return;
+        }
+        Reflect.defineMetadata(env_1.ARGS_METADATA, [
+            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, key) || [],
+            {
+                type: "option",
+                name,
+                params,
+                index
+            }
+        ], target.constructor, key);
+    };
+};
+exports.Option = Option;

package/lib/decorators/Param.d.ts

@@ -0,0 +1 @@
+export declare const Param: (name: string) => MethodDecorator;

package/lib/decorators/Param.js

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

package/lib/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Command";
+export * from "./Completion";
+export * from "./Controller";
+export * from "./Inject";
+export * from "./Injectable";
+export * from "./Module";
+export * from "./Option";

package/lib/decorators/index.js

@@ -0,0 +1,23 @@
+"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 });
+__exportStar(require("./Command"), exports);
+__exportStar(require("./Completion"), exports);
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./Inject"), exports);
+__exportStar(require("./Injectable"), exports);
+__exportStar(require("./Module"), exports);
+__exportStar(require("./Option"), exports);

package/lib/env.d.ts

@@ -0,0 +1,18 @@
+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 COMPLETION_METADATA = "completion";
+export declare const ARGS_METADATA = "__ARGS__";
+export declare const OPTION_META = "__OPTION_META__";
+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 enum MODULE_METADATA {
+    NAME = "name",
+    IMPORTS = "imports",
+    EXPORTS = "exports",
+    CONTROLLERS = "controllers",
+    PROVIDERS = "providers"
+}

package/lib/env.js

@@ -0,0 +1,22 @@
+"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.IS_MODULE = "IS_MODULE";
+exports.INJECTABLE_WATERMARK = "__injectable__";
+exports.ARGS_META = "__ARGS__";
+exports.COMMAND_METADATA = "command";
+exports.COMPLETION_METADATA = "completion";
+exports.ARGS_METADATA = "__ARGS__";
+exports.OPTION_META = "__OPTION_META__";
+exports.PARAMTYPES_METADATA = "design:paramtypes";
+exports.SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
+exports.INJECT_TOKEN_METADATA = "INJECT_TOKEN";
+exports.PLUGIN_DIR_KEY = "PLUGIN_DIR";
+var MODULE_METADATA;
+(function (MODULE_METADATA) {
+    MODULE_METADATA["NAME"] = "name";
+    MODULE_METADATA["IMPORTS"] = "imports";
+    MODULE_METADATA["EXPORTS"] = "exports";
+    MODULE_METADATA["CONTROLLERS"] = "controllers";
+    MODULE_METADATA["PROVIDERS"] = "providers";
+})(MODULE_METADATA || (exports.MODULE_METADATA = MODULE_METADATA = {}));

package/lib/index.d.ts

@@ -1,18 +1,6 @@
 export { Cli } from "@kearisp/cli";
-export * from "./decorators/Inject";
-export * from "./decorators/Injectable";
-export * from "./makes/Controller";
-export * from "./makes/DI";
-export * from "./makes/FSManager";
-export * from "./makes/Logger";
-export * from "./makes/Plugin";
-export * from "./models/Preset";
-export * from "./models/Project";
-export * from "./services/AppConfigService";
-export * from "./services/AppEventsService";
-export * from "./services/DockerService";
-export * from "./services/LogService";
-export * from "./services/PresetService";
-export * from "./services/ProjectService";
-export * from "./types/AppConfig";
-export * from "./types/EnvConfig";
+export * from "./decorators";
+export * from "./makes";
+export * from "./services";
+export * from "./types";
+export { MODULE_METADATA, PLUGIN_DIR_KEY } from "./env";

package/lib/index.js

@@ -14,23 +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 });
-exports.Cli = void 0;
+exports.PLUGIN_DIR_KEY = exports.MODULE_METADATA = 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/FSManager"), exports);
-__exportStar(require("./makes/Logger"), exports);
-__exportStar(require("./makes/Plugin"), exports);
-__exportStar(require("./models/Preset"), exports);
-__exportStar(require("./models/Project"), exports);
-__exportStar(require("./services/AppConfigService"), exports);
-__exportStar(require("./services/AppEventsService"), exports);
-__exportStar(require("./services/DockerService"), exports);
-__exportStar(require("./services/LogService"), exports);
-__exportStar(require("./services/PresetService"), exports);
-__exportStar(require("./services/ProjectService"), exports);
-__exportStar(require("./types/AppConfig"), exports);
-__exportStar(require("./types/EnvConfig"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./makes"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
+var env_1 = require("./env");
+Object.defineProperty(exports, "MODULE_METADATA", { enumerable: true, get: function () { return env_1.MODULE_METADATA; } });
+Object.defineProperty(exports, "PLUGIN_DIR_KEY", { enumerable: true, get: function () { return env_1.PLUGIN_DIR_KEY; } });

package/lib/makes/Container.d.ts

@@ -0,0 +1,8 @@
+import { Module } from "./Module";
+export declare class Container {
+    modules: Map<any, Module>;
+    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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+class Container {
+    constructor() {
+        this.modules = new Map();
+    }
+    hasModule(type) {
+        return this.modules.has(type);
+    }
+    getModule(type) {
+        return this.modules.get(type);
+    }
+    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

@@ -1,7 +1,19 @@
 /// <reference types="node" />
-import { PathOrFileDescriptor } from "fs";
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Abortable } from "node:events";
+import { PathLike, PathOrFileDescriptor, WriteFileOptions, RmOptions, MakeDirectoryOptions } from "fs";
+type ReadFileOptions = Abortable & {
+    encoding?: BufferEncoding;
+    flag?: string;
+};
 declare class FS {
-    static readJSON(filePath: PathOrFileDescriptor): Promise<any>;
-    static writeJSON(filePath: PathOrFileDescriptor, data: any): Promise<void>;
+    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 rm(path: PathLike, options?: RmOptions): Promise<void>;
 }
 export { FS };

package/lib/makes/FS.js

@@ -1,4 +1,27 @@
 "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) {
@@ -11,10 +34,57 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
 const fs_1 = require("fs");
+const Path = __importStar(require("path"));
 class FS {
-    static readJSON(filePath) {
+    static mkdir(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                (0, fs_1.mkdir)(path, options, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                });
+            });
+        });
+    }
+    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) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(res);
+                });
+            });
+        });
+    }
+    static writeFile(filePath, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const callback = (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                };
+                if (options) {
+                    (0, fs_1.writeFile)(filePath, data, options, callback);
+                }
+                else {
+                    (0, fs_1.writeFile)(filePath, data, callback);
+                }
+            });
+        });
+    }
+    static readJSON(...paths) {
         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) => {
                     if (err) {
                         reject(err);
@@ -26,17 +96,42 @@ class FS {
             return JSON.parse(res.toString());
         });
     }
-    static writeJSON(filePath, data) {
+    static writeJSON(filePath, data, options) {
         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) => {
+                const callback = (err) => {
                     if (err) {
                         reject(err);
                         return;
                     }
                     resolve(undefined);
-                });
+                };
+                if (options) {
+                    (0, fs_1.writeFile)(filePath, json, options, callback);
+                }
+                else {
+                    (0, fs_1.writeFile)(filePath, json, callback);
+                }
+            });
+        });
+    }
+    static rm(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const callback = (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(undefined);
+                };
+                if (options) {
+                    (0, fs_1.rm)(path, options, callback);
+                }
+                else {
+                    (0, fs_1.rm)(path, callback);
+                }
             });
         });
     }

package/lib/makes/FSManager.js

@@ -43,8 +43,8 @@ class FSManager {
     path(...parts) {
         return Path.join(this.destination, ...parts);
     }
-    mkdir(path, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    mkdir(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
             const fullPath = Path.join(this.destination, path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.mkdir)(fullPath, options, (err) => {
@@ -120,8 +120,8 @@ class FSManager {
             });
         });
     }
-    rm(path, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    rm(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
             const filePath = Path.join(this.destination, path);
             return new Promise((resolve, reject) => {
                 fs_1.default.rm(filePath, options, (err) => {

package/lib/makes/Factory.d.ts

@@ -0,0 +1,17 @@
+import { Module } from "./Module";
+export declare class Factory {
+    private readonly cli;
+    private readonly container;
+    private routes;
+    private constructor();
+    scan(moduleType: any): Promise<void>;
+    scanModules(moduleType: any, parent?: Module): Promise<Module | undefined>;
+    scanDependencies(): Promise<void>;
+    scanModuleDependencies(module: Module): Promise<void>;
+    scanDynamicModules(): Promise<void>;
+    scanRoutes(): Promise<void>;
+    log(...args: any[]): void;
+    init(): Promise<void>;
+    run(args: string[]): Promise<any>;
+    static create(module: any): Promise<Factory>;
+}