@midwayjs/core 3.5.4-beta.2 → 3.6.0

package/dist/decorator/faas/serverlessTrigger.d.ts

@@ -0,0 +1,13 @@
+import { FaaSMetadata, ServerlessTriggerType } from '../';
+export declare function ServerlessFunction(options: FaaSMetadata.ServerlessFunctionOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.HTTP, metadata: FaaSMetadata.HTTPTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.OS, metadata: FaaSMetadata.OSTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.LOG, metadata: FaaSMetadata.LogTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.TIMER, metadata: FaaSMetadata.TimerTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.MQ, metadata: FaaSMetadata.MQTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.CDN, metadata?: FaaSMetadata.CDNTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.API_GATEWAY, metadata?: FaaSMetadata.APIGatewayTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.HSF, metadata?: FaaSMetadata.HSFTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.MTOP, metadata?: FaaSMetadata.MTopTriggerOptions): MethodDecorator;
+export declare function ServerlessTrigger(type: ServerlessTriggerType.EVENT, metadata?: FaaSMetadata.EventTriggerOptions): MethodDecorator;
+//# sourceMappingURL=serverlessTrigger.d.ts.map

package/dist/decorator/faas/serverlessTrigger.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerlessTrigger = exports.ServerlessFunction = void 0;
+const __1 = require("../");
+function ServerlessFunction(options) {
+    return (target, key, descriptor) => {
+        (0, __1.savePropertyMetadata)(__1.SERVERLESS_FUNC_KEY, options, target, key);
+    };
+}
+exports.ServerlessFunction = ServerlessFunction;
+function ServerlessTrigger(type, metadata = {}) {
+    return (target, functionName, descriptor) => {
+        var _a;
+        if (type === __1.ServerlessTriggerType.HTTP ||
+            type === __1.ServerlessTriggerType.API_GATEWAY) {
+            metadata['method'] = (_a = metadata['method']) !== null && _a !== void 0 ? _a : 'get';
+        }
+        (0, __1.saveModule)(__1.FUNC_KEY, target.constructor);
+        // new method decorator
+        metadata = metadata || {};
+        (0, __1.attachClassMetadata)(__1.FUNC_KEY, {
+            type,
+            methodName: functionName,
+            metadata,
+        }, target.constructor);
+    };
+}
+exports.ServerlessTrigger = ServerlessTrigger;
+//# sourceMappingURL=serverlessTrigger.js.map

package/dist/decorator/index.d.ts

@@ -0,0 +1,31 @@
+export * from './interface';
+export * from './common/provide';
+export * from './common/inject';
+export * from './common/pipeline';
+export * from './common/aspect';
+export * from './common/autoload';
+export * from './common/configuration';
+export * from './common/objectDef';
+export * from './common/framework';
+export * from './common/filter';
+export * from './common/middleware';
+export * from './common/guard';
+export * from './faas/serverlessTrigger';
+export * from './web/controller';
+export * from './web/paramMapping';
+export * from './web/requestMapping';
+export * from './web/response';
+export * from './constant';
+export * from './decoratorManager';
+export * from './microservice/consumer';
+export * from './microservice/provider';
+export * from './microservice/rabbitmqListener';
+export * from './microservice/kafkaListener';
+export * from './rpc/hsf';
+export * from './task/queue';
+export * from './task/task';
+export * from './task/taskLocal';
+export * from './task/schedule';
+export * from './ws/webSocketController';
+export * from './ws/webSocketEvent';
+//# sourceMappingURL=index.d.ts.map

package/dist/decorator/index.js

@@ -0,0 +1,55 @@
+"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("./interface"), exports);
+// common
+__exportStar(require("./common/provide"), exports);
+__exportStar(require("./common/inject"), exports);
+__exportStar(require("./common/pipeline"), exports);
+__exportStar(require("./common/aspect"), exports);
+__exportStar(require("./common/autoload"), exports);
+__exportStar(require("./common/configuration"), exports);
+__exportStar(require("./common/objectDef"), exports);
+__exportStar(require("./common/framework"), exports);
+__exportStar(require("./common/filter"), exports);
+__exportStar(require("./common/middleware"), exports);
+__exportStar(require("./common/guard"), exports);
+// faas
+__exportStar(require("./faas/serverlessTrigger"), exports);
+// web
+__exportStar(require("./web/controller"), exports);
+__exportStar(require("./web/paramMapping"), exports);
+__exportStar(require("./web/requestMapping"), exports);
+__exportStar(require("./web/response"), exports);
+// other
+__exportStar(require("./constant"), exports);
+__exportStar(require("./decoratorManager"), exports);
+// microservice
+__exportStar(require("./microservice/consumer"), exports);
+__exportStar(require("./microservice/provider"), exports);
+__exportStar(require("./microservice/rabbitmqListener"), exports);
+__exportStar(require("./microservice/kafkaListener"), exports);
+// rpc
+__exportStar(require("./rpc/hsf"), exports);
+// task
+__exportStar(require("./task/queue"), exports);
+__exportStar(require("./task/task"), exports);
+__exportStar(require("./task/taskLocal"), exports);
+__exportStar(require("./task/schedule"), exports);
+// ws
+__exportStar(require("./ws/webSocketController"), exports);
+__exportStar(require("./ws/webSocketEvent"), exports);
+//# sourceMappingURL=index.js.map

