@midwayjs/core 3.16.2 → 3.17.0

package/dist/common/middlewareManager.d.ts

@@ -1,4 +1,4 @@
-import { CommonMiddleware, CommonMiddlewareUnion, IMiddlewareManager, IMidwayContext } from '../interface';
+import { ClassMiddleware, CommonMiddleware, CommonMiddlewareUnion, CompositionMiddleware, IMiddlewareManager, IMidwayContext } from '../interface';
 export declare class ContextMiddlewareManager<CTX extends IMidwayContext, R, N> extends Array<CommonMiddleware<CTX, R, N>> implements IMiddlewareManager<CTX, R, N> {
     /**
      * insert a middleware or middleware array to first
@@ -67,4 +67,15 @@ export declare class ContextMiddlewareManager<CTX extends IMidwayContext, R, N>
      */
     getNames(): string[];
 }
+/**
+ * Get middleware resolve options
+ */
+type MiddlewareResolveOptions<T, CTX, R, N> = T extends ClassMiddleware<CTX, R, N> ? InstanceType<T> extends {
+    resolve: (...args: infer P) => any;
+} ? P[1] : any : never;
+/**
+ * wrap a middleware with options and composition a new middleware
+ */
+export declare function createMiddleware<CTX extends IMidwayContext, R, N, M extends ClassMiddleware<CTX, R, N>>(middleware: M, options: MiddlewareResolveOptions<M, CTX, R, N>, name?: string): CompositionMiddleware<CTX, R, N>;
+export {};
 //# sourceMappingURL=middlewareManager.d.ts.map

package/dist/common/middlewareManager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextMiddlewareManager = void 0;
+exports.createMiddleware = exports.ContextMiddlewareManager = void 0;
 class ContextMiddlewareManager extends Array {
     /**
      * insert a middleware or middleware array to first
@@ -151,8 +151,11 @@ class ContextMiddlewareManager extends Array {
      * @param middleware
      */
     getMiddlewareName(middleware) {
-        var _a, _b;
-        return ((_b = (_a = (middleware.getName && middleware.getName())) !== null && _a !== void 0 ? _a : middleware._name) !== null && _b !== void 0 ? _b : middleware.name);
+        var _a, _b, _c;
+        if (middleware['middleware']) {
+            return ((_a = middleware.name) !== null && _a !== void 0 ? _a : this.getMiddlewareName(middleware['middleware']));
+        }
+        return ((_c = (_b = (middleware.getName && middleware.getName())) !== null && _b !== void 0 ? _b : middleware._name) !== null && _c !== void 0 ? _c : middleware.name);
     }
     /**
      * remove a middleware
@@ -196,4 +199,15 @@ class ContextMiddlewareManager extends Array {
     }
 }
 exports.ContextMiddlewareManager = ContextMiddlewareManager;
+/**
+ * wrap a middleware with options and composition a new middleware
+ */
+function createMiddleware(middleware, options, name) {
+    return {
+        middleware,
+        options,
+        name,
+    };
+}
+exports.createMiddleware = createMiddleware;
 //# sourceMappingURL=middlewareManager.js.map

package/dist/index.d.ts

@@ -46,4 +46,5 @@ export { Types } from './util/types';
 export { PathFileUtil } from './util/pathFileUtil';
 export { FileUtils } from './util/fs';
 export { FORMAT } from './util/format';
+export { ServerResponse, HttpServerResponse } from './response/index';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORMAT = exports.FileUtils = exports.PathFileUtil = exports.Types = exports.retryWith = exports.retryWithAsync = exports.extend = exports.Utils = exports.sleep = exports.isTypeScriptEnvironment = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.loadModule = exports.safeRequire = exports.safelyGet = exports.ASYNC_ROOT_CONTEXT = exports.MidwayPriorityManager = exports.DEFAULT_PRIORITY = exports.DataSourceManager = exports.WebRouterCollector = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayHealthService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.FunctionalConfiguration = exports.createConfiguration = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
+exports.HttpServerResponse = exports.ServerResponse = exports.FORMAT = exports.FileUtils = exports.PathFileUtil = exports.Types = exports.retryWith = exports.retryWithAsync = exports.extend = exports.Utils = exports.sleep = exports.isTypeScriptEnvironment = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.loadModule = exports.safeRequire = exports.safelyGet = exports.ASYNC_ROOT_CONTEXT = exports.MidwayPriorityManager = exports.DEFAULT_PRIORITY = exports.DataSourceManager = exports.WebRouterCollector = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayHealthService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.FunctionalConfiguration = exports.createConfiguration = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
 __exportStar(require("./interface"), exports);
 __exportStar(require("./context/container"), exports);
 var requestContainer_1 = require("./context/requestContainer");
@@ -109,4 +109,7 @@ var fs_1 = require("./util/fs");
 Object.defineProperty(exports, "FileUtils", { enumerable: true, get: function () { return fs_1.FileUtils; } });
 var format_1 = require("./util/format");
 Object.defineProperty(exports, "FORMAT", { enumerable: true, get: function () { return format_1.FORMAT; } });
+var index_1 = require("./response/index");
+Object.defineProperty(exports, "ServerResponse", { enumerable: true, get: function () { return index_1.ServerResponse; } });
+Object.defineProperty(exports, "HttpServerResponse", { enumerable: true, get: function () { return index_1.HttpServerResponse; } });
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -421,12 +421,12 @@ export type CreateDataSourceInstanceOptions = {
     cacheInstance?: boolean | undefined;
 };
 export type DataSourceManagerConfigOption<OPTIONS, ENTITY_CONFIG_KEY extends string = 'entities'> = {
-    default?: PowerPartial<OPTIONS>;
+    default?: OPTIONS;
     defaultDataSourceName?: string;
     dataSource?: {
         [key: string]: PowerPartial<{
             [keyName in ENTITY_CONFIG_KEY]: any[];
-        } & OPTIONS>;
+        }> & OPTIONS;
     };
 } & CreateDataSourceInstanceOptions;
 type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<ReturnType<T>>> : Writable<PowerPartial<T>>;
