@midwayjs/core 3.0.0-beta.12 → 3.0.0-beta.16

package/dist/common/dataListener.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class DataListener<T> {
+    private innerData;
+    protected init(): Promise<void>;
+    abstract initData(): T;
+    abstract onData(callback: (data: T) => void): any;
+    protected setData(data: T): void;
+    getData(): T;
+    stop(): Promise<void>;
+    protected destroyListener(): Promise<void>;
+}
+//# sourceMappingURL=dataListener.d.ts.map

package/dist/common/dataListener.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataListener = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+class DataListener {
+    async init() {
+        this.innerData = await this.initData();
+        await this.onData(this.setData.bind(this));
+    }
+    setData(data) {
+        this.innerData = data;
+    }
+    getData() {
+        return this.innerData;
+    }
+    async stop() {
+        await this.destroyListener();
+    }
+    async destroyListener() { }
+}
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DataListener.prototype, "init", null);
+__decorate([
+    (0, decorator_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DataListener.prototype, "stop", null);
+exports.DataListener = DataListener;
+//# sourceMappingURL=dataListener.js.map

package/dist/common/fileDetector.js

@@ -47,7 +47,7 @@ class DirectoryFileDetector extends AbstractFileDetector {
                                 continue;
                             }
                         }
-                        else if ((0, decorator_1.isRegExp)(resolveFilter.pattern)) {
+                        else if (decorator_1.TYPES.isRegExp(resolveFilter.pattern)) {
                             if (resolveFilter.pattern.test(file)) {
                                 const exports = resolveFilter.ignoreRequire
                                     ? undefined

package/dist/common/webRouterCollector.js

@@ -232,7 +232,7 @@ class WebRouterCollector {
         return urlMatchList
             .map(item => {
             const urlString = item.url.toString();
-            const weightArr = (0, decorator_1.isRegExp)(item.url)
+            const weightArr = decorator_1.TYPES.isRegExp(item.url)
                 ? urlString.split('\\/')
                 : urlString.split('/');
             let weight = 0;

package/dist/context/container.js

@@ -144,16 +144,16 @@ class ContainerConfiguration {
     }
     getConfigurationExport(exports) {
         const mods = [];
-        if ((0, decorator_1.isClass)(exports) ||
-            (0, decorator_1.isFunction)(exports) ||
+        if (decorator_1.TYPES.isClass(exports) ||
+            decorator_1.TYPES.isFunction(exports) ||
             exports instanceof configuration_1.FunctionalConfiguration) {
             mods.push(exports);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
-                if ((0, decorator_1.isClass)(module) ||
-                    (0, decorator_1.isFunction)(module) ||
+                if (decorator_1.TYPES.isClass(module) ||
+                    decorator_1.TYPES.isFunction(module) ||
                     module instanceof configuration_1.FunctionalConfiguration) {
                     mods.push(module);
                 }
@@ -240,13 +240,13 @@ class MidwayContainer {
         (_a = this.fileDetector) === null || _a === void 0 ? void 0 : _a.run(this);
     }
     bindClass(exports, options) {
-        if ((0, decorator_1.isClass)(exports) || (0, decorator_1.isFunction)(exports)) {
+        if (decorator_1.TYPES.isClass(exports) || decorator_1.TYPES.isFunction(exports)) {
             this.bindModule(exports, options);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
-                if ((0, decorator_1.isClass)(module) || (0, decorator_1.isFunction)(module)) {
+                if (decorator_1.TYPES.isClass(module) || decorator_1.TYPES.isFunction(module)) {
                     this.bindModule(module, options);
                 }
             }
@@ -254,7 +254,7 @@ class MidwayContainer {
     }
     bind(identifier, target, options) {
         var _a;
-        if ((0, decorator_1.isClass)(identifier) || (0, decorator_1.isFunction)(identifier)) {
+        if (decorator_1.TYPES.isClass(identifier) || decorator_1.TYPES.isFunction(identifier)) {
             return this.bindModule(identifier, target);
         }
         if (this.registry.hasDefinition(identifier)) {
@@ -262,13 +262,13 @@ class MidwayContainer {
             return;
         }
         let definition;
-        if ((0, decorator_1.isClass)(target)) {
+        if (decorator_1.TYPES.isClass(target)) {
             definition = new objectDefinition_1.ObjectDefinition();
             definition.name = (0, decorator_1.getProviderName)(target);
         }
         else {
             definition = new functionDefinition_1.FunctionDefinition();
-            if (!(0, decorator_1.isAsyncFunction)(target)) {
+            if (!decorator_1.TYPES.isAsyncFunction(target)) {
                 definition.asynchronous = false;
             }
             definition.name = definition.id;
@@ -327,7 +327,7 @@ class MidwayContainer {
         }
     }
     bindModule(module, options) {
-        if ((0, decorator_1.isClass)(module)) {
+        if (decorator_1.TYPES.isClass(module)) {
             const providerId = (0, decorator_1.getProviderUUId)(module);
             if (providerId) {
                 this.identifierMapping.saveClassRelation(module, options === null || options === void 0 ? void 0 : options.namespace);

package/dist/context/requestContainer.js

@@ -13,6 +13,8 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
         this.ctx = ctx;
         // register ctx
         this.registerObject(interface_1.REQUEST_CTX_KEY, ctx);
+        // register res
+        this.registerObject('res', {});
         if (ctx.logger) {
             // register contextLogger
             this.registerObject('logger', ctx.logger);

package/dist/definitions/objectCreator.js

@@ -65,7 +65,7 @@ class ObjectCreator {
         let inst;
         if (this.definition.constructMethod) {
             const fn = Clzz[this.definition.constructMethod];
-            if ((0, decorator_1.isAsyncFunction)(fn)) {
+            if (decorator_1.TYPES.isAsyncFunction(fn)) {
                 inst = await fn.apply(Clzz, args);
             }
             else {
@@ -86,13 +86,13 @@ class ObjectCreator {
         const inst = obj;
         // after properties set then do init
         if (this.definition.initMethod && inst[this.definition.initMethod]) {
-            if ((0, decorator_1.isGeneratorFunction)(inst[this.definition.initMethod]) ||
-                (0, decorator_1.isAsyncFunction)(inst[this.definition.initMethod])) {
+            if (decorator_1.TYPES.isGeneratorFunction(inst[this.definition.initMethod]) ||
+                decorator_1.TYPES.isAsyncFunction(inst[this.definition.initMethod])) {
                 throw new error_1.MidwayUseWrongMethodError('context.get', 'context.getAsync', this.definition.id);
             }
             else {
                 const rt = inst[this.definition.initMethod].call(inst);
-                if ((0, decorator_1.isPromise)(rt)) {
+                if (decorator_1.TYPES.isPromise(rt)) {
                     throw new error_1.MidwayUseWrongMethodError('context.get', 'context.getAsync', this.definition.id);
                 }
             }
@@ -107,7 +107,7 @@ class ObjectCreator {
         const inst = obj;
         if (this.definition.initMethod && inst[this.definition.initMethod]) {
             const initFn = inst[this.definition.initMethod];
-            if ((0, decorator_1.isAsyncFunction)(initFn)) {
+            if (decorator_1.TYPES.isAsyncFunction(initFn)) {
                 await initFn.call(inst);
             }
             else {
@@ -140,7 +140,7 @@ class ObjectCreator {
     async doDestroyAsync(obj) {
         if (this.definition.destroyMethod && obj[this.definition.destroyMethod]) {
             const fn = obj[this.definition.destroyMethod];
-            if ((0, decorator_1.isAsyncFunction)(fn)) {
+            if (decorator_1.TYPES.isAsyncFunction(fn)) {
                 await fn.call(obj);
             }
             else {

package/dist/error/http.d.ts

@@ -49,53 +49,98 @@ export declare enum HttpStatus {
     GATEWAY_TIMEOUT = 504,
     HTTP_VERSION_NOT_SUPPORTED = 505
 }
+/**
+ * 400 http error, Means that the request can be fulfilled because of the bad syntax.
+ */
 export declare class BadRequestError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 401 http error, Means that the request was legal, but the server is rejecting to answer it. For the use when authentication is required and has failed or has not yet been provided.
+ */
 export declare class UnauthorizedError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 	4o4 http error, Means that the requested page cannot be found at the moment, but it may be available again in the future.
+ */
 export declare class NotFoundError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 403 http error, Means that the request is legal, but the server is rejecting to answer it.
+ */
 export declare class ForbiddenError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 406 http error, Means that the server can only generate an answer which the client doesn't accept.
+ */
 export declare class NotAcceptableError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 408 http error, Means that the server timed out waiting for the request.
+ */
 export declare class RequestTimeoutError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 409 http error, Means that the request cannot be completed, because of a conflict in the request.
+ */
 export declare class ConflictError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 410 http error, Means that the requested page is not available anymore.
+ */
 export declare class GoneError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 413 http error, Means that the request entity is too large and that's why the server won't accept the request.
+ */
 export declare class PayloadTooLargeError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 415 http error, Means that the media type is not supported and that's why the server won't accept the request.
+ */
 export declare class UnsupportedMediaTypeError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
-export declare class UnprocessableError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+export declare class UnprocessableEntityError extends MidwayHttpError {
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 500 http error, Is a generic error and users receive this error message when there is no more suitable specific message.
+ */
 export declare class InternalServerErrorError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
-declare class NotImplementedError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+/**
+ * 501 http error, Means that the server doesn't recognize the request method or it lacks the ability to fulfill the request.
+ */
+export declare class NotImplementedError extends MidwayHttpError {
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 502 http error, Means that the server was acting as a gateway or proxy and it received an invalid answer from the upstream server.
+ */
 export declare class BadGatewayError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 503 http error, Means that the server is not available now (It may be overloaded or down).
+ */
 export declare class ServiceUnavailableError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
+/**
+ * 504 http error, Means that the server was acting as a gateway or proxy and it didn't get answer on time from the upstream server.
+ */
 export declare class GatewayTimeoutError extends MidwayHttpError {
-    constructor(resOrMessage: ResOrMessage);
+    constructor(resOrMessage?: ResOrMessage);
 }
 export declare const httpError: {
     BadRequestError: typeof BadRequestError;
@@ -108,12 +153,11 @@ export declare const httpError: {
     GoneError: typeof GoneError;
     PayloadTooLargeError: typeof PayloadTooLargeError;
     UnsupportedMediaTypeError: typeof UnsupportedMediaTypeError;
-    UnprocessableError: typeof UnprocessableError;
+    UnprocessableEntityError: typeof UnprocessableEntityError;
     InternalServerErrorError: typeof InternalServerErrorError;
     NotImplementedError: typeof NotImplementedError;
     BadGatewayError: typeof BadGatewayError;
     ServiceUnavailableError: typeof ServiceUnavailableError;
     GatewayTimeoutError: typeof GatewayTimeoutError;
 };
-export {};
 //# sourceMappingURL=http.d.ts.map

package/dist/error/http.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpError = exports.GatewayTimeoutError = exports.ServiceUnavailableError = exports.BadGatewayError = exports.InternalServerErrorError = exports.UnprocessableError = exports.UnsupportedMediaTypeError = exports.PayloadTooLargeError = exports.GoneError = exports.ConflictError = exports.RequestTimeoutError = exports.NotAcceptableError = exports.ForbiddenError = exports.NotFoundError = exports.UnauthorizedError = exports.BadRequestError = exports.HttpStatus = void 0;
+exports.httpError = exports.GatewayTimeoutError = exports.ServiceUnavailableError = exports.BadGatewayError = exports.NotImplementedError = exports.InternalServerErrorError = exports.UnprocessableEntityError = exports.UnsupportedMediaTypeError = exports.PayloadTooLargeError = exports.GoneError = exports.ConflictError = exports.RequestTimeoutError = exports.NotAcceptableError = exports.ForbiddenError = exports.NotFoundError = exports.UnauthorizedError = exports.BadRequestError = exports.HttpStatus = void 0;
 const base_1 = require("./base");
 var HttpStatus;
 (function (HttpStatus) {
@@ -53,97 +53,143 @@ var HttpStatus;
     HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
     HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
 })(HttpStatus = exports.HttpStatus || (exports.HttpStatus = {}));
+/**
+ * 400 http error, Means that the request can be fulfilled because of the bad syntax.
+ */
 class BadRequestError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Bad Request') {
         super(resOrMessage, HttpStatus.BAD_REQUEST);
     }
 }
 exports.BadRequestError = BadRequestError;
+/**
+ * 401 http error, Means that the request was legal, but the server is rejecting to answer it. For the use when authentication is required and has failed or has not yet been provided.
+ */
 class UnauthorizedError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Unauthorized') {
         super(resOrMessage, HttpStatus.UNAUTHORIZED);
     }
 }
 exports.UnauthorizedError = UnauthorizedError;
+/**
+ * 	4o4 http error, Means that the requested page cannot be found at the moment, but it may be available again in the future.
+ */
 class NotFoundError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Not Found') {
         super(resOrMessage, HttpStatus.NOT_FOUND);
     }
 }
 exports.NotFoundError = NotFoundError;
+/**
+ * 403 http error, Means that the request is legal, but the server is rejecting to answer it.
+ */
 class ForbiddenError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Forbidden') {
         super(resOrMessage, HttpStatus.FORBIDDEN);
     }
 }
 exports.ForbiddenError = ForbiddenError;
+/**
+ * 406 http error, Means that the server can only generate an answer which the client doesn't accept.
+ */
 class NotAcceptableError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Not Acceptable') {
         super(resOrMessage, HttpStatus.NOT_ACCEPTABLE);
     }
 }
 exports.NotAcceptableError = NotAcceptableError;
+/**
+ * 408 http error, Means that the server timed out waiting for the request.
+ */
 class RequestTimeoutError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Request Timeout') {
         super(resOrMessage, HttpStatus.REQUEST_TIMEOUT);
     }
 }
 exports.RequestTimeoutError = RequestTimeoutError;
+/**
+ * 409 http error, Means that the request cannot be completed, because of a conflict in the request.
+ */
 class ConflictError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Conflict') {
         super(resOrMessage, HttpStatus.CONFLICT);
     }
 }
 exports.ConflictError = ConflictError;
+/**
+ * 410 http error, Means that the requested page is not available anymore.
+ */
 class GoneError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Gone') {
         super(resOrMessage, HttpStatus.GONE);
     }
 }
 exports.GoneError = GoneError;
+/**
+ * 413 http error, Means that the request entity is too large and that's why the server won't accept the request.
+ */
 class PayloadTooLargeError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Request Entity Too Large') {
         super(resOrMessage, HttpStatus.PAYLOAD_TOO_LARGE);
     }
 }
 exports.PayloadTooLargeError = PayloadTooLargeError;
+/**
+ * 415 http error, Means that the media type is not supported and that's why the server won't accept the request.
+ */
 class UnsupportedMediaTypeError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Unsupported Media Type') {
         super(resOrMessage, HttpStatus.UNSUPPORTED_MEDIA_TYPE);
     }
 }
 exports.UnsupportedMediaTypeError = UnsupportedMediaTypeError;
-class UnprocessableError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+class UnprocessableEntityError extends base_1.MidwayHttpError {
+    constructor(resOrMessage = 'Unprocessable Entity') {
         super(resOrMessage, HttpStatus.UNPROCESSABLE_ENTITY);
     }
 }
-exports.UnprocessableError = UnprocessableError;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+/**
+ * 500 http error, Is a generic error and users receive this error message when there is no more suitable specific message.
+ */
 class InternalServerErrorError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Internal Server Error') {
         super(resOrMessage, HttpStatus.INTERNAL_SERVER_ERROR);
     }
 }
 exports.InternalServerErrorError = InternalServerErrorError;
+/**
+ * 501 http error, Means that the server doesn't recognize the request method or it lacks the ability to fulfill the request.
+ */
 class NotImplementedError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Not Implemented') {
         super(resOrMessage, HttpStatus.NOT_IMPLEMENTED);
     }
 }
+exports.NotImplementedError = NotImplementedError;
+/**
+ * 502 http error, Means that the server was acting as a gateway or proxy and it received an invalid answer from the upstream server.
+ */
 class BadGatewayError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Bad Gateway') {
         super(resOrMessage, HttpStatus.BAD_GATEWAY);
     }
 }
 exports.BadGatewayError = BadGatewayError;
+/**
+ * 503 http error, Means that the server is not available now (It may be overloaded or down).
+ */
 class ServiceUnavailableError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Service Unavailable') {
         super(resOrMessage, HttpStatus.SERVICE_UNAVAILABLE);
     }
 }
 exports.ServiceUnavailableError = ServiceUnavailableError;
+/**
+ * 504 http error, Means that the server was acting as a gateway or proxy and it didn't get answer on time from the upstream server.
+ */
 class GatewayTimeoutError extends base_1.MidwayHttpError {
-    constructor(resOrMessage) {
+    constructor(resOrMessage = 'Gateway Timeout') {
         super(resOrMessage, HttpStatus.GATEWAY_TIMEOUT);
     }
 }
@@ -159,7 +205,7 @@ exports.httpError = {
     GoneError,
     PayloadTooLargeError,
     UnsupportedMediaTypeError,
-    UnprocessableError,
+    UnprocessableEntityError,
     InternalServerErrorError,
     NotImplementedError,
     BadGatewayError,

package/dist/error/index.d.ts

@@ -1,4 +1,4 @@
 export * from './base';
-export * from './http';
+export { HttpStatus, httpError } from './http';
 export * from './framework';
 //# sourceMappingURL=index.d.ts.map

package/dist/error/index.js

@@ -10,7 +10,10 @@ 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.httpError = exports.HttpStatus = void 0;
 __exportStar(require("./base"), exports);
-__exportStar(require("./http"), exports);
+var http_1 = require("./http");
+Object.defineProperty(exports, "HttpStatus", { enumerable: true, get: function () { return http_1.HttpStatus; } });
+Object.defineProperty(exports, "httpError", { enumerable: true, get: function () { return http_1.httpError; } });
 __exportStar(require("./framework"), exports);
 //# sourceMappingURL=index.js.map

package/dist/functional/configuration.d.ts

@@ -4,10 +4,12 @@ export declare class FunctionalConfiguration {
     private readyHandler;
     private stopHandler;
     private configLoadHandler;
+    private serverReadyHandler;
     private options;
     constructor(options: InjectionConfigurationOptions);
     onConfigLoad(configLoadHandler: ((container: IMidwayContainer, app: IMidwayApplication) => any) | IMidwayContainer, app?: IMidwayApplication): any;
     onReady(readyHandler: ((container: IMidwayContainer, app: IMidwayApplication) => void) | IMidwayContainer, app?: IMidwayApplication): any;
+    onServerReady(serverReadyHandler: ((container: IMidwayContainer, app: IMidwayApplication) => void) | IMidwayContainer, app?: IMidwayApplication): any;
     onStop(stopHandler: ((container: IMidwayContainer, app: IMidwayApplication) => void) | IMidwayContainer, app?: IMidwayApplication): any;
     getConfigurationOptions(): InjectionConfigurationOptions;
 }

package/dist/functional/configuration.js

@@ -7,6 +7,7 @@ class FunctionalConfiguration {
         this.readyHandler = () => { };
         this.stopHandler = () => { };
         this.configLoadHandler = () => { };
+        this.serverReadyHandler = () => { };
     }
     onConfigLoad(configLoadHandler, app) {
         if (typeof configLoadHandler === 'function') {
@@ -26,6 +27,15 @@ class FunctionalConfiguration {
         }
         return this;
     }
+    onServerReady(serverReadyHandler, app) {
+        if (typeof serverReadyHandler === 'function') {
+            this.serverReadyHandler = serverReadyHandler;
+        }
+        else {
+            return this.serverReadyHandler(serverReadyHandler, app);
+        }
+        return this;
+    }
     onStop(stopHandler, app) {
         if (typeof stopHandler === 'function') {
             this.stopHandler = stopHandler;

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export { MidwayDecoratorService } from './service/decoratorService';
 export * from './service/pipelineService';
 export * from './util/contextUtil';
 export * from './common/serviceFactory';
+export * from './common/dataListener';
 export * from './common/fileDetector';
 export * from './common/webGenerator';
 export * from './common/middlewareManager';

package/dist/index.js

@@ -56,6 +56,7 @@ Object.defineProperty(exports, "MidwayDecoratorService", { enumerable: true, get
 __exportStar(require("./service/pipelineService"), exports);
 __exportStar(require("./util/contextUtil"), exports);
 __exportStar(require("./common/serviceFactory"), exports);
+__exportStar(require("./common/dataListener"), exports);
 __exportStar(require("./common/fileDetector"), exports);
 __exportStar(require("./common/webGenerator"), exports);
 __exportStar(require("./common/middlewareManager"), exports);

package/dist/interface.d.ts

@@ -14,9 +14,19 @@ export declare type ServiceFactoryConfigOption<OPTIONS> = {
         [key: string]: PowerPartial<OPTIONS>;
     };
 };
-declare type ConfigType<T> = T extends (...args: any[]) => any ? PowerPartial<ReturnType<T>> : PowerPartial<T>;
+declare 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>;
 /**
+ * Make object property writeable
+ */
+export declare type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * Lifecycle Definition
  * 生命周期定义
  */
 export interface ILifeCycle extends Partial<IObjectLifeCycle> {
@@ -29,8 +39,8 @@ export declare type ObjectContext = {
     originName?: string;
 };
 /**
+ * Abstract Object Factory
  * 对象容器抽象
- * 默认用Xml容器实现一个
  */
 export interface IObjectFactory {
     registry: IObjectDefinitionRegistry;
@@ -46,6 +56,10 @@ export declare enum ObjectLifeCycleEvent {
     AFTER_INIT = "afterObjectInit",
     BEFORE_DESTROY = "beforeObjectDestroy"
 }
+/**
+ * Object Lifecycle
+ * 对象生命周期
+ */
 export interface IObjectLifeCycle {
     onBeforeBind(fn: (Clzz: any, options: {
         context: IMidwayContainer;
@@ -72,6 +86,7 @@ export interface IObjectLifeCycle {
     }) => void): any;
 }
 /**
+ * Object Definition
  * 对象描述定义
  */
 export interface IObjectDefinition {
@@ -123,6 +138,7 @@ export interface IObjectCreator {
     doDestroyAsync(obj: any): Promise<void>;
 }
 /**
+ * Object Definition Registry
  * 对象定义存储容器
  */
 export interface IObjectDefinitionRegistry {
@@ -452,10 +468,5 @@ export interface MidwayAppInfo {
 export interface MidwayConfig extends FileConfigOption<typeof _default> {
     [customConfigKey: string]: unknown;
 }
-export interface TranslateOptions {
-    lang?: string;
-    group?: string;
-    args?: any;
-}
 export {};
 //# sourceMappingURL=interface.d.ts.map