package/dist/decorator/interface.d.ts

@@ -0,0 +1,238 @@
+export declare type MiddlewareParamArray = Array<string | any>;
+export declare type ObjectIdentifier = string | Symbol;
+export declare 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 CDNTriggerOptions extends TriggerCommonOptions {
+    }
+    export type EventTriggerUnionOptions = EventTriggerOptions | HTTPTriggerOptions | APIGatewayTriggerOptions | OSTriggerOptions | CDNTriggerOptions | LogTriggerOptions | TimerTriggerOptions | MQTriggerOptions | HSFTriggerOptions | MTopTriggerOptions;
+    export interface TriggerMetadata {
+        type: ServerlessTriggerType;
+        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"
+}
+export interface IModuleStore {
+    listModule(key: string): any;
+    saveModule(key: string, module: any): any;
+    transformModule?(moduleMap: Map<string, Set<any>>): any;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/decorator/interface.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = exports.ServerlessTriggerType || (exports.ServerlessTriggerType = {}));
+//# sourceMappingURL=interface.js.map

package/dist/decorator/microservice/consumer.d.ts

@@ -0,0 +1,5 @@
+import { MSListenerType } from '../';
+export declare function Consumer(type: MSListenerType.MQTT): ClassDecorator;
+export declare function Consumer(type: MSListenerType.RABBITMQ, options?: any): ClassDecorator;
+export declare function Consumer(type: MSListenerType.KAFKA, options?: any): ClassDecorator;
+//# sourceMappingURL=consumer.d.ts.map