@@ -715,13 +715,24 @@ export type IgnoreMatcher<CTX> = string | RegExp | ((ctx: CTX) => boolean);
  * Common middleware definition
  */
 export interface IMiddleware<CTX, R, N = unknown> {
-    resolve: (app: IMidwayApplication) => FunctionMiddleware<CTX, R, N> | Promise<FunctionMiddleware<CTX, R, N>>;
+    resolve: (app: IMidwayApplication, options?: any) => FunctionMiddleware<CTX, R, N> | Promise<FunctionMiddleware<CTX, R, N>>;
+    /**
+     * Which paths to ignore
+     */
     match?: IgnoreMatcher<CTX> | IgnoreMatcher<CTX>[];
+    /**
+     * Match those paths with higher priority than ignore
+     */
     ignore?: IgnoreMatcher<CTX> | IgnoreMatcher<CTX>[];
 }
 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 CompositionMiddleware<CTX, R, N> = {
+    middleware: ClassMiddleware<CTX, R, N>;
+    options: any;
+    name?: string;
+};
+export type CommonMiddleware<CTX, R, N> = ClassMiddleware<CTX, R, N> | FunctionMiddleware<CTX, R, N> | CompositionMiddleware<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>;
 /**
@@ -987,5 +998,18 @@ export interface HealthResults {
         reason?: string;
     }>;
 }
+export interface ServerSendEventMessage {
+    data?: string | object;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+export interface ServerStreamOptions {
+    tpl?: (data: unknown) => unknown;
+}
+export interface ServerSendEventStreamOptions {
+    closeEvent?: string;
+    tpl?: (data: ServerSendEventMessage) => ServerSendEventMessage;
+}
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/response/base.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { IMidwayContext } from '../interface';
+export declare class ServerResponse<CTX extends IMidwayContext = IMidwayContext> {
+    protected readonly ctx: any;
+    protected isSuccess: boolean;
+    constructor(ctx: CTX);
+    static TEXT_TPL: (data: string, isSuccess: boolean) => unknown;
+    static JSON_TPL: (data: Record<any, any>, isSuccess: boolean) => unknown;
+    static BLOB_TPL: (data: Buffer, isSuccess: boolean) => unknown;
+    json(data: Record<any, any>): any;
+    text(data: string): any;
+    blob(data: Buffer): any;
+    success(): this;
+    fail(): this;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/response/base.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerResponse = void 0;
+class ServerResponse {
+    constructor(ctx) {
+        this.isSuccess = true;
+        this.ctx = ctx;
+    }
+    json(data) {
+        return Object.getPrototypeOf(this).constructor.JSON_TPL(data, this.isSuccess);
+    }
+    text(data) {
+        return Object.getPrototypeOf(this).constructor.TEXT_TPL(data, this.isSuccess);
+    }
+    blob(data) {
+        return Object.getPrototypeOf(this).constructor.BLOB_TPL(data, this.isSuccess);
+    }
+    success() {
+        this.isSuccess = true;
+        return this;
+    }
+    fail() {
+        this.isSuccess = false;
+        return this;
+    }
+}
+exports.ServerResponse = ServerResponse;
+ServerResponse.TEXT_TPL = (data, isSuccess) => {
+    return data;
+};
+ServerResponse.JSON_TPL = (data, isSuccess) => {
+    if (isSuccess) {
+        return {
+            success: 'true',
+            data,
+        };
+    }
+    else {
+        return {
+            success: 'false',
+            message: data || 'fail',
+        };
+    }
+};
+ServerResponse.BLOB_TPL = (data, isSuccess) => {
+    return data;
+};
+//# sourceMappingURL=base.js.map

package/dist/response/http.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IMidwayContext, ServerSendEventMessage, ServerSendEventStreamOptions, ServerStreamOptions } from '../interface';
+import { ServerResponse } from './base';
+import { ServerSendEventStream } from './sse';
+import { Readable } from 'stream';
+import { HttpStreamResponse } from './stream';
+export declare class HttpServerResponse<CTX extends IMidwayContext> extends ServerResponse<CTX> {
+    constructor(ctx: CTX);
+    static FILE_TPL: (data: Readable, isSuccess: boolean) => Readable;
+    static SSE_TPL: (data: ServerSendEventMessage) => ServerSendEventMessage;
+    static STREAM_TPL: (data: unknown) => unknown;
+    status(code: number): this;
+    header(key: string, value: string): this;
+    headers(headers: Record<string, string>): this;
+    json(data: Record<any, any>): any;
+    text(data: string): any;
+    file(filePath: string, mimeType?: string): any;
+    blob(data: Buffer, mimeType?: string): any;
+    sse(options?: ServerSendEventStreamOptions): ServerSendEventStream;
+    stream(options?: ServerStreamOptions): HttpStreamResponse;
+}
+//# sourceMappingURL=http.d.ts.map

package/dist/response/http.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServerResponse = void 0;
+const fs_1 = require("fs");
+const base_1 = require("./base");
+const sse_1 = require("./sse");
+const stream_1 = require("./stream");
+const path_1 = require("path");
+class HttpServerResponse extends base_1.ServerResponse {
+    constructor(ctx) {
+        super(ctx);
+    }
+    status(code) {
+        this.ctx.res.statusCode = code;
+        return this;
+    }
+    header(key, value) {
+        this.ctx.res.setHeader(key, value);
+        return this;
+    }
+    headers(headers) {
+        if (this.ctx.res.setHeaders) {
+            this.ctx.res.setHeaders(new Map(Object.entries(headers)));
+        }
+        else {
+            for (const key in headers) {
+                this.header(key, headers[key]);
+            }
+        }
+        return this;
+    }
+    json(data) {
+        this.header('Content-Type', 'application/json');
+        return Object.getPrototypeOf(this).constructor.JSON_TPL(data, this.isSuccess);
+    }
+    text(data) {
+        this.header('Content-Type', 'text/plain');
+        return Object.getPrototypeOf(this).constructor.TEXT_TPL(data, this.isSuccess);
+    }
+    file(filePath, mimeType) {
+        this.header('Content-Type', mimeType || 'application/octet-stream');
+        this.header('Content-Disposition', `attachment; filename=${(0, path_1.basename)(filePath)}`);
+        return Object.getPrototypeOf(this).constructor.FILE_TPL(typeof filePath === 'string' ? (0, fs_1.createReadStream)(filePath) : filePath, this.isSuccess);
+    }
+    blob(data, mimeType) {
+        this.header('Content-Type', mimeType || 'application/octet-stream');
+        return Object.getPrototypeOf(this).constructor.BLOB_TPL(data, this.isSuccess);
+    }
+    sse(options = {}) {
+        return new sse_1.ServerSendEventStream(this.ctx, {
+            tpl: Object.getPrototypeOf(this).constructor.SSE_TPL,
+            ...options,
+        });
+    }
+    stream(options = {}) {
+        return new stream_1.HttpStreamResponse(this.ctx, {
+            tpl: Object.getPrototypeOf(this).constructor.STREAM_TPL,
+            ...options,
+        });
+    }
+}
+exports.HttpServerResponse = HttpServerResponse;
+HttpServerResponse.FILE_TPL = (data, isSuccess) => {
+    return data;
+};
+HttpServerResponse.SSE_TPL = (data) => {
+    return data;
+};
+HttpServerResponse.STREAM_TPL = (data) => {
+    return data;
+};
+//# sourceMappingURL=http.js.map

package/dist/response/index.d.ts

@@ -0,0 +1,3 @@
+export { ServerResponse } from './base';
+export { HttpServerResponse } from './http';
+//# sourceMappingURL=index.d.ts.map

package/dist/response/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServerResponse = exports.ServerResponse = void 0;
+var base_1 = require("./base");
+Object.defineProperty(exports, "ServerResponse", { enumerable: true, get: function () { return base_1.ServerResponse; } });
+var http_1 = require("./http");
+Object.defineProperty(exports, "HttpServerResponse", { enumerable: true, get: function () { return http_1.HttpServerResponse; } });
+//# sourceMappingURL=index.js.map

package/dist/response/sse.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { Transform } from 'stream';
+import { ServerSendEventStreamOptions } from '../interface';
+interface MessageEvent {
+    data?: string | object;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+export declare class ServerSendEventStream extends Transform {
+    private readonly ctx;
+    private isActive;
+    private readonly closeEvent;
+    private options;
+    constructor(ctx: any, options?: ServerSendEventStreamOptions);
+    _transform(chunk: any, encoding: any, callback: any): void;
+    sendError(error: Error): void;
+    sendEnd(message?: MessageEvent): void;
+    send(message: MessageEvent): void;
+    private handleClose;
+}
+export {};
+//# sourceMappingURL=sse.d.ts.map

package/dist/response/sse.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerSendEventStream = void 0;
+const stream_1 = require("stream");
+class ServerSendEventStream extends stream_1.Transform {
+    constructor(ctx, options = {}) {
+        super({
+            objectMode: true,
+            ...options,
+        });
+        this.isActive = false;
+        this.ctx = ctx;
+        this.closeEvent = options.closeEvent || 'close';
+        this.options = options;
+        // 监听客户端关闭连接
+        this.ctx.req.on('close', this.handleClose.bind(this));
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            let dataLines, prefix = 'data: ';
+            const commentReg = /^\s*:\s*/;
+            const res = [];
+            if (!this.isActive) {
+                this.isActive = true;
+                const defaultHeader = {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache, no-transform',
+                    Connection: 'keep-alive',
+                    'X-Accel-Buffering': 'no',
+                };
+                for (const key in defaultHeader) {
+                    this.ctx.res.setHeader(key, defaultHeader[key]);
+                }
+                this.ctx.req.socket.setTimeout(0);
+                this.ctx.req.socket.setNoDelay(true);
+                this.ctx.req.socket.setKeepAlive(true);
+                res.push({
+                    data: ':ok',
+                });
+            }
+            const senderObject = chunk;
+            if (senderObject.event)
+                res.push('event: ' + senderObject.event);
+            if (senderObject.retry)
+                res.push('retry: ' + senderObject.retry);
+            if (senderObject.id)
+                res.push('id: ' + senderObject.id);
+            if (typeof senderObject.data === 'object') {
+                dataLines = JSON.stringify(senderObject.data);
+                res.push(prefix + dataLines);
+            }
+            else if (typeof senderObject.data === 'undefined') {
+                // Send an empty string even without data
+                res.push(prefix);
+            }
+            else {
+                senderObject.data = String(senderObject.data);
+                if (senderObject.data.search(commentReg) !== -1) {
+                    senderObject.data = senderObject.data.replace(commentReg, '');
+                    prefix = ': ';
+                }
+                senderObject.data = senderObject.data.replace(/(\r\n|\r|\n)/g, '\n');
+                dataLines = senderObject.data.split(/\n/);
+                for (let i = 0, l = dataLines.length; i < l; ++i) {
+                    const line = dataLines[i];
+                    if (i + 1 === l) {
+                        res.push(prefix + line);
+                    }
+                    else {
+                        res.push(prefix + line);
+                    }
+                }
+            }
+            this.push(res.join('\n') + '\n\n');
+            callback();
+        }
+        catch (err) {
+            this.ctx.logger.error(err);
+            // send error to client
+            this.sendError(err);
+            // close stream
+            this.end();
+            // callback error
+            callback(err);
+        }
+    }
+    sendError(error) {
+        this.send({
+            event: 'error',
+            data: error.message || 'An error occurred',
+        });
+    }
+    sendEnd(message) {
+        message.event = this.closeEvent;
+        this.send(message);
+    }
+    send(message) {
+        super.write(this.options.tpl(message));
+    }
+    handleClose() {
+        this.end();
+    }
+}
+exports.ServerSendEventStream = ServerSendEventStream;
+//# sourceMappingURL=sse.js.map

