@midwayjs/core 3.5.4-beta.2 → 3.6.0

package/dist/decorator/task/queue.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+const __1 = require("../");
+const constant_1 = require("../constant");
+function Queue(options) {
+    return function (target) {
+        (0, __1.saveModule)(constant_1.MODULE_TASK_QUEUE_KEY, target);
+        (0, __1.saveClassMetadata)(constant_1.MODULE_TASK_QUEUE_OPTIONS, {
+            options,
+            name: target.name,
+        }, target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.Queue = Queue;
+//# sourceMappingURL=queue.js.map

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

@@ -0,0 +1,21 @@
+export interface CommonSchedule {
+    exec(ctx?: any): any;
+}
+export interface ScheduleOpts {
+    type: string;
+    cron?: string;
+    interval?: number | string;
+    immediate?: boolean;
+    disable?: boolean;
+    env?: string[];
+    cronOptions?: {
+        currentDate?: string | number | Date;
+        startDate?: string | number | Date;
+        endDate?: string | number | Date;
+        iterator?: boolean;
+        utc?: boolean;
+        tz?: string;
+    };
+}
+export declare function Schedule(scheduleOpts: ScheduleOpts | string): (target: any) => void;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/decorator/task/schedule.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schedule = void 0;
+const __1 = require("../");
+function Schedule(scheduleOpts) {
+    return function (target) {
+        (0, __1.saveModule)(__1.SCHEDULE_KEY, target);
+        (0, __1.saveClassMetadata)(__1.SCHEDULE_KEY, scheduleOpts, target);
+        (0, __1.Scope)(__1.ScopeEnum.Request)(target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.Schedule = Schedule;
+//# sourceMappingURL=schedule.js.map

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

@@ -0,0 +1,2 @@
+export declare function Task(options: any): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+//# sourceMappingURL=task.d.ts.map

package/dist/decorator/task/task.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+const __1 = require("../");
+const constant_1 = require("../constant");
+function Task(options) {
+    return function (target, propertyKey, descriptor) {
+        (0, __1.saveModule)(constant_1.MODULE_TASK_KEY, target.constructor);
+        (0, __1.attachClassMetadata)(constant_1.MODULE_TASK_METADATA, {
+            options,
+            propertyKey,
+            value: descriptor.value,
+            name: target.constructor.name,
+        }, target);
+    };
+}
+exports.Task = Task;
+//# sourceMappingURL=task.js.map

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

@@ -0,0 +1,2 @@
+export declare function TaskLocal(options: any): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+//# sourceMappingURL=taskLocal.d.ts.map

package/dist/decorator/task/taskLocal.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskLocal = void 0;
+const __1 = require("../");
+const constant_1 = require("../constant");
+function TaskLocal(options) {
+    return function (target, propertyKey, descriptor) {
+        (0, __1.saveModule)(constant_1.MODULE_TASK_TASK_LOCAL_KEY, target.constructor);
+        (0, __1.attachClassMetadata)(constant_1.MODULE_TASK_TASK_LOCAL_OPTIONS, {
+            options,
+            propertyKey,
+            value: descriptor.value,
+        }, target);
+    };
+}
+exports.TaskLocal = TaskLocal;
+//# sourceMappingURL=taskLocal.js.map

package/dist/decorator/web/controller.d.ts

@@ -0,0 +1,20 @@
+import { MiddlewareParamArray } from '../';
+export interface ControllerOption {
+    prefix: string;
+    routerOptions?: {
+        sensitive?: boolean;
+        middleware?: MiddlewareParamArray;
+        alias?: string[];
+        description?: string;
+        tagName?: string;
+        ignoreGlobalPrefix?: boolean;
+    };
+}
+export declare function Controller(prefix?: string, routerOptions?: {
+    sensitive?: boolean;
+    middleware?: MiddlewareParamArray;
+    description?: string;
+    tagName?: string;
+    ignoreGlobalPrefix?: boolean;
+}): ClassDecorator;
+//# sourceMappingURL=controller.d.ts.map

package/dist/decorator/web/controller.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const __1 = require("../");
+function Controller(prefix = '/', routerOptions = { middleware: [], sensitive: true }) {
+    return (target) => {
+        (0, __1.saveModule)(__1.CONTROLLER_KEY, target);
+        if (prefix)
+            (0, __1.saveClassMetadata)(__1.CONTROLLER_KEY, {
+                prefix,
+                routerOptions,
+            }, target);
+        (0, __1.Scope)(__1.ScopeEnum.Request)(target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.Controller = Controller;
+//# sourceMappingURL=controller.js.map

package/dist/decorator/web/paramMapping.d.ts

@@ -0,0 +1,31 @@
+export declare enum RouteParamTypes {
+    QUERY = 0,
+    BODY = 1,
+    PARAM = 2,
+    HEADERS = 3,
+    SESSION = 4,
+    FILESTREAM = 5,
+    FILESSTREAM = 6,
+    NEXT = 7,
+    REQUEST_PATH = 8,
+    REQUEST_IP = 9,
+    QUERIES = 10,
+    FIELDS = 11
+}
+export interface RouterParamValue {
+    index: number;
+    type: RouteParamTypes;
+    propertyData?: any;
+}
+export declare const Session: (property?: string) => ParameterDecorator;
+export declare const Body: (property?: string) => ParameterDecorator;
+export declare const Query: (property?: string) => ParameterDecorator;
+export declare const Param: (property?: string) => ParameterDecorator;
+export declare const Headers: (property?: string) => ParameterDecorator;
+export declare const File: (property?: any) => ParameterDecorator;
+export declare const Files: (property?: any) => ParameterDecorator;
+export declare const RequestPath: () => ParameterDecorator;
+export declare const RequestIP: () => ParameterDecorator;
+export declare const Queries: (property?: string) => ParameterDecorator;
+export declare const Fields: (property?: string) => ParameterDecorator;
+//# sourceMappingURL=paramMapping.d.ts.map

package/dist/decorator/web/paramMapping.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fields = exports.Queries = exports.RequestIP = exports.RequestPath = exports.Files = exports.File = exports.Headers = exports.Param = exports.Query = exports.Body = exports.Session = exports.RouteParamTypes = void 0;
+const __1 = require("../");
+var RouteParamTypes;
+(function (RouteParamTypes) {
+    RouteParamTypes[RouteParamTypes["QUERY"] = 0] = "QUERY";
+    RouteParamTypes[RouteParamTypes["BODY"] = 1] = "BODY";
+    RouteParamTypes[RouteParamTypes["PARAM"] = 2] = "PARAM";
+    RouteParamTypes[RouteParamTypes["HEADERS"] = 3] = "HEADERS";
+    RouteParamTypes[RouteParamTypes["SESSION"] = 4] = "SESSION";
+    RouteParamTypes[RouteParamTypes["FILESTREAM"] = 5] = "FILESTREAM";
+    RouteParamTypes[RouteParamTypes["FILESSTREAM"] = 6] = "FILESSTREAM";
+    RouteParamTypes[RouteParamTypes["NEXT"] = 7] = "NEXT";
+    RouteParamTypes[RouteParamTypes["REQUEST_PATH"] = 8] = "REQUEST_PATH";
+    RouteParamTypes[RouteParamTypes["REQUEST_IP"] = 9] = "REQUEST_IP";
+    RouteParamTypes[RouteParamTypes["QUERIES"] = 10] = "QUERIES";
+    RouteParamTypes[RouteParamTypes["FIELDS"] = 11] = "FIELDS";
+})(RouteParamTypes = exports.RouteParamTypes || (exports.RouteParamTypes = {}));
+const createParamMapping = function (type) {
+    return (propertyData) => {
+        return (0, __1.createCustomParamDecorator)(__1.WEB_ROUTER_PARAM_KEY, {
+            type,
+            propertyData,
+        });
+    };
+};
+const Session = (property) => createParamMapping(RouteParamTypes.SESSION)(property);
+exports.Session = Session;
+const Body = (property) => createParamMapping(RouteParamTypes.BODY)(property);
+exports.Body = Body;
+const Query = (property) => createParamMapping(RouteParamTypes.QUERY)(property);
+exports.Query = Query;
+const Param = (property) => createParamMapping(RouteParamTypes.PARAM)(property);
+exports.Param = Param;
+const Headers = (property) => createParamMapping(RouteParamTypes.HEADERS)(property);
+exports.Headers = Headers;
+const File = (property) => createParamMapping(RouteParamTypes.FILESTREAM)(property);
+exports.File = File;
+const Files = (property) => createParamMapping(RouteParamTypes.FILESSTREAM)(property);
+exports.Files = Files;
+const RequestPath = () => createParamMapping(RouteParamTypes.REQUEST_PATH)();
+exports.RequestPath = RequestPath;
+const RequestIP = () => createParamMapping(RouteParamTypes.REQUEST_IP)();
+exports.RequestIP = RequestIP;
+const Queries = (property) => createParamMapping(RouteParamTypes.QUERIES)(property);
+exports.Queries = Queries;
+const Fields = (property) => createParamMapping(RouteParamTypes.FIELDS)(property);
+exports.Fields = Fields;
+//# sourceMappingURL=paramMapping.js.map

package/dist/decorator/web/requestMapping.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 'HEAD', 'OPTIONS', 'GET', 'PUT', 'PATCH', 'POST', 'DELETE' 封装
+ */
+import { MiddlewareParamArray } from '../';
+export interface RouterOption {
+    /**
+     * router path, like "/api"
+     */
+    path?: string | RegExp;
+    /**
+     * http method, like "get", "post"
+     */
+    requestMethod: string;
+    /**
+     * router alias name
+     */
+    routerName?: string;
+    /**
+     * which method decorator attached
+     */
+    method?: string;
+    /**
+     * middleware array in router
+     */
+    middleware?: MiddlewareParamArray;
+    /**
+     * router summary, for swagger
+     * @deprecated
+     */
+    summary?: string;
+    /**
+     * router description, for swagger
+     * @deprecated
+     */
+    description?: string;
+    /**
+     * ignore global prefix
+     */
+    ignoreGlobalPrefix?: boolean;
+}
+export declare const RequestMethod: {
+    GET: string;
+    POST: string;
+    PUT: string;
+    DELETE: string;
+    PATCH: string;
+    ALL: string;
+    OPTIONS: string;
+    HEAD: string;
+};
+export declare const RequestMapping: (metadata?: RouterOption) => MethodDecorator;
+/**
+ * Routes HTTP POST requests to the specified path.
+ */
+export declare const Post: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes HTTP GET requests to the specified path.
+ */
+export declare const Get: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes HTTP DELETE requests to the specified path.
+ */
+export declare const Del: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes HTTP PUT requests to the specified path.
+ */
+export declare const Put: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes HTTP PATCH requests to the specified path.
+ */
+export declare const Patch: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes HTTP OPTIONS requests to the specified path.
+ */
+export declare const Options: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes HTTP HEAD requests to the specified path.
+ */
+export declare const Head: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+/**
+ * Routes all HTTP requests to the specified path.
+ */
+export declare const All: (path?: string | RegExp, routerOptions?: {
+    routerName?: string;
+    middleware?: MiddlewareParamArray;
+    summary?: string;
+    description?: string;
+    ignoreGlobalPrefix?: boolean;
+}) => MethodDecorator;
+//# sourceMappingURL=requestMapping.d.ts.map

package/dist/decorator/web/requestMapping.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.All = exports.Head = exports.Options = exports.Patch = exports.Put = exports.Del = exports.Get = exports.Post = exports.RequestMapping = exports.RequestMethod = void 0;
+/**
+ * 'HEAD', 'OPTIONS', 'GET', 'PUT', 'PATCH', 'POST', 'DELETE' 封装
+ */
+const __1 = require("../");
+exports.RequestMethod = {
+    GET: 'get',
+    POST: 'post',
+    PUT: 'put',
+    DELETE: 'delete',
+    PATCH: 'patch',
+    ALL: 'all',
+    OPTIONS: 'options',
+    HEAD: 'head',
+};
+const defaultMetadata = {
+    path: '/',
+    requestMethod: exports.RequestMethod.GET,
+    routerName: null,
+    middleware: [],
+};
+const RequestMapping = (metadata = defaultMetadata) => {
+    const path = metadata.path || '/';
+    const requestMethod = metadata.requestMethod || exports.RequestMethod.GET;
+    const routerName = metadata.routerName;
+    const middleware = metadata.middleware;
+    return (target, key, descriptor) => {
+        var _a;
+        (0, __1.attachClassMetadata)(__1.WEB_ROUTER_KEY, {
+            path,
+            requestMethod,
+            routerName,
+            method: key,
+            middleware,
+            summary: (metadata === null || metadata === void 0 ? void 0 : metadata.summary) || '',
+            description: (metadata === null || metadata === void 0 ? void 0 : metadata.description) || '',
+            ignoreGlobalPrefix: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.ignoreGlobalPrefix) !== null && _a !== void 0 ? _a : false,
+        }, target);
+        return descriptor;
+    };
+};
+exports.RequestMapping = RequestMapping;
+const createMappingDecorator = (method) => (path, routerOptions = { middleware: [] }) => {
+    return (0, exports.RequestMapping)(Object.assign(routerOptions, {
+        requestMethod: method,
+        path,
+    }));
+};
+/**
+ * Routes HTTP POST requests to the specified path.
+ */
+exports.Post = createMappingDecorator(exports.RequestMethod.POST);
+/**
+ * Routes HTTP GET requests to the specified path.
+ */
+exports.Get = createMappingDecorator(exports.RequestMethod.GET);
+/**
+ * Routes HTTP DELETE requests to the specified path.
+ */
+exports.Del = createMappingDecorator(exports.RequestMethod.DELETE);
+/**
+ * Routes HTTP PUT requests to the specified path.
+ */
+exports.Put = createMappingDecorator(exports.RequestMethod.PUT);
+/**
+ * Routes HTTP PATCH requests to the specified path.
+ */
+exports.Patch = createMappingDecorator(exports.RequestMethod.PATCH);
+/**
+ * Routes HTTP OPTIONS requests to the specified path.
+ */
+exports.Options = createMappingDecorator(exports.RequestMethod.OPTIONS);
+/**
+ * Routes HTTP HEAD requests to the specified path.
+ */
+exports.Head = createMappingDecorator(exports.RequestMethod.HEAD);
+/**
+ * Routes all HTTP requests to the specified path.
+ */
+exports.All = createMappingDecorator(exports.RequestMethod.ALL);
+//# sourceMappingURL=requestMapping.js.map

package/dist/decorator/web/response.d.ts

@@ -0,0 +1,9 @@
+export declare function Redirect(url: string, code?: number): (target: any, key: any, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function HttpCode(code: number): (target: any, key: any, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function SetHeader(headerKey: string | Record<string, any>, value?: string): (target: any, key: any, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ContentType(contentType: string): (target: any, key: any, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function createRender(RenderEngine: {
+    render: () => string;
+    renderString: () => string;
+}): (templateName: string) => (target: any, key: any, descriptor: PropertyDescriptor) => PropertyDescriptor;
+//# sourceMappingURL=response.d.ts.map

package/dist/decorator/web/response.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRender = exports.ContentType = exports.SetHeader = exports.HttpCode = exports.Redirect = void 0;
+const __1 = require("../");
+function Redirect(url, code = 302) {
+    return (target, key, descriptor) => {
+        (0, __1.attachPropertyMetadata)(__1.WEB_RESPONSE_KEY, {
+            type: __1.WEB_RESPONSE_REDIRECT,
+            url,
+            code,
+        }, target, key);
+        return descriptor;
+    };
+}
+exports.Redirect = Redirect;
+function HttpCode(code) {
+    return (target, key, descriptor) => {
+        (0, __1.attachPropertyMetadata)(__1.WEB_RESPONSE_KEY, {
+            type: __1.WEB_RESPONSE_HTTP_CODE,
+            code,
+        }, target, key);
+        return descriptor;
+    };
+}
+exports.HttpCode = HttpCode;
+function SetHeader(headerKey, value) {
+    return (target, key, descriptor) => {
+        let headerObject = {};
+        if (value) {
+            headerObject[headerKey] = value;
+        }
+        else {
+            headerObject = headerKey;
+        }
+        (0, __1.attachPropertyMetadata)(__1.WEB_RESPONSE_KEY, {
+            type: __1.WEB_RESPONSE_HEADER,
+            setHeaders: headerObject,
+        }, target, key);
+        return descriptor;
+    };
+}
+exports.SetHeader = SetHeader;
+function ContentType(contentType) {
+    return (target, key, descriptor) => {
+        (0, __1.attachPropertyMetadata)(__1.WEB_RESPONSE_KEY, {
+            type: __1.WEB_RESPONSE_CONTENT_TYPE,
+            contentType,
+        }, target, key);
+        return descriptor;
+    };
+}
+exports.ContentType = ContentType;
+function createRender(RenderEngine) {
+    return (templateName) => {
+        return (target, key, descriptor) => {
+            (0, __1.attachPropertyMetadata)(__1.WEB_RESPONSE_KEY, {
+                type: __1.WEB_RESPONSE_RENDER,
+                templateName,
+            }, target, key);
+            return descriptor;
+        };
+    };
+}
+exports.createRender = createRender;
+//# sourceMappingURL=response.js.map

package/dist/decorator/ws/webSocketController.d.ts

@@ -0,0 +1,10 @@
+import { MiddlewareParamArray } from '../';
+export interface WSControllerOption {
+    namespace: string;
+    routerOptions: {
+        connectionMiddleware?: MiddlewareParamArray;
+        middleware?: MiddlewareParamArray;
+    };
+}
+export declare function WSController(namespace?: string | RegExp, routerOptions?: WSControllerOption['routerOptions']): ClassDecorator;
+//# sourceMappingURL=webSocketController.d.ts.map

package/dist/decorator/ws/webSocketController.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSController = void 0;
+const __1 = require("../");
+function WSController(namespace = '/', routerOptions = {
+    middleware: [],
+    connectionMiddleware: [],
+}) {
+    return (target) => {
+        (0, __1.saveModule)(__1.WS_CONTROLLER_KEY, target);
+        (0, __1.saveClassMetadata)(__1.WS_CONTROLLER_KEY, {
+            namespace,
+            routerOptions,
+        }, target);
+        (0, __1.Scope)(__1.ScopeEnum.Request)(target);
+        (0, __1.Provide)()(target);
+    };
+}
+exports.WSController = WSController;
+//# sourceMappingURL=webSocketController.js.map

package/dist/decorator/ws/webSocketEvent.d.ts

@@ -0,0 +1,60 @@
+import { MiddlewareParamArray } from '../';
+export declare enum WSEventTypeEnum {
+    ON_CONNECTION = "ws:onConnection",
+    ON_DISCONNECTION = "ws:onDisconnection",
+    ON_MESSAGE = "ws:onMessage",
+    ON_SOCKET_ERROR = "ws:onSocketError",
+    EMIT = "ws:Emit",
+    BROADCAST = "ws:broadcast"
+}
+export interface WSEventInfo {
+    /**
+     * web socket event name in enum
+     */
+    eventType: WSEventTypeEnum;
+    /**
+     * decorator method name
+     */
+    propertyName: string;
+    descriptor: PropertyDescriptor;
+    /**
+     * the event name by user definition
+     */
+    messageEventName?: string;
+    /**
+     * the room name to emit
+     */
+    roomName?: string[];
+    /**
+     * event options, like middleware
+     */
+    eventOptions?: {
+        middleware?: MiddlewareParamArray;
+    };
+}
+export declare function OnWSConnection(eventOptions?: {
+    middleware?: MiddlewareParamArray;
+}): MethodDecorator;
+export declare function OnWSDisConnection(): MethodDecorator;
+export declare function OnWSMessage(eventName: string, eventOptions?: {
+    middleware?: MiddlewareParamArray;
+}): MethodDecorator;
+export declare function WSEmit(messageName: string, roomName?: string | string[]): MethodDecorator;
+export declare function WSBroadCast(messageName?: string, roomName?: string | string[]): MethodDecorator;
+/**
+ * @deprecated please use @OnWSMessage
+ */
+export declare const OnMessage: typeof OnWSMessage;
+/**
+ * @deprecated please use @WSEmit
+ */
+export declare const Emit: typeof WSEmit;
+/**
+ * @deprecated please use @OnWSDisConnection
+ */
+export declare const OnDisConnection: typeof OnWSDisConnection;
+/**
+ * @deprecated please use @OnWSConnection
+ */
+export declare const OnConnection: typeof OnWSConnection;
+//# sourceMappingURL=webSocketEvent.d.ts.map