package/dist/decorator/microservice/consumer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = void 0;
+const __1 = require("../");
+function Consumer(type, options = {}) {
+    return (target) => {
+        (0, __1.saveModule)(__1.MS_CONSUMER_KEY, target);
+        (0, __1.saveClassMetadata)(__1.MS_CONSUMER_KEY, {
+            type,
+            metadata: options,
+        }, target);
+        (0, __1.Scope)(__1.ScopeEnum.Request)(target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.Consumer = Consumer;
+//# sourceMappingURL=consumer.js.map

package/dist/decorator/microservice/kafkaListener.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @deprecated Replaced by ConsumerSubscribeTopics
+ */
+export declare type ConsumerSubscribeTopic = {
+    fromBeginning?: boolean;
+};
+export declare type ConsumerSubscribeTopics = {
+    fromBeginning?: boolean;
+};
+export declare type ConsumerRunConfig = {
+    autoCommit?: boolean;
+    autoCommitInterval?: number | null;
+    autoCommitThreshold?: number | null;
+    eachBatchAutoResolve?: boolean;
+    partitionsConsumedConcurrently?: number;
+};
+export interface KafkaListenerOptions {
+    propertyKey?: string;
+    topic?: string;
+    subscription?: ConsumerSubscribeTopics | ConsumerSubscribeTopic;
+    runConfig?: ConsumerRunConfig;
+}
+export declare function KafkaListener(topic: string, options?: KafkaListenerOptions): MethodDecorator;
+//# sourceMappingURL=kafkaListener.d.ts.map

package/dist/decorator/microservice/kafkaListener.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaListener = void 0;
+const __1 = require("../");
+function KafkaListener(topic, options = {}) {
+    return (target, propertyKey) => {
+        options.topic = topic;
+        options.propertyKey = propertyKey;
+        (0, __1.attachPropertyDataToClass)(__1.MS_CONSUMER_KEY, options, target, propertyKey);
+    };
+}
+exports.KafkaListener = KafkaListener;
+//# sourceMappingURL=kafkaListener.js.map

package/dist/decorator/microservice/provider.d.ts

@@ -0,0 +1,16 @@
+import { MSProviderType, GRPCMetadata } from '../';
+export declare function Provider(type: MSProviderType.GRPC, metadata?: GRPCMetadata.ProviderOptions): ClassDecorator;
+export declare function Provider(type: MSProviderType.DUBBO, metadata?: any): ClassDecorator;
+export declare enum GrpcStreamTypeEnum {
+    BASE = "base",
+    DUPLEX = "ServerDuplexStream",
+    READABLE = "ServerReadableStream",
+    WRITEABLE = "ServerWritableStream"
+}
+export declare function GrpcMethod(methodOptions?: {
+    methodName?: string;
+    type?: GrpcStreamTypeEnum;
+    onEnd?: string;
+}): MethodDecorator;
+export declare function DubboMethod(methodName?: string): MethodDecorator;
+//# sourceMappingURL=provider.d.ts.map

package/dist/decorator/microservice/provider.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DubboMethod = exports.GrpcMethod = exports.GrpcStreamTypeEnum = exports.Provider = void 0;
+const __1 = require("../");
+function Provider(type, metadata = {}) {
+    return (target) => {
+        (0, __1.saveModule)(__1.MS_PROVIDER_KEY, target);
+        (0, __1.saveClassMetadata)(__1.MS_PROVIDER_KEY, {
+            type,
+            metadata,
+        }, target);
+        (0, __1.Scope)(__1.ScopeEnum.Request)(target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.Provider = Provider;
+var GrpcStreamTypeEnum;
+(function (GrpcStreamTypeEnum) {
+    GrpcStreamTypeEnum["BASE"] = "base";
+    GrpcStreamTypeEnum["DUPLEX"] = "ServerDuplexStream";
+    GrpcStreamTypeEnum["READABLE"] = "ServerReadableStream";
+    GrpcStreamTypeEnum["WRITEABLE"] = "ServerWritableStream";
+})(GrpcStreamTypeEnum = exports.GrpcStreamTypeEnum || (exports.GrpcStreamTypeEnum = {}));
+function GrpcMethod(methodOptions = {}) {
+    return (target, propertyName, descriptor) => {
+        if (!methodOptions.type) {
+            methodOptions.type = GrpcStreamTypeEnum.BASE;
+        }
+        (0, __1.savePropertyMetadata)(__1.MS_GRPC_METHOD_KEY, {
+            methodName: methodOptions.methodName || propertyName,
+            type: methodOptions.type,
+            onEnd: methodOptions.onEnd,
+        }, target, propertyName);
+        return descriptor;
+    };
+}
+exports.GrpcMethod = GrpcMethod;
+function DubboMethod(methodName) {
+    return (target, propertyName, descriptor) => {
+        (0, __1.attachClassMetadata)(__1.MS_DUBBO_METHOD_KEY, {
+            methodName: methodName || propertyName,
+        }, target);
+        return descriptor;
+    };
+}
+exports.DubboMethod = DubboMethod;
+//# sourceMappingURL=provider.js.map

package/dist/decorator/microservice/rabbitmqListener.d.ts

@@ -0,0 +1,50 @@
+export interface RabbitMQListenerOptions {
+    propertyKey?: string;
+    queueName?: string;
+    exchange?: string;
+    /**
+     * queue options
+     */
+    exclusive?: boolean;
+    durable?: boolean;
+    autoDelete?: boolean;
+    messageTtl?: number;
+    expires?: number;
+    deadLetterExchange?: string;
+    deadLetterRoutingKey?: string;
+    maxLength?: number;
+    maxPriority?: number;
+    pattern?: string;
+    /**
+     * prefetch
+     */
+    prefetch?: number;
+    /**
+     * router
+     */
+    routingKey?: string;
+    /**
+     * exchange options
+     */
+    exchangeOptions?: {
+        type?: 'direct' | 'topic' | 'headers' | 'fanout' | 'match' | string;
+        durable?: boolean;
+        internal?: boolean;
+        autoDelete?: boolean;
+        alternateExchange?: string;
+        arguments?: any;
+    };
+    /**
+     * consumeOptions
+     */
+    consumeOptions?: {
+        consumerTag?: string;
+        noLocal?: boolean;
+        noAck?: boolean;
+        exclusive?: boolean;
+        priority?: number;
+        arguments?: any;
+    };
+}
+export declare function RabbitMQListener(queueName: string, options?: RabbitMQListenerOptions): MethodDecorator;
+//# sourceMappingURL=rabbitmqListener.d.ts.map

package/dist/decorator/microservice/rabbitmqListener.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQListener = void 0;
+const __1 = require("../");
+function RabbitMQListener(queueName, options = {}) {
+    return (target, propertyKey) => {
+        options.queueName = queueName;
+        options.propertyKey = propertyKey;
+        (0, __1.attachPropertyDataToClass)(__1.MS_CONSUMER_KEY, options, target, propertyKey);
+    };
+}
+exports.RabbitMQListener = RabbitMQListener;
+//# sourceMappingURL=rabbitmqListener.js.map

package/dist/decorator/rpc/hsf.d.ts

@@ -0,0 +1,12 @@
+export interface HSFOpts {
+    interfaceName?: string;
+    version?: string;
+    group?: string;
+    namespace?: string;
+}
+/**
+ * @param hsfOption
+ * @constructor
+ */
+export declare function HSF(hsfOption?: HSFOpts): ClassDecorator;
+//# sourceMappingURL=hsf.d.ts.map

package/dist/decorator/rpc/hsf.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HSF = void 0;
+const __1 = require("../");
+/**
+ * @param hsfOption
+ * @constructor
+ */
+function HSF(hsfOption = {}) {
+    return (target) => {
+        (0, __1.saveModule)(__1.HSF_KEY, target);
+        (0, __1.saveClassMetadata)(__1.HSF_KEY, hsfOption, target);
+        (0, __1.Scope)(__1.ScopeEnum.Request)(target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.HSF = HSF;
+//# sourceMappingURL=hsf.js.map

package/dist/decorator/task/queue.d.ts

@@ -0,0 +1,2 @@
+export declare function Queue(options?: any): ClassDecorator;
+//# sourceMappingURL=queue.d.ts.map