package/dist/response/stream.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Transform } from 'stream';
+import { ServerStreamOptions } from '../interface';
+export declare class HttpStreamResponse extends Transform {
+    private ctx;
+    private isActive;
+    private options;
+    constructor(ctx: any, options?: ServerStreamOptions);
+    _transform(chunk: any, encoding: any, callback: any): void;
+    send(data: unknown): void;
+    sendError(error: any): void;
+    _flush(callback: any): void;
+}
+//# sourceMappingURL=stream.d.ts.map

package/dist/response/stream.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStreamResponse = void 0;
+const stream_1 = require("stream");
+class HttpStreamResponse extends stream_1.Transform {
+    constructor(ctx, options = {}) {
+        super({
+            objectMode: true,
+            ...options,
+        });
+        this.isActive = false;
+        this.ctx = ctx;
+        this.options = options;
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            if (!this.isActive) {
+                this.isActive = true;
+                this.ctx.res.statusCode = 200;
+                this.ctx.res.setHeader('Transfer-Encoding', 'chunked');
+                this.ctx.res.setHeader('Cache-Control', 'no-cache');
+                this.ctx.req.socket.setTimeout(0);
+            }
+            if (typeof chunk === 'string') {
+                this.ctx.res.write(chunk);
+            }
+            else {
+                this.ctx.res.write(JSON.stringify(chunk));
+            }
+            callback();
+        }
+        catch (err) {
+            this.ctx.logger.error(err);
+            // close stream
+            this.end();
+            this.ctx.res.end();
+            callback(err);
+        }
+    }
+    send(data) {
+        if (!this.writable) {
+            return;
+        }
+        this.write(this.options.tpl(data));
+    }
+    sendError(error) {
+        this.ctx.logger.error(error);
+        this.end();
+        this.ctx.res.end();
+    }
+    _flush(callback) {
+        this.ctx.res.end();
+        callback();
+    }
+}
+exports.HttpStreamResponse = HttpStreamResponse;
+//# sourceMappingURL=stream.js.map

