@midwayjs/core 3.0.0-beta.6 → 3.0.0

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,32 +56,36 @@ export declare enum ObjectLifeCycleEvent {
     AFTER_INIT = "afterObjectInit",
     BEFORE_DESTROY = "beforeObjectDestroy"
 }
+interface ObjectLifeCycleOptions {
+    context: IMidwayContainer;
+    definition: IObjectDefinition;
+}
+export interface ObjectBeforeBindOptions extends ObjectLifeCycleOptions {
+    replaceCallback: (newDefinition: IObjectDefinition) => void;
+}
+export interface ObjectBeforeCreatedOptions extends ObjectLifeCycleOptions {
+    constructorArgs: any[];
+}
+export interface ObjectCreatedOptions<T> extends ObjectLifeCycleOptions {
+    replaceCallback: (ins: T) => void;
+}
+export interface ObjectInitOptions extends ObjectLifeCycleOptions {
+}
+export interface ObjectBeforeDestroyOptions extends ObjectLifeCycleOptions {
+}
+/**
+ * Object Lifecycle
+ * 对象生命周期
+ */
 export interface IObjectLifeCycle {
-    onBeforeBind(fn: (Clzz: any, options: {
-        context: IMidwayContainer;
-        definition: IObjectDefinition;
-        replaceCallback: (newDefinition: IObjectDefinition) => void;
-    }) => void): any;
-    onBeforeObjectCreated(fn: (Clzz: any, options: {
-        context: IMidwayContainer;
-        definition: IObjectDefinition;
-        constructorArgs: any[];
-    }) => void): any;
-    onObjectCreated<T>(fn: (ins: T, options: {
-        context: IMidwayContainer;
-        definition: IObjectDefinition;
-        replaceCallback: (ins: T) => void;
-    }) => void): any;
-    onObjectInit<T>(fn: (ins: T, options: {
-        context: IMidwayContainer;
-        definition: IObjectDefinition;
-    }) => void): any;
-    onBeforeObjectDestroy<T>(fn: (ins: T, options: {
-        context: IMidwayContainer;
-        definition: IObjectDefinition;
-    }) => void): any;
+    onBeforeBind(fn: (Clzz: any, options: ObjectBeforeBindOptions) => void): any;
+    onBeforeObjectCreated(fn: (Clzz: any, options: ObjectBeforeCreatedOptions) => void): any;
+    onObjectCreated<T>(fn: (ins: T, options: ObjectCreatedOptions<T>) => void): any;
+    onObjectInit<T>(fn: (ins: T, options: ObjectInitOptions) => void): any;
+    onBeforeObjectDestroy<T>(fn: (ins: T, options: ObjectBeforeDestroyOptions) => void): any;
 }
 /**
+ * Object Definition
  * 对象描述定义
  */
 export interface IObjectDefinition {
@@ -112,6 +126,7 @@ export interface IObjectDefinition {
         metadata: any;
     }>;
     createFrom: 'framework' | 'file' | 'module';
+    allowDowngrade: boolean;
 }
 export interface IObjectCreator {
     load(): any;
@@ -123,6 +138,7 @@ export interface IObjectCreator {
     doDestroyAsync(obj: any): Promise<void>;
 }
 /**
+ * Object Definition Registry
  * 对象定义存储容器
  */
 export interface IObjectDefinitionRegistry {
@@ -279,7 +295,7 @@ export declare type NextFunction = () => Promise<any>;
  * Common middleware definition
  */
 export interface IMiddleware<CTX, R, N = unknown> {
-    resolve: () => FunctionMiddleware<CTX, R, N>;
+    resolve: (app?: IMidwayApplication) => FunctionMiddleware<CTX, R, N> | Promise<FunctionMiddleware<CTX, R, N>>;
     match?: (ctx?: CTX) => boolean;
     ignore?: (ctx?: CTX) => boolean;
 }
@@ -396,13 +412,17 @@ export interface IMidwayBootstrapOptions {
     appDir?: string;
     applicationContext?: IMidwayContainer;
     preloadModules?: any[];
+    /**
+     * @deprecated please use 'imports'
+     */
     configurationModule?: any | any[];
+    imports?: any | any[];
     moduleDetector?: 'file' | IFileDetector | false;
     logger?: boolean | ILogger;
     ignore?: string[];
-    globalConfig?: {
+    globalConfig?: Array<{
         [environmentName: string]: Record<string, any>;
-    };
+    }> | Record<string, any>;
 }
 export interface IConfigurationOptions {
     logger?: ILogger;
@@ -432,7 +452,8 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     getProjectName(): string;
     getDefaultContextLoggerClass(): any;
     useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
-    getMiddleware(lastMiddleware?: CommonMiddleware<CTX, ResOrNext, Next>): Promise<MiddlewareRespond<CTX, ResOrNext, Next>>;
+    getMiddleware(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
+    applyMiddleware(lastMiddleware?: CommonMiddleware<CTX, ResOrNext, Next>): Promise<MiddlewareRespond<CTX, ResOrNext, Next>>;
     useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>): any;
 }
 export declare const MIDWAY_LOGGER_WRITEABLE_DIR = "MIDWAY_LOGGER_WRITEABLE_DIR";
@@ -449,6 +470,7 @@ export interface MidwayAppInfo {
  * midway global config definition
  */
 export interface MidwayConfig extends FileConfigOption<typeof _default> {
+    [customConfigKey: string]: unknown;
 }
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/service/aspectService.js

@@ -64,7 +64,7 @@ let MidwayAspectService = class MidwayAspectService {
      */
     interceptPrototypeMethod(Clz, methodName, aspectObject) {
         const originMethod = Clz.prototype[methodName];
-        if ((0, decorator_1.isAsyncFunction)(Clz.prototype[methodName])) {
+        if (decorator_1.Types.isAsyncFunction(Clz.prototype[methodName])) {
             Clz.prototype[methodName] = async function (...args) {
                 var _a, _b, _c;
                 let error, result;

package/dist/service/configService.d.ts

@@ -1,4 +1,4 @@
-import { IConfigService } from '../interface';
+import { IConfigService, MidwayAppInfo } from '../interface';
 import { MidwayEnvironmentService } from './environmentService';
 import { MidwayInformationService } from './informationService';
 export declare class MidwayConfigService implements IConfigService {
@@ -7,8 +7,10 @@ export declare class MidwayConfigService implements IConfigService {
     protected configuration: any;
     protected isReady: boolean;
     protected externalObject: Record<string, unknown>[];
+    protected appInfo: MidwayAppInfo;
     protected environmentService: MidwayEnvironmentService;
     protected informationService: MidwayInformationService;
+    protected init(): Promise<void>;
     add(configFilePaths: any[]): void;
     addObject(obj: Record<string, unknown>): void;
     private getEnvSet;

package/dist/service/configService.js

@@ -10,7 +10,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayConfigService = void 0;
-const extend = require("extend2");
 const path_1 = require("path");
 const util_1 = require("../util");
 const fs_1 = require("fs");
@@ -18,6 +17,7 @@ const decorator_1 = require("@midwayjs/decorator");
 const util = require("util");
 const environmentService_1 = require("./environmentService");
 const informationService_1 = require("./informationService");
+const extend_1 = require("../util/extend");
 const debug = util.debuglog('midway:debug');
 let MidwayConfigService = class MidwayConfigService {
     constructor() {
@@ -29,6 +29,17 @@ let MidwayConfigService = class MidwayConfigService {
         this.isReady = false;
         this.externalObject = [];
     }
+    async init() {
+        this.appInfo = {
+            pkg: this.informationService.getPkg(),
+            name: this.informationService.getProjectName(),
+            baseDir: this.informationService.getBaseDir(),
+            appDir: this.informationService.getAppDir(),
+            HOME: this.informationService.getHome(),
+            root: this.informationService.getRoot(),
+            env: this.environmentService.getCurrentEnvironment(),
+        };
+    }
     add(configFilePaths) {
         for (const dir of configFilePaths) {
             if (typeof dir === 'string') {
@@ -63,7 +74,7 @@ let MidwayConfigService = class MidwayConfigService {
     }
     addObject(obj) {
         if (this.isReady) {
-            extend(true, this.configuration, obj);
+            (0, extend_1.extend)(true, this.configuration, obj);
         }
         else {
             this.externalObject.push(obj);
@@ -96,20 +107,9 @@ let MidwayConfigService = class MidwayConfigService {
         const target = {};
         for (const filename of [...defaultSet, ...currentEnvSet]) {
             let config = await this.loadConfig(filename);
-            if ((0, decorator_1.isFunction)(config)) {
+            if (decorator_1.Types.isFunction(config)) {
                 // eslint-disable-next-line prefer-spread
-                config = config.apply(null, [
-                    {
-                        pkg: this.informationService.getPkg(),
-                        name: this.informationService.getProjectName(),
-                        baseDir: this.informationService.getBaseDir(),
-                        appDir: this.informationService.getAppDir(),
-                        HOME: this.informationService.getHome(),
-                        root: this.informationService.getRoot(),
-                        env: this.environmentService.getCurrentEnvironment(),
-                    },
-                    target,
-                ]);
+                config = config.apply(null, [this.appInfo, target]);
             }
             if (!config) {
                 continue;
@@ -120,13 +120,13 @@ let MidwayConfigService = class MidwayConfigService {
             else {
                 debug('[config]: Loaded config %j', config);
             }
-            extend(true, target, config);
+            (0, extend_1.extend)(true, target, config);
         }
         if (this.externalObject.length) {
             for (const externalObject of this.externalObject) {
                 if (externalObject) {
                     debug('[config]: Loaded external object %j', externalObject);
-                    extend(true, target, externalObject);
+                    (0, extend_1.extend)(true, target, externalObject);
                 }
             }
         }
@@ -160,6 +160,12 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", informationService_1.MidwayInformationService)
 ], MidwayConfigService.prototype, "informationService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayConfigService.prototype, "init", null);
 MidwayConfigService = __decorate([
     (0, decorator_1.Provide)(),
     (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)

package/dist/service/decoratorService.js

@@ -30,7 +30,10 @@ let MidwayDecoratorService = class MidwayDecoratorService {
             if (methodDecoratorMetadataList) {
                 // loop it, save this order for decorator run
                 for (const meta of methodDecoratorMetadataList) {
-                    const { propertyName, key, metadata } = meta;
+                    const { propertyName, key, metadata, impl } = meta;
+                    if (!impl) {
+                        continue;
+                    }
                     // add aspect implementation first
                     this.aspectService.interceptPrototypeMethod(Clzz, propertyName, () => {
                         const methodDecoratorHandler = this.methodDecoratorMap.get(key);
@@ -57,7 +60,10 @@ let MidwayDecoratorService = class MidwayDecoratorService {
                                 // joinPoint.args
                                 const newArgs = [...joinPoint.args];
                                 for (const meta of parameterDecoratorMetadata[methodName]) {
-                                    const { propertyName, key, metadata, parameterIndex } = meta;
+                                    const { propertyName, key, metadata, parameterIndex, impl } = meta;
+                                    if (!impl) {
+                                        continue;
+                                    }
                                     const parameterDecoratorHandler = this.parameterDecoratorMap.get(key);
                                     if (!parameterDecoratorHandler) {
                                         throw new error_1.MidwayCommonError(`Parameter Decorator "${key}" handler not found, please register first.`);
@@ -95,15 +101,15 @@ let MidwayDecoratorService = class MidwayDecoratorService {
         });
     }
     registerPropertyHandler(decoratorKey, fn) {
-        debug(`[core:decorator]: Register property decorator key="${decoratorKey}"`);
+        debug(`[core]: Register property decorator key="${decoratorKey}"`);
         this.propertyHandlerMap.set(decoratorKey, fn);
     }
     registerMethodHandler(decoratorKey, fn) {
-        debug(`[core:decorator]: Register method decorator key="${decoratorKey}"`);
+        debug(`[core]: Register method decorator key="${decoratorKey}"`);
         this.methodDecoratorMap.set(decoratorKey, fn);
     }
     registerParameterHandler(decoratorKey, fn) {
-        debug(`[core:decorator]: Register parameter decorator key="${decoratorKey}"`);
+        debug(`[core]: Register parameter decorator key="${decoratorKey}"`);
         this.parameterDecoratorMap.set(decoratorKey, fn);
     }
     /**

package/dist/service/environmentService.d.ts

@@ -1,6 +1,6 @@
 import { IEnvironmentService } from '../interface';
 export declare class MidwayEnvironmentService implements IEnvironmentService {
-    environment: string;
+    protected environment: string;
     getCurrentEnvironment(): string;
     setCurrentEnvironment(environment: string): void;
     isDevelopmentEnvironment(): boolean;

package/dist/service/frameworkService.d.ts

@@ -4,6 +4,7 @@ import { MidwayConfigService } from './configService';
 import { MidwayLoggerService } from './loggerService';
 import { MidwayDecoratorService } from './decoratorService';
 import { MidwayAspectService } from './aspectService';
+import { MidwayApplicationManager } from '../common/applicationManager';
 export declare class MidwayFrameworkService {
     readonly applicationContext: IMidwayContainer;
     readonly globalOptions: any;
@@ -11,14 +12,14 @@ export declare class MidwayFrameworkService {
     loggerService: MidwayLoggerService;
     aspectService: MidwayAspectService;
     decoratorService: MidwayDecoratorService;
+    applicationManager: MidwayApplicationManager;
     constructor(applicationContext: IMidwayContainer, globalOptions: any);
     private mainFramework;
-    private globalFrameworkMap;
     private globalFrameworkList;
     protected init(): Promise<void>;
     getMainApp(): any;
     getMainFramework(): IMidwayFramework<any, any, any, unknown, unknown>;
-    getFramework(type: MidwayFrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
+    getFramework(namespaceOrFrameworkType: string | MidwayFrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
     runFramework(): Promise<void>;
     stopFramework(): Promise<void>;
 }

package/dist/service/frameworkService.js

@@ -18,6 +18,7 @@ const baseFramework_1 = require("../baseFramework");
 const pipelineService_1 = require("./pipelineService");
 const decoratorService_1 = require("./decoratorService");
 const aspectService_1 = require("./aspectService");
+const applicationManager_1 = require("../common/applicationManager");
 const util = require("util");
 const error_1 = require("../error");
 const debug = util.debuglog('midway:debug');
@@ -25,10 +26,10 @@ let MidwayFrameworkService = class MidwayFrameworkService {
     constructor(applicationContext, globalOptions) {
         this.applicationContext = applicationContext;
         this.globalOptions = globalOptions;
-        this.globalFrameworkMap = new WeakMap();
         this.globalFrameworkList = [];
     }
     async init() {
+        var _a;
         // register base config hook
         this.decoratorService.registerPropertyHandler(decorator_1.CONFIG_KEY, (propertyName, meta) => {
             var _a;
@@ -51,7 +52,7 @@ let MidwayFrameworkService = class MidwayFrameworkService {
         let frameworks = (0, decorator_1.listModule)(decorator_1.FRAMEWORK_KEY);
         // filter proto
         frameworks = filterProtoFramework(frameworks);
-        debug(`[core:framework]: Found Framework length = ${frameworks.length}`);
+        debug(`[core]: Found Framework length = ${frameworks.length}`);
         if (frameworks.length) {
             for (const frameworkClz of frameworks) {
                 const frameworkInstance = await this.applicationContext.getAsync(frameworkClz, [this.applicationContext]);
@@ -62,24 +63,24 @@ let MidwayFrameworkService = class MidwayFrameworkService {
                         applicationContext: this.applicationContext,
                         ...this.globalOptions,
                     });
-                    debug(`[core:framework]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
                 }
                 else {
-                    debug(`[core:framework]: Found Framework "${frameworkInstance.getFrameworkName()}" and delay initialize.`);
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and delay initialize.`);
                 }
                 // app init
-                this.globalFrameworkMap.set(frameworkInstance.getFrameworkType(), frameworkInstance);
+                const definition = this.applicationContext.registry.getDefinition((0, decorator_1.getProviderUUId)(frameworkClz));
+                this.applicationManager.addFramework((_a = definition === null || definition === void 0 ? void 0 : definition.namespace) !== null && _a !== void 0 ? _a : frameworkInstance.getFrameworkName(), frameworkInstance);
                 this.globalFrameworkList.push(frameworkInstance);
             }
             // register @App decorator handler
             this.decoratorService.registerPropertyHandler(decorator_1.APPLICATION_KEY, (propertyName, mete) => {
                 if (mete.type) {
-                    if (this.globalFrameworkMap.has(mete.type)) {
-                        return this.globalFrameworkMap.get(mete.type).getApplication();
-                    }
-                    else {
+                    const framework = this.applicationManager.getApplication(mete.type);
+                    if (!framework) {
                         throw new error_1.MidwayCommonError(`Framework ${mete.type} not Found`);
                     }
+                    return framework;
                 }
                 else {
                     return this.getMainApp();
@@ -107,8 +108,8 @@ let MidwayFrameworkService = class MidwayFrameworkService {
     getMainFramework() {
         return this.mainFramework;
     }
-    getFramework(type) {
-        return this.globalFrameworkMap.get(type);
+    getFramework(namespaceOrFrameworkType) {
+        return this.applicationManager.getFramework(namespaceOrFrameworkType);
     }
     async runFramework() {
         for (const frameworkInstance of this.globalFrameworkList) {
@@ -116,7 +117,7 @@ let MidwayFrameworkService = class MidwayFrameworkService {
             if (frameworkInstance.isEnable()) {
                 // app init
                 await frameworkInstance.run();
-                debug(`[core:framework]: Found Framework "${frameworkInstance.getFrameworkName()}" and run.`);
+                debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and run.`);
             }
         }
     }
@@ -142,6 +143,10 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", decoratorService_1.MidwayDecoratorService)
 ], MidwayFrameworkService.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", applicationManager_1.MidwayApplicationManager)
+], MidwayFrameworkService.prototype, "applicationManager", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),

package/dist/service/lifeCycleService.js

@@ -23,7 +23,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
     async init() {
         // run lifecycle
         const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
-        debug(`[core:lifecycle]: Found Configuration length = ${cycles.length}`);
+        debug(`[core]: Found Configuration length = ${cycles.length}`);
         const lifecycleInstanceList = [];
         for (const cycle of cycles) {
             if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
@@ -32,7 +32,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
             }
             else {
                 // 普通类写法
-                debug(`[core:lifecycle]: run ${cycle.target.name} init`);
+                debug(`[core]: run ${cycle.target.name} init`);
                 cycle.instance = await this.applicationContext.getAsync(cycle.target);
             }
             cycle.instance && lifecycleInstanceList.push(cycle);
@@ -80,7 +80,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         if (Array.isArray(lifecycleInstanceOrList)) {
             for (const cycle of lifecycleInstanceOrList) {
                 if (typeof cycle.instance[lifecycle] === 'function') {
-                    debug(`[core:lifecycle]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                    debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
                     const result = await cycle.instance[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
                     if (resultHandler) {
                         resultHandler(result);
@@ -90,7 +90,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         }
         else {
             if (typeof lifecycleInstanceOrList[lifecycle] === 'function') {
-                debug(`[core:lifecycle]: run ${lifecycleInstanceOrList.constructor.name} ${lifecycle}`);
+                debug(`[core]: run ${lifecycleInstanceOrList.constructor.name} ${lifecycle}`);
                 const result = await lifecycleInstanceOrList[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
                 if (resultHandler) {
                     resultHandler(result);
@@ -101,7 +101,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
     async runObjectLifeCycle(lifecycleInstanceList, lifecycle) {
         for (const cycle of lifecycleInstanceList) {
             if (typeof cycle.instance[lifecycle] === 'function') {
-                debug(`[core:lifecycle]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
                 return this.applicationContext[lifecycle](cycle.instance[lifecycle].bind(cycle.instance));
             }
         }

package/dist/service/loggerService.d.ts

@@ -7,7 +7,7 @@ export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     configService: MidwayConfigService;
     constructor(applicationContext: IMidwayContainer);
     protected init(): Promise<void>;
-    transformEggConfig(): {
+    protected transformEggConfig(): {
         midwayLogger: {
             default: {};
             clients: {};

package/dist/service/middlewareService.d.ts

@@ -1,11 +1,10 @@
-import { CommonMiddleware, IMidwayContainer } from '../interface';
+import { CommonMiddleware, IMidwayContainer, IMidwayApplication } from '../interface';
 export declare class MidwayMiddlewareService<T, R, N = unknown> {
     readonly applicationContext: IMidwayContainer;
     constructor(applicationContext: IMidwayContainer);
-    compose(middleware: Array<CommonMiddleware<T, R, N> | string>, name?: string): Promise<{
-        (context: any, next?: any): Promise<any>;
+    compose(middleware: Array<CommonMiddleware<T, R, N> | string>, app: IMidwayApplication, name?: string): Promise<{
+        (context: T, next?: any): Promise<any>;
         _name: string;
     }>;
 }
-export declare function pathMatching(options: any): (ctx?: any) => any;
 //# sourceMappingURL=middlewareService.d.ts.map

package/dist/service/middlewareService.js

@@ -9,7 +9,7 @@ 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.pathMatching = exports.MidwayMiddlewareService = void 0;
+exports.MidwayMiddlewareService = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const error_1 = require("../error");
 const util_1 = require("../util");
@@ -17,29 +17,31 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
     }
-    async compose(middleware, name) {
+    async compose(middleware, app, name) {
         if (!Array.isArray(middleware)) {
             throw new error_1.MidwayParameterError('Middleware stack must be an array');
         }
         const newMiddlewareArr = [];
         for (let fn of middleware) {
-            if ((0, decorator_1.isClass)(fn) || typeof fn === 'string') {
+            if (decorator_1.Types.isClass(fn) || typeof fn === 'string') {
                 if (typeof fn === 'string' &&
                     !this.applicationContext.hasDefinition(fn)) {
                     throw new error_1.MidwayCommonError('Middleware definition not found in midway container');
                 }
                 const classMiddleware = await this.applicationContext.getAsync(fn);
                 if (classMiddleware) {
-                    fn = classMiddleware.resolve();
+                    fn = await classMiddleware.resolve(app);
                     if (!classMiddleware.match && !classMiddleware.ignore) {
-                        fn._name = classMiddleware.constructor.name;
+                        if (!fn.name) {
+                            fn._name = classMiddleware.constructor.name;
+                        }
                         // just got fn
                         newMiddlewareArr.push(fn);
                     }
                     else {
                         // wrap ignore and match
                         const mw = fn;
-                        const match = pathMatching({
+                        const match = (0, util_1.pathMatching)({
                             match: classMiddleware.match,
                             ignore: classMiddleware.ignore,
                         });
@@ -67,6 +69,7 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
          * @api public
          */
         const composeFn = (context, next) => {
+            const supportBody = (0, util_1.isIncludeProperty)(context, 'body');
             // last called middleware #
             let index = -1;
             return dispatch(0);
@@ -80,9 +83,25 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                 if (!fn)
                     return Promise.resolve();
                 try {
-                    return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
-                        index,
-                    }));
+                    if (supportBody) {
+                        return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
+                            index,
+                        })).then(result => {
+                            // need to set body
+                            if (context['body'] && !result) {
+                                result = context['body'];
+                            }
+                            else if (result && context['body'] !== result) {
+                                context['body'] = result;
+                            }
+                            return result;
+                        });
+                    }
+                    else {
+                        return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
+                            index,
+                        }));
+                    }
                 }
                 catch (err) {
                     return Promise.reject(err);
@@ -101,19 +120,4 @@ MidwayMiddlewareService = __decorate([
     __metadata("design:paramtypes", [Object])
 ], MidwayMiddlewareService);
 exports.MidwayMiddlewareService = MidwayMiddlewareService;
-function pathMatching(options) {
-    options = options || {};
-    if (options.match && options.ignore)
-        throw new error_1.MidwayCommonError('options.match and options.ignore can not both present');
-    if (!options.match && !options.ignore)
-        return () => true;
-    const matchFn = options.match
-        ? (0, util_1.toPathMatch)(options.match)
-        : (0, util_1.toPathMatch)(options.ignore);
-    return function pathMatch(ctx) {
-        const matched = matchFn(ctx);
-        return options.match ? matched : !matched;
-    };
-}
-exports.pathMatching = pathMatching;
 //# sourceMappingURL=middlewareService.js.map

package/dist/setup.js

@@ -22,7 +22,7 @@ async function initializeGlobalApplicationContext(globalOptions) {
     // register baseDir and appDir
     applicationContext.registerObject('baseDir', baseDir);
     applicationContext.registerObject('appDir', appDir);
-    if (globalOptions.moduleDirector !== false) {
+    if (globalOptions.moduleDetector !== false) {
         if (globalOptions.moduleDetector === undefined ||
             globalOptions.moduleDetector === 'file') {
             applicationContext.setFileDetector(new _1.DirectoryFileDetector({
@@ -44,6 +44,7 @@ async function initializeGlobalApplicationContext(globalOptions) {
     applicationContext.bindClass(_1.MidwayFrameworkService);
     applicationContext.bindClass(_1.MidwayMiddlewareService);
     applicationContext.bindClass(_1.MidwayLifeCycleService);
+    applicationContext.bindClass(_1.MidwayApplicationManager);
     // bind preload module
     if (globalOptions.preloadModules && globalOptions.preloadModules.length) {
         for (const preloadModule of globalOptions.preloadModules) {
@@ -63,19 +64,26 @@ async function initializeGlobalApplicationContext(globalOptions) {
     await applicationContext.getAsync(_1.MidwayDecoratorService, [
         applicationContext,
     ]);
-    if (!globalOptions.configurationModule) {
-        globalOptions.configurationModule = [
+    if (!globalOptions.imports) {
+        globalOptions.imports = [
             (0, _1.safeRequire)((0, path_1.join)(globalOptions.baseDir, 'configuration')),
         ];
     }
-    for (const configurationModule of [].concat(globalOptions.configurationModule)) {
+    for (const configurationModule of []
+        .concat(globalOptions.imports)
+        .concat(globalOptions.configurationModule)) {
         // load configuration and component
         applicationContext.load(configurationModule);
     }
     // bind user code module
     await applicationContext.ready();
     if (globalOptions.globalConfig) {
-        configService.add([globalOptions.globalConfig]);
+        if (Array.isArray(globalOptions.globalConfig)) {
+            configService.add(globalOptions.globalConfig);
+        }
+        else {
+            configService.addObject(globalOptions.globalConfig);
+        }
     }
     // merge config
     await configService.load();