@midwayjs/core 3.8.0 → 3.10.0

package/dist/interface.d.ts

@@ -1,11 +1,306 @@
 /// <reference types="node" />
-import type { ILogger, LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
+import type { LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import type { AsyncContextManager } from './common/asyncContextManager';
-import type { IManagedInstance, IMethodAspect, ObjectIdentifier } from './decorator';
-import { FrameworkType, ScopeEnum } from './decorator';
+import type { LoggerFactory } from './common/loggerFactory';
+export type MiddlewareParamArray = Array<string | any>;
+export type ObjectIdentifier = string | Symbol;
+export type GroupModeType = 'one' | 'multi';
+export declare enum ScopeEnum {
+    Singleton = "Singleton",
+    Request = "Request",
+    Prototype = "Prototype"
+}
+export declare enum InjectModeEnum {
+    Identifier = "Identifier",
+    Class = "Class",
+    PropertyName = "PropertyName"
+}
+/**
+ * 内部管理的属性、json、ref等解析实例存储
+ */
+export interface IManagedInstance {
+    type: string;
+    value?: any;
+    args?: any;
+}
+export interface ObjectDefinitionOptions {
+    isAsync?: boolean;
+    initMethod?: string;
+    destroyMethod?: string;
+    scope?: ScopeEnum;
+    constructorArgs?: any[];
+    namespace?: string;
+    srcPath?: string;
+    allowDowngrade?: boolean;
+}
+export interface TagPropsMetadata {
+    key: string | number | symbol;
+    value: any;
+    args?: any;
+}
+export interface TagClsMetadata {
+    id: string;
+    originName: string;
+    uuid: string;
+    name: string;
+}
+export interface ReflectResult {
+    [key: string]: any[];
+}
+export declare enum MSProviderType {
+    DUBBO = "dubbo",
+    GRPC = "gRPC"
+}
+export declare enum MSListenerType {
+    RABBITMQ = "rabbitmq",
+    MQTT = "mqtt",
+    KAFKA = "kafka",
+    REDIS = "redis"
+}
+export declare namespace ConsumerMetadata {
+    interface ConsumerMetadata {
+        type: MSListenerType;
+        metadata: any;
+    }
+}
+/**
+ * grpc decorator metadata format
+ */
+export declare namespace GRPCMetadata {
+    interface ProviderOptions {
+        serviceName?: string;
+        package?: string;
+    }
+    interface ProviderMetadata {
+        type: MSProviderType;
+        metadata: ProviderOptions;
+    }
+}
+export declare namespace FaaSMetadata {
+    export interface ServerlessFunctionOptions {
+        /**
+         * function name
+         */
+        functionName?: string;
+        /**
+         * function description
+         */
+        description?: string;
+        /**
+         * function memory size, unit: M
+         */
+        memorySize?: number;
+        /**
+         * function timeout value, unit: seconds
+         */
+        timeout?: number;
+        /**
+         * function init timeout, just for aliyun
+         */
+        initTimeout?: number;
+        /**
+         * function runtime, nodejs10, nodejs12, nodejs14
+         */
+        runtime?: string;
+        /**
+         * invoke concurrency, just for aliyun
+         */
+        concurrency?: number;
+        /**
+         * function invoke stage, like env, just for tencent
+         */
+        stage?: string;
+        /**
+         * environment variable, key-value
+         */
+        environment?: any;
+        /**
+         * deploy or not
+         */
+        isDeploy?: boolean;
+        /**
+         * function handler name, like 'index.handler'
+         */
+        handlerName?: string;
+    }
+    interface TriggerCommonOptions {
+        /**
+         * function name
+         */
+        functionName?: string;
+        /**
+         * serverless event name
+         */
+        name?: string;
+        /**
+         * function invoke role, just for aliyun
+         */
+        role?: string;
+        /**
+         * function publish version, just for aliyun
+         */
+        version?: string;
+        /**
+         * deploy or not
+         */
+        isDeploy?: boolean;
+        /**
+         * function middleware
+         */
+        middleware?: any[];
+    }
+    export interface EventTriggerOptions extends TriggerCommonOptions {
+    }
+    export interface HTTPTriggerOptions extends TriggerCommonOptions {
+        path: string;
+        method?: 'get' | 'post' | 'delete' | 'put' | 'head' | 'patch' | 'all';
+    }
+    export interface APIGatewayTriggerOptions extends HTTPTriggerOptions {
+    }
+    export interface OSTriggerOptions extends TriggerCommonOptions {
+        bucket: string;
+        events: string | string[];
+        filter?: {
+            prefix: string;
+            suffix: string;
+        };
+    }
+    export interface LogTriggerOptions extends TriggerCommonOptions {
+        source: string;
+        project: string;
+        log: string;
+        retryTime?: number;
+        interval?: number;
+    }
+    export interface TimerTriggerOptions extends TriggerCommonOptions {
+        type: 'cron' | 'every' | 'interval';
+        value: string;
+        payload?: string;
+        enable?: boolean;
+    }
+    export interface MQTriggerOptions extends TriggerCommonOptions {
+        topic: string;
+        tags?: string;
+        region?: string;
+        strategy?: 'BACKOFF_RETRY' | 'EXPONENTIAL_DECAY_RETRY';
+    }
+    export interface HSFTriggerOptions extends TriggerCommonOptions {
+    }
+    export interface MTopTriggerOptions extends TriggerCommonOptions {
+    }
+    export interface SSRTriggerOptions extends HTTPTriggerOptions {
+    }
+    export interface CDNTriggerOptions extends TriggerCommonOptions {
+    }
+    export type EventTriggerUnionOptions = EventTriggerOptions | HTTPTriggerOptions | APIGatewayTriggerOptions | OSTriggerOptions | CDNTriggerOptions | LogTriggerOptions | TimerTriggerOptions | MQTriggerOptions | HSFTriggerOptions | MTopTriggerOptions | SSRTriggerOptions;
+    export interface TriggerMetadata {
+        type: ServerlessTriggerType | string;
+        functionName?: string;
+        handlerName?: string;
+        methodName?: string;
+        metadata: EventTriggerUnionOptions;
+    }
+    export {};
+}
+export declare abstract class FrameworkType {
+    abstract name: string;
+}
+export declare class MidwayFrameworkType extends FrameworkType {
+    name: string;
+    static WEB: MidwayFrameworkType;
+    static WEB_KOA: MidwayFrameworkType;
+    static WEB_EXPRESS: MidwayFrameworkType;
+    static FAAS: MidwayFrameworkType;
+    static MS_GRPC: MidwayFrameworkType;
+    static MS_RABBITMQ: MidwayFrameworkType;
+    static MS_KAFKA: MidwayFrameworkType;
+    static WS_IO: MidwayFrameworkType;
+    static WS: MidwayFrameworkType;
+    static SERVERLESS_APP: MidwayFrameworkType;
+    static CUSTOM: MidwayFrameworkType;
+    static EMPTY: MidwayFrameworkType;
+    static LIGHT: MidwayFrameworkType;
+    static TASK: MidwayFrameworkType;
+    constructor(name: string);
+}
+export declare enum ServerlessTriggerType {
+    EVENT = "event",
+    HTTP = "http",
+    API_GATEWAY = "apigw",
+    OS = "os",
+    CDN = "cdn",
+    LOG = "log",
+    TIMER = "timer",
+    MQ = "mq",
+    KAFKA = "kafka",
+    HSF = "hsf",
+    MTOP = "mtop",
+    SSR = "ssr"
+}
+export interface JoinPoint {
+    methodName: string;
+    target: any;
+    args: any[];
+    proceed?(...args: any[]): any;
+}
+export interface AspectMetadata {
+    aspectTarget: any;
+    match?: string | (() => boolean);
+    priority?: number;
+}
+export interface IMethodAspect {
+    after?(joinPoint: JoinPoint, result: any, error: Error): any;
+    afterReturn?(joinPoint: JoinPoint, result: any): any;
+    afterThrow?(joinPoint: JoinPoint, error: Error): void;
+    before?(joinPoint: JoinPoint): void;
+    around?(joinPoint: JoinPoint): any;
+}
+export interface IModuleStore {
+    listModule(key: string): any;
+    saveModule(key: string, module: any): any;
+    transformModule?(moduleMap: Map<string, Set<any>>): any;
+}
+export interface TSDesignType<OriginType = unknown> {
+    name: string;
+    originDesign: OriginType;
+    isBaseType: boolean;
+}
+export interface TransformOptions<OriginType = unknown> {
+    metaType: TSDesignType<OriginType>;
+    metadata: any;
+    /**
+     * current instance
+     */
+    target: any;
+    /**
+     * the name of method
+     */
+    methodName: string;
+}
+export interface PipeTransform<T = unknown, R = unknown> {
+    transform(value: T, transformOptions: TransformOptions): R;
+}
+export type PipeTransformFunction<T = any, R = any> = (value: T) => R;
+export type PipeUnionTransform<T = any, R = any> = PipeTransform<T, R> | (new (...args: any[]) => PipeTransform<T, R>) | PipeTransformFunction<T, R>;
+export interface MethodDecoratorOptions {
+    impl?: boolean;
+}
+export interface ParamDecoratorOptions {
+    impl?: boolean;
+    throwError?: boolean;
+    pipes?: PipeUnionTransform<any, any>[];
+}
+export interface ILogger {
+    info(msg: any, ...args: any[]): void;
+    debug(msg: any, ...args: any[]): void;
+    error(msg: any, ...args: any[]): void;
+    warn(msg: any, ...args: any[]): void;
+}
 export interface MidwayCoreDefaultConfig {
-    midwayLogger?: ServiceFactoryConfigOption<LoggerOptions>;
+    midwayLogger?: ServiceFactoryConfigOption<LoggerOptions & {
+        lazyLoad?: boolean;
+    }>;
     debug?: {
         recordConfigMergeOrder?: boolean;
     };
@@ -13,10 +308,10 @@ export interface MidwayCoreDefaultConfig {
         enable: boolean;
     };
 }
-export declare type PowerPartial<T> = {
+export type PowerPartial<T> = {
     [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
 };
-export declare type ServiceFactoryConfigOption<OPTIONS> = {
+export type ServiceFactoryConfigOption<OPTIONS> = {
     default?: PowerPartial<OPTIONS>;
     client?: PowerPartial<OPTIONS>;
     clients?: {
@@ -24,7 +319,7 @@ export declare type ServiceFactoryConfigOption<OPTIONS> = {
     };
     defaultClientName?: string;
 };
-export declare type DataSourceManagerConfigOption<OPTIONS> = {
+export type DataSourceManagerConfigOption<OPTIONS> = {
     default?: PowerPartial<OPTIONS>;
     defaultDataSourceName?: string;
     dataSource?: {
@@ -33,15 +328,15 @@ export declare type DataSourceManagerConfigOption<OPTIONS> = {
         } & OPTIONS>;
     };
 };
-declare type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<ReturnType<T>>> : Writable<PowerPartial<T>>;
+type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<ReturnType<T>>> : Writable<PowerPartial<T>>;
 /**
  * Get definition from config
  */
-export declare type FileConfigOption<T, K = unknown> = K extends keyof ConfigType<T> ? Pick<ConfigType<T>, K> : ConfigType<T>;
+export type FileConfigOption<T, K = unknown> = K extends keyof ConfigType<T> ? Pick<ConfigType<T>, K> : ConfigType<T>;
 /**
  * Make object property writeable
  */
-export declare type Writable<T> = {
+export type Writable<T> = {
     -readonly [P in keyof T]: T[P];
 };
 /**
@@ -54,7 +349,7 @@ export interface ILifeCycle extends Partial<IObjectLifeCycle> {
     onServerReady?(container: IMidwayContainer, mainApp?: IMidwayApplication): Promise<void>;
     onStop?(container: IMidwayContainer, mainApp?: IMidwayApplication): Promise<void>;
 }
-export declare type ObjectContext = {
+export type ObjectContext = {
     originName?: string;
 };
 /**
@@ -199,7 +494,7 @@ export interface IManagedResolverFactoryCreateOptions {
     args?: any;
     namespace?: string;
 }
-export declare type HandlerFunction = (
+export type HandlerFunction = (
 /**
  * decorator uuid key
  */
@@ -208,12 +503,12 @@ key: string,
  * decorator set metadata
  */
 meta: any, instance: any) => any;
-export declare type MethodHandlerFunction = (options: {
+export type MethodHandlerFunction = (options: {
     target: new (...args: any[]) => any;
     propertyName: string;
     metadata: any;
 }) => IMethodAspect;
-export declare type ParameterHandlerFunction = (options: {
+export type ParameterHandlerFunction = (options: {
     target: new (...args: any[]) => any;
     propertyName: string;
     metadata: any;
@@ -259,7 +554,7 @@ export interface IMidwayContainer extends IObjectFactory, IObjectLifeCycle {
 /**
  * @deprecated
  */
-export declare type IApplicationContext = IMidwayContainer;
+export type IApplicationContext = IMidwayContainer;
 export interface IFileDetector {
     run(container: IMidwayContainer, fileDetectorOptions?: Record<string, any>): any;
     setExtraDetectorOptions(detectorOptions: Record<string, any>): any;
@@ -308,8 +603,8 @@ export interface Context {
      */
     getAttr<T>(key: string): T;
 }
-export declare type IMidwayContext<FrameworkContext = unknown> = Context & FrameworkContext;
-export declare type NextFunction = () => Promise<any>;
+export type IMidwayContext<FrameworkContext = unknown> = Context & FrameworkContext;
+export type NextFunction = () => Promise<any>;
 /**
  * Common middleware definition
  */
@@ -318,11 +613,11 @@ export interface IMiddleware<CTX, R, N = unknown> {
     match?: (ctx: CTX) => boolean;
     ignore?: (ctx: CTX) => boolean;
 }
-export declare type FunctionMiddleware<CTX, R, N = unknown> = N extends true ? (req: CTX, res: R, next: N) => any : (context: CTX, next: R, options?: any) => any;
-export declare type ClassMiddleware<CTX, R, N> = new (...args: any[]) => IMiddleware<CTX, R, N>;
-export declare type CommonMiddleware<CTX, R, N> = ClassMiddleware<CTX, R, N> | FunctionMiddleware<CTX, R, N>;
-export declare type CommonMiddlewareUnion<CTX, R, N> = CommonMiddleware<CTX, R, N> | Array<CommonMiddleware<CTX, R, N>>;
-export declare type MiddlewareRespond<CTX, R, N> = (context: CTX, nextOrRes?: N extends true ? R : NextFunction, next?: N) => Promise<any>;
+export type FunctionMiddleware<CTX, R, N = unknown> = N extends true ? (req: CTX, res: R, next: N) => any : (context: CTX, next: R, options?: any) => any;
+export type ClassMiddleware<CTX, R, N> = new (...args: any[]) => IMiddleware<CTX, R, N>;
+export type CommonMiddleware<CTX, R, N> = ClassMiddleware<CTX, R, N> | FunctionMiddleware<CTX, R, N>;
+export type CommonMiddlewareUnion<CTX, R, N> = CommonMiddleware<CTX, R, N> | Array<CommonMiddleware<CTX, R, N>>;
+export type MiddlewareRespond<CTX, R, N> = (context: CTX, nextOrRes?: N extends true ? R : NextFunction, next?: N) => Promise<any>;
 /**
  * Common Exception Filter definition
  */
@@ -330,14 +625,14 @@ export interface IFilter<CTX, R, N> {
     catch?(err: Error, ctx: CTX, res?: R, next?: N): any;
     match?(result: any, ctx: CTX, res?: R, next?: N): any;
 }
-export declare type CommonFilterUnion<CTX, R, N> = (new (...args: any[]) => IFilter<CTX, R, N>) | Array<new (...args: any[]) => IFilter<CTX, R, N>>;
+export type CommonFilterUnion<CTX, R, N> = (new (...args: any[]) => IFilter<CTX, R, N>) | Array<new (...args: any[]) => IFilter<CTX, R, N>>;
 /**
  * Guard definition
  */
 export interface IGuard<CTX = unknown> {
     canActivate(ctx: CTX, supplierClz: new (...args: any[]) => any, methodName: string): boolean | Promise<boolean>;
 }
-export declare type CommonGuardUnion<CTX = unknown> = (new (...args: any[]) => IGuard<CTX>) | Array<new (...args: any[]) => IGuard<CTX>>;
+export type CommonGuardUnion<CTX = unknown> = (new (...args: any[]) => IGuard<CTX>) | Array<new (...args: any[]) => IGuard<CTX>>;
 export interface IMiddlewareManager<CTX, R, N> {
     insertFirst(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
     insertLast(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
@@ -454,8 +749,12 @@ export interface IMidwayBaseApplication<CTX extends IMidwayContext> {
      * @param guard
      */
     useGuard(guard: CommonGuardUnion<CTX>): void;
+    /**
+     * get current namespace
+     */
+    getNamespace(): string;
 }
-export declare type IMidwayApplication<T extends IMidwayContext = IMidwayContext, FrameworkApplication = unknown> = IMidwayBaseApplication<T> & FrameworkApplication;
+export type IMidwayApplication<T extends IMidwayContext = IMidwayContext, FrameworkApplication = unknown> = IMidwayBaseApplication<T> & FrameworkApplication;
 export interface IMidwayBootstrapOptions {
     [customPropertyKey: string]: any;
     baseDir?: string;
@@ -474,6 +773,7 @@ export interface IMidwayBootstrapOptions {
         [environmentName: string]: Record<string, any>;
     }> | Record<string, any>;
     asyncContextManager?: AsyncContextManager;
+    loggerFactory?: LoggerFactory<any, any>;
 }
 export interface IConfigurationOptions {
     logger?: ILogger;
@@ -506,6 +806,8 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>): void;
     useGuard(guard: CommonGuardUnion<CTX>): void;
     runGuard(ctx: CTX, supplierClz: new (...args: any[]) => any, methodName: string): Promise<boolean>;
+    getNamespace(): string;
+    setNamespace(namespace: string): void;
 }
 export interface MidwayAppInfo {
     pkg: Record<string, any>;
@@ -522,5 +824,22 @@ export interface MidwayAppInfo {
 export interface MidwayConfig extends FileConfigOption<MidwayCoreDefaultConfig> {
     [customConfigKey: string]: unknown;
 }
+export interface IServiceFactory<Client> {
+    get(clientId: string): Client;
+    has(clientId: string): boolean;
+    createInstance(config: any, clientId?: string): Promise<Client | undefined>;
+    getName(): string;
+    stop(): Promise<void>;
+    getDefaultClientName(): string;
+}
+export interface ISimulation {
+    setup?(): Promise<void>;
+    tearDown?(): Promise<void>;
+    appSetup?(app: IMidwayApplication): Promise<void>;
+    contextSetup?(ctx: IMidwayContext, app: IMidwayApplication): Promise<void>;
+    contextTearDown?(ctx: IMidwayContext, app: IMidwayApplication): Promise<void>;
+    appTearDown?(app: IMidwayApplication): Promise<void>;
+    enableCondition(): boolean | Promise<boolean>;
+}
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -1,6 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayProcessTypeEnum = exports.ObjectLifeCycleEvent = void 0;
+exports.MidwayProcessTypeEnum = exports.ObjectLifeCycleEvent = exports.ServerlessTriggerType = exports.MidwayFrameworkType = exports.FrameworkType = exports.MSListenerType = exports.MSProviderType = exports.InjectModeEnum = exports.ScopeEnum = void 0;
+var ScopeEnum;
+(function (ScopeEnum) {
+    ScopeEnum["Singleton"] = "Singleton";
+    ScopeEnum["Request"] = "Request";
+    ScopeEnum["Prototype"] = "Prototype";
+})(ScopeEnum = exports.ScopeEnum || (exports.ScopeEnum = {}));
+var InjectModeEnum;
+(function (InjectModeEnum) {
+    InjectModeEnum["Identifier"] = "Identifier";
+    InjectModeEnum["Class"] = "Class";
+    InjectModeEnum["PropertyName"] = "PropertyName";
+})(InjectModeEnum = exports.InjectModeEnum || (exports.InjectModeEnum = {}));
+var MSProviderType;
+(function (MSProviderType) {
+    MSProviderType["DUBBO"] = "dubbo";
+    MSProviderType["GRPC"] = "gRPC";
+})(MSProviderType = exports.MSProviderType || (exports.MSProviderType = {}));
+var MSListenerType;
+(function (MSListenerType) {
+    MSListenerType["RABBITMQ"] = "rabbitmq";
+    MSListenerType["MQTT"] = "mqtt";
+    MSListenerType["KAFKA"] = "kafka";
+    MSListenerType["REDIS"] = "redis";
+})(MSListenerType = exports.MSListenerType || (exports.MSListenerType = {}));
+class FrameworkType {
+}
+exports.FrameworkType = FrameworkType;
+class MidwayFrameworkType extends FrameworkType {
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+}
+exports.MidwayFrameworkType = MidwayFrameworkType;
+MidwayFrameworkType.WEB = new MidwayFrameworkType('@midwayjs/web');
+MidwayFrameworkType.WEB_KOA = new MidwayFrameworkType('@midwayjs/web-koa');
+MidwayFrameworkType.WEB_EXPRESS = new MidwayFrameworkType('@midwayjs/express');
+MidwayFrameworkType.FAAS = new MidwayFrameworkType('@midwayjs/faas');
+MidwayFrameworkType.MS_GRPC = new MidwayFrameworkType('@midwayjs/grpc');
+MidwayFrameworkType.MS_RABBITMQ = new MidwayFrameworkType('@midwayjs/rabbitmq');
+MidwayFrameworkType.MS_KAFKA = new MidwayFrameworkType('@midwayjs/kafka');
+MidwayFrameworkType.WS_IO = new MidwayFrameworkType('@midwayjs/socketio');
+MidwayFrameworkType.WS = new MidwayFrameworkType('@midwayjs/ws');
+MidwayFrameworkType.SERVERLESS_APP = new MidwayFrameworkType('@midwayjs/serverless-app');
+MidwayFrameworkType.CUSTOM = new MidwayFrameworkType('');
+MidwayFrameworkType.EMPTY = new MidwayFrameworkType('empty');
+MidwayFrameworkType.LIGHT = new MidwayFrameworkType('light');
+MidwayFrameworkType.TASK = new MidwayFrameworkType('@midwayjs/task');
+var ServerlessTriggerType;
+(function (ServerlessTriggerType) {
+    ServerlessTriggerType["EVENT"] = "event";
+    ServerlessTriggerType["HTTP"] = "http";
+    ServerlessTriggerType["API_GATEWAY"] = "apigw";
+    ServerlessTriggerType["OS"] = "os";
+    ServerlessTriggerType["CDN"] = "cdn";
+    ServerlessTriggerType["LOG"] = "log";
+    ServerlessTriggerType["TIMER"] = "timer";
+    ServerlessTriggerType["MQ"] = "mq";
+    ServerlessTriggerType["KAFKA"] = "kafka";
+    ServerlessTriggerType["HSF"] = "hsf";
+    ServerlessTriggerType["MTOP"] = "mtop";
+    ServerlessTriggerType["SSR"] = "ssr";
+})(ServerlessTriggerType = exports.ServerlessTriggerType || (exports.ServerlessTriggerType = {}));
 var ObjectLifeCycleEvent;
 (function (ObjectLifeCycleEvent) {
     ObjectLifeCycleEvent["BEFORE_BIND"] = "beforeBind";

package/dist/service/aspectService.d.ts

@@ -1,5 +1,4 @@
-import { IMidwayContainer } from '../interface';
-import { AspectMetadata, IMethodAspect } from '../decorator';
+import { IMidwayContainer, AspectMetadata, IMethodAspect } from '../interface';
 export declare class MidwayAspectService {
     readonly applicationContext: IMidwayContainer;
     constructor(applicationContext: IMidwayContainer);

package/dist/service/aspectService.js

@@ -11,6 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayAspectService = void 0;
 const pm = require("picomatch");
+const interface_1 = require("../interface");
 const decorator_1 = require("../decorator");
 const types_1 = require("../util/types");
 let MidwayAspectService = class MidwayAspectService {
@@ -157,7 +158,7 @@ let MidwayAspectService = class MidwayAspectService {
 };
 MidwayAspectService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayAspectService);
 exports.MidwayAspectService = MidwayAspectService;

package/dist/service/configService.js

@@ -11,6 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayConfigService = void 0;
 const path_1 = require("path");
+const interface_1 = require("../interface");
 const util_1 = require("../util");
 const fs_1 = require("fs");
 const util = require("util");
@@ -240,7 +241,7 @@ __decorate([
 ], MidwayConfigService.prototype, "init", null);
 MidwayConfigService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
 ], MidwayConfigService);
 exports.MidwayConfigService = MidwayConfigService;
 //# sourceMappingURL=configService.js.map

package/dist/service/decoratorService.d.ts

@@ -1,15 +1,17 @@
-import { HandlerFunction, IMidwayContainer, MethodHandlerFunction, ParameterHandlerFunction } from '../interface';
+import { HandlerFunction, IMidwayContainer, MethodHandlerFunction, ParameterHandlerFunction, PipeUnionTransform } from '../interface';
 export declare class MidwayDecoratorService {
     readonly applicationContext: IMidwayContainer;
     private propertyHandlerMap;
     private methodDecoratorMap;
     private parameterDecoratorMap;
+    private parameterDecoratorPipes;
     private aspectService;
     constructor(applicationContext: IMidwayContainer);
     protected init(): void;
     registerPropertyHandler(decoratorKey: string, fn: HandlerFunction): void;
     registerMethodHandler(decoratorKey: string, fn: MethodHandlerFunction): void;
     registerParameterHandler(decoratorKey: string, fn: ParameterHandlerFunction): void;
+    registerParameterPipes(decoratorKey: string, pipes: PipeUnionTransform[]): void;
     /**
      * binding getter method for decorator
      *