package/dist/service/middlewareService.js

@@ -22,33 +22,37 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
         this.applicationContext = applicationContext;
     }
     async compose(middleware, app, name) {
+        var _a;
         if (!Array.isArray(middleware)) {
             throw new error_1.MidwayParameterError('Middleware stack must be an array');
         }
         const newMiddlewareArr = [];
         for (let fn of middleware) {
-            if (types_1.Types.isClass(fn) || typeof fn === 'string') {
-                if (typeof fn === 'string' &&
-                    !this.applicationContext.hasDefinition(fn)) {
-                    throw new error_1.MidwayCommonError(`Middleware definition of "${fn}" not found in midway container`);
+            if (types_1.Types.isClass(fn) || typeof fn === 'string' || (fn === null || fn === void 0 ? void 0 : fn['middleware'])) {
+                let mw = (_a = fn === null || fn === void 0 ? void 0 : fn['middleware']) !== null && _a !== void 0 ? _a : fn;
+                const mwConfig = fn === null || fn === void 0 ? void 0 : fn['options'];
+                let mwName = fn === null || fn === void 0 ? void 0 : fn['name'];
+                if (typeof mw === 'string' &&
+                    !this.applicationContext.hasDefinition(mw)) {
+                    throw new error_1.MidwayCommonError(`Middleware definition of "${mw}" not found in midway container`);
                 }
-                const classMiddleware = await this.applicationContext.getAsync(fn);
+                const classMiddleware = await this.applicationContext.getAsync(mw);
                 if (classMiddleware) {
-                    fn = await classMiddleware.resolve(app);
-                    if (!fn) {
+                    mwName = mwName !== null && mwName !== void 0 ? mwName : classMiddleware.constructor.name;
+                    mw = await classMiddleware.resolve(app, mwConfig);
+                    if (!mw) {
                         // for middleware enabled
                         continue;
                     }
                     if (!classMiddleware.match && !classMiddleware.ignore) {
-                        if (!fn.name) {
-                            fn._name = classMiddleware.constructor.name;
+                        if (!mw.name) {
+                            mw._name = mwName;
                         }
                         // just got fn
-                        newMiddlewareArr.push(fn);
+                        newMiddlewareArr.push(mw);
                     }
                     else {
                         // wrap ignore and match
-                        const mw = fn;
                         const match = (0, util_1.pathMatching)({
                             match: classMiddleware.match,
                             ignore: classMiddleware.ignore,
@@ -59,7 +63,7 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                                 return next();
                             return mw(ctx, next, options);
                         };
-                        fn._name = classMiddleware.constructor.name;
+                        fn._name = mwName;
                         newMiddlewareArr.push(fn);
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.16.2",
+  "version": "3.17.0",
   "description": "midway core",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -23,6 +23,7 @@
   "license": "MIT",
   "devDependencies": {
     "@midwayjs/logger": "^3.0.0",
+    "eventsource": "2.0.2",
     "koa": "2.15.3",
     "mm": "3.4.0",
     "raw-body": "2.5.2",
@@ -42,5 +43,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "45af90c8055ed62b4a0e811d3b5ce42a796b6d65"
+  "gitHead": "21faf25ae7277f28d61f8416d1acd5a786a2c353"
 }