@wocker/core 1.0.25-beta.1 → 1.0.26-beta.0

package/README.md

@@ -4,7 +4,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@wocker/core.svg)](https://www.npmjs.com/package/@wocker/core)
 [![Publish](https://github.com/kearisp/wocker-core/actions/workflows/publish-latest.yml/badge.svg?event=release)](https://github.com/kearisp/wocker-core/actions/workflows/publish-latest.yml)
-[![License](https://img.shields.io/npm/l/@wocker/core)](https://github.com/kearisp/wocker-core/blob/main/LICENSE)
+[![License](https://img.shields.io/npm/l/@wocker/core)](https://github.com/kearisp/wocker-core/blob/master/LICENSE)
 
 [![npm total downloads](https://img.shields.io/npm/dt/@wocker/core.svg)](https://www.npmjs.com/package/@wocker/core)
 [![bundle size](https://img.shields.io/bundlephobia/minzip/@wocker/core)](https://bundlephobia.com/package/@wocker/core)

package/lib/core/ApplicationContext.d.ts

@@ -1,5 +1,5 @@
+import { Type } from "../types";
 import { Container } from "./Container";
-import { Type } from "../types/Type";
 export declare class ApplicationContext {
     protected readonly module: any;
     protected readonly container: Container;

package/lib/core/AsyncStorage.d.ts

@@ -1,3 +1,11 @@
-import { AsyncLocalStorage } from "node:async_hooks";
 import type { Container } from "./Container";
-export declare const AsyncStorage: AsyncLocalStorage<Container>;
+export declare const AsyncStorage: {
+    getContainer(): Container;
+    disable(): void;
+    getStore(): Container | undefined;
+    readonly name: string;
+    run<R>(store: Container, callback: () => R): R;
+    run<R, TArgs extends any[]>(store: Container, callback: (...args: TArgs) => R, ...args: TArgs): R;
+    exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
+    enterWith(store: Container): void;
+};

package/lib/core/AsyncStorage.js

@@ -2,4 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncStorage = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
-exports.AsyncStorage = new node_async_hooks_1.AsyncLocalStorage();
+exports.AsyncStorage = new class extends node_async_hooks_1.AsyncLocalStorage {
+    getContainer() {
+        const container = exports.AsyncStorage.getStore();
+        if (!container) {
+            throw new Error("Couldn't find container");
+        }
+        return container;
+    }
+}();

package/lib/core/Container.d.ts

@@ -1,9 +1,9 @@
 import { InstanceWrapper } from "./InstanceWrapper";
 import { ModuleWrapper } from "./ModuleWrapper";
-import { InjectionToken, ProviderType } from "../types";
-import { Type } from "../types/Type";
+import { Type, InjectionToken, ProviderType } from "../types";
 export declare class Container {
     readonly modules: Map<Type, ModuleWrapper>;
+    readonly moduleExportIndex: Map<InjectionToken, Set<ModuleWrapper>>;
     readonly globalProviders: Map<InjectionToken, InstanceWrapper>;
     constructor();
     addModule<TInput = any>(type: Type<TInput>, module: ModuleWrapper): void;
@@ -11,5 +11,6 @@ export declare class Container {
     getModule<TInput = any>(type: Type<TInput>): ModuleWrapper<TInput>;
     addProvider(type: InjectionToken, wrapper: InstanceWrapper): void;
     getProvider(type: InjectionToken): InstanceWrapper | undefined;
+    get<TInput = any, TReturn = TInput>(type: InjectionToken<TInput>): TReturn;
     replace(type: InjectionToken, provider: ProviderType): void;
 }

package/lib/core/Container.js

@@ -8,6 +8,7 @@ const env_1 = require("../env");
 class Container {
     constructor() {
         this.modules = new Map();
+        this.moduleExportIndex = new Map();
         this.globalProviders = new Map();
         const cliWrapper = new InstanceWrapper_1.InstanceWrapper(new ModuleWrapper_1.ModuleWrapper(this, null), cli_1.Cli);
         this.globalProviders.set(cli_1.Cli, cliWrapper);
@@ -37,6 +38,13 @@ class Container {
             : type;
         return this.globalProviders.get(token);
     }
+    get(type) {
+        const wrapper = this.getProvider(type);
+        if (!wrapper) {
+            throw new Error("Couldn't find provider wrapper");
+        }
+        return wrapper.instance;
+    }
     replace(type, provider) {
         const token = typeof type !== "string"
             ? Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, type) || type

package/lib/core/InstanceWrapper.d.ts

@@ -1,6 +1,5 @@
 import { ModuleWrapper } from "./ModuleWrapper";
-import { ProviderType, InjectionToken } from "../types";
-import { Type } from "../types/Type";
+import { Type, ProviderType, InjectionToken } from "../types";
 export declare class InstanceWrapper<TInput = any> {
     protected readonly module: ModuleWrapper;
     protected readonly provider: ProviderType<TInput>;

package/lib/core/InstanceWrapper.js

@@ -37,15 +37,15 @@ class InstanceWrapper {
             if (!this._type) {
                 throw new Error("Type not defined");
             }
-            const types = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this._type) || [];
-            const selfTypes = Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, this._type) || [];
+            const types = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this._type) || [], selfTypes = Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, this._type) || [], argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, this._type) || [];
             if (selfTypes.length > 0) {
                 selfTypes.forEach(({ index, token }) => {
                     types[index] = token;
                 });
             }
-            const params = types.map((type) => {
-                return this.module.get(type);
+            const params = types.map((type, index) => {
+                const optional = (argsMeta[index] || {}).optional || false;
+                return this.module.get(type, optional);
             });
             this._instance = new this._type(...params);
         }

package/lib/core/ModuleWrapper.d.ts

@@ -1,20 +1,24 @@
-import { InjectionToken, ProviderType } from "../types";
-import { Type } from "../types/Type";
+import { InjectionToken, ModuleMetadata, ProviderType, Type } from "../types";
 import { Container } from "./Container";
 import { InstanceWrapper } from "./InstanceWrapper";
 import { ControllerWrapper } from "./ControllerWrapper";
 export declare class ModuleWrapper<TInput = any> {
     readonly container: Container;
     readonly type: TInput;
-    imports: Map<any, InstanceWrapper>;
+    global: boolean;
+    imports: Set<ModuleWrapper>;
     controllers: Map<any, ControllerWrapper>;
     providers: Map<any, InstanceWrapper>;
     exports: Set<any>;
+    factory?: (...args: any[]) => ModuleMetadata | Promise<ModuleMetadata>;
+    factoryInject?: any[];
     constructor(container: Container, type: TInput);
-    get<TInput = any, TResult = TInput>(type: Type<TInput> | Function | string | symbol): TResult;
+    get<TInput = any, TResult = TInput>(type: InjectionToken<TInput>): TResult;
+    get<TInput = any, TResult = TInput, O extends boolean = boolean>(type: InjectionToken<TInput>, optional: O): O extends true ? TResult | undefined : TResult;
     getWrapper(type: InjectionToken): InstanceWrapper | undefined;
     addProvider(provider: ProviderType): void;
-    addController(type: any): void;
-    addExport(type: any): void;
+    addController(type: Type): void;
+    addImport(module: ModuleWrapper): void;
+    addExport(type: InjectionToken | Type): void;
     replace(token: InjectionToken, provider: ProviderType): void;
 }

package/lib/core/ModuleWrapper.js

@@ -8,14 +8,18 @@ class ModuleWrapper {
     constructor(container, type) {
         this.container = container;
         this.type = type;
-        this.imports = new Map();
+        this.global = false;
+        this.imports = new Set();
         this.controllers = new Map();
         this.providers = new Map();
         this.exports = new Set();
     }
-    get(type) {
+    get(type, optional) {
         const wrapper = this.getWrapper(type);
         if (!wrapper) {
+            if (optional) {
+                return undefined;
+            }
             if (typeof type === "function") {
                 throw new Error(`Provider "${type.prototype.constructor.name}" not found`);
             }
@@ -32,6 +36,15 @@ class ModuleWrapper {
             : type;
         const wrapper = this.providers.get(token);
         if (!wrapper) {
+            for (const im of this.imports) {
+                if (!im.exports.has(token)) {
+                    continue;
+                }
+                const wrapper = im.getWrapper(token);
+                if (wrapper) {
+                    return wrapper;
+                }
+            }
             return this.container.globalProviders.get(token);
         }
         return wrapper;
@@ -44,11 +57,17 @@ class ModuleWrapper {
         const controllerWrapper = new ControllerWrapper_1.ControllerWrapper(this, type);
         this.controllers.set(type, controllerWrapper);
     }
+    addImport(module) {
+        this.imports.add(module);
+    }
     addExport(type) {
         const token = typeof type !== "string"
             ? Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, type) || type
             : type;
         this.exports.add(token);
+        const indexes = this.container.moduleExportIndex.get(token) || new Set();
+        indexes.add(this);
+        this.container.moduleExportIndex.set(token, indexes);
     }
     replace(token, provider) {
         const wrapper = this.getWrapper(token);

package/lib/core/Route.d.ts

@@ -1,5 +1,4 @@
-import { ArgMeta } from "../types/ArgMeta";
-import { Type } from "../types/Type";
+import { Type } from "../types";
 export declare class Route {
     readonly type: Type;
     readonly method: string;
@@ -9,7 +8,6 @@ export declare class Route {
         name: string;
         params: any;
     }[];
-    argsMeta: ArgMeta[];
     designTypes: any[];
     commandNames: string[];
     completions: {

package/lib/core/Route.js

@@ -7,7 +7,6 @@ class Route {
         this.type = type;
         this.method = method;
         this.args = [];
-        this.argsMeta = [];
         this.designTypes = [];
         this.commandNames = [];
         this.completions = [];
@@ -18,17 +17,16 @@ class Route {
         this.description = Reflect.getMetadata(env_1.DESCRIPTION_METADATA, descriptor.value) || "";
         this.commandNames = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value) || [];
         this.completions = Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || [];
-        const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, this.type, this.method) || [], argsAliases = Reflect.getMetadata(env_1.ALIAS_METADATA, this.type, this.method) || {}, argsDescription = Reflect.getMetadata(env_1.DESCRIPTION_METADATA, this.type, method) || {}, designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type.prototype, this.method) || [];
-        this.argsMeta = argsMeta;
-        this.designTypes = designTypes;
-        for (let i = 0; i < argsMeta.length; i++) {
-            const argMeta = argsMeta[i];
+        this.designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type.prototype, this.method) || [];
+        const argsMetadata = Reflect.getMetadata(env_1.ARGS_METADATA, this.type, this.method) || [], argsAliases = Reflect.getMetadata(env_1.ALIAS_METADATA, this.type, this.method) || {};
+        for (const index in argsMetadata) {
+            const argMeta = argsMetadata[index];
             if (argMeta.type === "param") {
                 this.args[argMeta.index] = {
                     type: argMeta.type,
                     name: argMeta.name,
                     params: {
-                        description: argsDescription[argMeta.index] || ""
+                        description: argMeta.description,
                     }
                 };
             }
@@ -37,7 +35,7 @@ class Route {
                 this.args[argMeta.index] = {
                     type: argMeta.type,
                     name: argMeta.name,
-                    params: Object.assign(Object.assign({}, argMeta.params), { type: this.getArgType(argMeta.index) || type, alias: argsAliases[argMeta.index] || alias, description: argsDescription[argMeta.index] || description })
+                    params: Object.assign(Object.assign({}, argMeta.params), { type: this.getArgType(argMeta.index) || type, alias: argsAliases[argMeta.index] || alias, description: argMeta.description || description })
                 };
             }
         }

package/lib/core/Scanner.d.ts

@@ -1,18 +1,21 @@
 import "reflect-metadata";
 import { Cli } from "@kearisp/cli";
+import { Type, DynamicModule, ProviderType } from "../types";
 import { Container } from "./Container";
 import { ControllerWrapper } from "./ControllerWrapper";
 import { ModuleWrapper } from "./ModuleWrapper";
 export declare class Scanner {
     readonly container: Container;
-    constructor();
-    scan(moduleType: any): Promise<void>;
-    protected scanModule(moduleType: any): ModuleWrapper;
-    protected scanControllers(module: ModuleWrapper): void;
-    protected scanProviders(module: ModuleWrapper): void;
-    protected scanImports(module: ModuleWrapper): void;
-    protected scanExports(module: ModuleWrapper): void;
+    constructor(container?: Container);
+    scan(moduleDefinition: Type | DynamicModule): Promise<void>;
+    protected getMetadata(moduleDefinition: Type | DynamicModule): DynamicModule;
+    protected scanModule(moduleDefinition: Type | DynamicModule): ModuleWrapper;
+    protected scanControllers(module: ModuleWrapper, controllers: Type[]): void;
+    protected scanProviders(module: ModuleWrapper, providers: ProviderType[]): void;
+    protected scanImports(module: ModuleWrapper, imports: any[]): void;
+    protected scanExports(module: ModuleWrapper, exports: any[]): void;
     protected scanRoutes(): void;
     protected scanControllerRoutes(cli: Cli, wrapper: ControllerWrapper): void;
     protected scanDynamicModules(): Promise<void>;
+    isDynamicModule(moduleDefinition: Type | DynamicModule): moduleDefinition is DynamicModule;
 }

package/lib/core/Scanner.js

@@ -16,61 +16,93 @@ const Container_1 = require("./Container");
 const ModuleWrapper_1 = require("./ModuleWrapper");
 const env_1 = require("../env");
 class Scanner {
-    constructor() {
-        this.container = new Container_1.Container();
+    constructor(container) {
+        this.container = container || new Container_1.Container();
     }
-    scan(moduleType) {
+    scan(moduleDefinition) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.scanModule(moduleType);
+            this.scanModule(moduleDefinition);
             yield this.scanDynamicModules();
             this.scanRoutes();
         });
     }
-    scanModule(moduleType) {
+    getMetadata(moduleDefinition) {
+        if (this.isDynamicModule(moduleDefinition)) {
+            const module = moduleDefinition.module;
+            return {
+                module: moduleDefinition.module,
+                global: moduleDefinition.global || Reflect.getMetadata(env_1.IS_GLOBAL_METADATA, module),
+                inject: moduleDefinition.inject,
+                useFactory: moduleDefinition.useFactory,
+                imports: [
+                    ...Reflect.getMetadata(env_1.MODULE_METADATA.IMPORTS, module) || [],
+                    ...moduleDefinition.imports || []
+                ],
+                controllers: [
+                    ...Reflect.getMetadata(env_1.MODULE_METADATA.CONTROLLERS, module) || [],
+                    ...moduleDefinition.controllers || []
+                ],
+                providers: [
+                    ...Reflect.getMetadata(env_1.MODULE_METADATA.PROVIDERS, module) || [],
+                    ...moduleDefinition.providers || []
+                ],
+                exports: [
+                    ...Reflect.getMetadata(env_1.MODULE_METADATA.EXPORTS, module) || [],
+                    ...moduleDefinition.exports || []
+                ]
+            };
+        }
+        return {
+            module: moduleDefinition,
+            global: Reflect.getMetadata(env_1.IS_GLOBAL_METADATA, moduleDefinition) || false,
+            imports: Reflect.getMetadata(env_1.MODULE_METADATA.IMPORTS, moduleDefinition) || [],
+            controllers: Reflect.getMetadata(env_1.MODULE_METADATA.CONTROLLERS, moduleDefinition) || [],
+            providers: Reflect.getMetadata(env_1.MODULE_METADATA.PROVIDERS, moduleDefinition) || [],
+            exports: Reflect.getMetadata(env_1.MODULE_METADATA.EXPORTS, moduleDefinition) || []
+        };
+    }
+    scanModule(moduleDefinition) {
+        const { module: moduleType, global = false, inject, useFactory, imports = [], controllers = [], providers = [], exports = [] } = this.getMetadata(moduleDefinition);
         let module = this.container.hasModule(moduleType)
             ? this.container.getModule(moduleType)
             : null;
         if (!module) {
             module = new ModuleWrapper_1.ModuleWrapper(this.container, moduleType);
+            module.global = global;
+            if (useFactory) {
+                module.factory = useFactory;
+                module.factoryInject = inject;
+            }
             this.container.addModule(moduleType, module);
-            this.scanImports(module);
-            this.scanControllers(module);
-            this.scanProviders(module);
-            this.scanExports(module);
+            this.scanImports(module, imports);
+            this.scanControllers(module, controllers);
+            this.scanProviders(module, providers);
+            this.scanExports(module, exports);
         }
         return module;
     }
-    scanControllers(module) {
-        const controllers = Reflect.getMetadata(env_1.MODULE_METADATA.CONTROLLERS, module.type) || [];
+    scanControllers(module, controllers) {
+        // const controllers = Reflect.getMetadata(MODULE_METADATA.CONTROLLERS, module.type) || [];
         controllers.forEach((controller) => {
             module.addController(controller);
         });
     }
-    scanProviders(module) {
-        const providers = Reflect.getMetadata(env_1.MODULE_METADATA.PROVIDERS, module.type) || [];
+    scanProviders(module, providers) {
+        // const providers: ProviderType[] = Reflect.getMetadata(MODULE_METADATA.PROVIDERS, module.type) || [];
         providers.forEach((provider) => {
             module.addProvider(provider);
         });
     }
-    scanImports(module) {
-        const imports = Reflect.getMetadata(env_1.MODULE_METADATA.IMPORTS, module.type) || [];
+    scanImports(module, imports) {
         imports.forEach((importType) => {
             const subModule = this.scanModule(importType);
-            subModule.exports.forEach((type) => {
-                const provider = subModule.providers.get(type);
-                if (!provider) {
-                    return;
-                }
-                module.providers.set(type, provider);
-            });
+            module.addImport(subModule);
         });
     }
-    scanExports(module) {
-        const exports = Reflect.getMetadata(env_1.MODULE_METADATA.EXPORTS, module.type) || [];
-        const isGlobal = Reflect.getMetadata(env_1.IS_GLOBAL_METADATA, module.type) || false;
+    scanExports(module, exports) {
         exports.forEach((type) => {
             module.addExport(type);
-            if (isGlobal) {
+            if (module.global) {
                 const wrapper = module.getWrapper(type);
                 if (wrapper) {
                     this.container.addProvider(type, wrapper);
@@ -123,25 +155,25 @@ class Scanner {
     scanDynamicModules() {
         return __awaiter(this, void 0, void 0, function* () {
             const promises = ([...this.container.modules.keys()]).map((type) => __awaiter(this, void 0, void 0, function* () {
-                if (!type.prototype.load) {
+                const wrapper = this.container.modules.get(type);
+                if (!wrapper) {
                     return;
                 }
-                const parentModule = this.container.modules.get(type);
-                const { [env_1.MODULE_METADATA.IMPORTS]: imports = [] } = yield type.prototype.load(this.container);
-                for (const subModuleType of imports) {
-                    const module = this.scanModule(subModuleType);
-                    module.exports.forEach((type) => {
-                        const provider = module.getWrapper(type);
-                        if (!provider) {
-                            return;
-                        }
-                        // @ts-ignore
-                        parentModule.providers.set(type, provider);
-                    });
+                if (wrapper.factory) {
+                    const { imports = [], controllers = [], providers = [], exports = [] } = yield wrapper.factory(...(wrapper.factoryInject || []).map((token) => {
+                        return wrapper.get(token);
+                    }));
+                    this.scanImports(wrapper, imports);
+                    this.scanControllers(wrapper, controllers);
+                    this.scanProviders(wrapper, providers);
+                    this.scanExports(wrapper, exports);
                 }
             }));
             yield Promise.all(promises);
         });
     }
+    isDynamicModule(moduleDefinition) {
+        return moduleDefinition && !!moduleDefinition.module;
+    }
 }
 exports.Scanner = Scanner;

package/lib/decorators/Description.js

@@ -1,4 +1,15 @@
 "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.Description = void 0;
 require("reflect-metadata");
@@ -24,6 +35,8 @@ const Description = (description) => {
             return;
         }
         // Parameter
+        const _a = Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, propertyKey) || {}, _b = descriptorOrIndex, options = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        Reflect.defineMetadata(env_1.ARGS_METADATA, Object.assign(Object.assign({}, rest), { [descriptorOrIndex]: Object.assign(Object.assign({}, options || {}), { description }) }), target.constructor, propertyKey);
         Reflect.defineMetadata(env_1.DESCRIPTION_METADATA, Object.assign(Object.assign({}, Reflect.getMetadata(env_1.DESCRIPTION_METADATA, target.constructor, propertyKey) || {}), { [descriptorOrIndex]: description }), target.constructor, propertyKey);
     };
 };

package/lib/decorators/Module.d.ts

@@ -1,9 +1,2 @@
-import { MODULE_METADATA } from "../env";
-import { ProviderType } from "../types/ProviderType";
-export type ModuleMetadata = {
-    [MODULE_METADATA.CONTROLLERS]?: any[];
-    [MODULE_METADATA.PROVIDERS]?: ProviderType[];
-    [MODULE_METADATA.IMPORTS]?: any[];
-    [MODULE_METADATA.EXPORTS]?: any[];
-};
+import { ModuleMetadata } from "../types";
 export declare const Module: (config: ModuleMetadata) => ClassDecorator;

package/lib/decorators/Option.js

@@ -1,22 +1,35 @@
 "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.Option = void 0;
 require("reflect-metadata");
 const env_1 = require("../env");
 const Option = (name, aliasOrParams) => {
-    return (target, key, index) => {
-        if (!key) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
             return;
         }
-        Reflect.defineMetadata(env_1.ARGS_METADATA, [
+        const _a = Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, propertyKey) || {}, _b = parameterIndex, options = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        Reflect.defineMetadata(env_1.ARGS_METADATA, Object.assign(Object.assign({}, rest), { [parameterIndex]: Object.assign(Object.assign({}, options || {}), { type: "option", name, params: typeof aliasOrParams === "string" ? { alias: aliasOrParams } : aliasOrParams, index: parameterIndex }) }), target.constructor, propertyKey);
+        Reflect.defineMetadata(env_1.ARGS_METADATA_OLD, [
             {
                 type: "option",
                 name,
                 params: typeof aliasOrParams === "string" ? { alias: aliasOrParams } : aliasOrParams,
-                index
+                index: parameterIndex
             },
-            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, key) || []
-        ], target.constructor, key);
+            ...Reflect.getMetadata(env_1.ARGS_METADATA_OLD, target.constructor, propertyKey) || []
+        ], target.constructor, propertyKey);
     };
 };
 exports.Option = Option;

package/lib/decorators/Optional.d.ts

@@ -0,0 +1 @@
+export declare const Optional: () => ParameterDecorator;

package/lib/decorators/Optional.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = void 0;
+const env_1 = require("../env");
+const Optional = () => {
+    return (target, propertyKey, parameterIndex) => {
+        const metadata = propertyKey
+            ? Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, propertyKey) || {}
+            : Reflect.getMetadata(env_1.ARGS_METADATA, target) || {};
+        if (!metadata[parameterIndex]) {
+            metadata[parameterIndex] = {};
+        }
+        metadata[parameterIndex] = Object.assign(Object.assign({}, metadata[parameterIndex]), { optional: true });
+        if (propertyKey) {
+            Reflect.defineMetadata(env_1.ARGS_METADATA, metadata, target.constructor, propertyKey);
+        }
+        else {
+            Reflect.defineMetadata(env_1.ARGS_METADATA, metadata, target);
+        }
+    };
+};
+exports.Optional = Optional;

package/lib/decorators/Param.js

@@ -1,4 +1,15 @@
 "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.Param = void 0;
 const env_1 = require("../env");
@@ -7,8 +18,10 @@ const Param = (name) => {
         if (!propertyKey) {
             return;
         }
-        Reflect.defineMetadata(env_1.ARGS_METADATA, [
-            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, propertyKey) || [],
+        const _a = Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, propertyKey) || {}, _b = parameterIndex, options = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        Reflect.defineMetadata(env_1.ARGS_METADATA, Object.assign(Object.assign({}, rest), { [parameterIndex]: Object.assign(Object.assign({}, options || {}), { type: "param", name, index: parameterIndex }) }), target.constructor, propertyKey);
+        Reflect.defineMetadata(env_1.ARGS_METADATA_OLD, [
+            ...Reflect.getMetadata(env_1.ARGS_METADATA_OLD, target.constructor, propertyKey) || [],
             {
                 type: "param",
                 name,

package/lib/decorators/Plugin.d.ts

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

package/lib/decorators/Plugin.js

@@ -12,13 +12,15 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
+const Global_1 = require("./Global");
 const Module_1 = require("./Module");
 const env_1 = require("../env");
 const Plugin = (config) => {
-    const { name } = config, rest = __rest(config, ["name"]);
+    const _a = config, _b = env_1.PLUGIN_NAME_METADATA, name = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
     return (target) => {
         Reflect.defineMetadata("isPlugin", true, target);
         Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
+        (0, Global_1.Global)()(target);
         (0, Module_1.Module)(rest)(target);
     };
 };

package/lib/decorators/index.d.ts

@@ -7,10 +7,6 @@ export * from "./Inject";
 export * from "./Injectable";
 export * from "./Module";
 export * from "./Option";
+export * from "./Optional";
 export * from "./Param";
 export * from "./Plugin";
-export type { 
-/**
- * @deprecated
- */
-ModuleMetadata as ModuleConfig } from "./Module";

package/lib/decorators/index.js

@@ -23,5 +23,6 @@ __exportStar(require("./Inject"), exports);
 __exportStar(require("./Injectable"), exports);
 __exportStar(require("./Module"), exports);
 __exportStar(require("./Option"), exports);
+__exportStar(require("./Optional"), exports);
 __exportStar(require("./Param"), exports);
 __exportStar(require("./Plugin"), exports);