@midwayjs/core 3.0.0-alpha.9 → 3.0.0-beta.12

package/dist/service/loggerService.js

@@ -0,0 +1,132 @@
+"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.MidwayLoggerService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const configService_1 = require("./configService");
+const serviceFactory_1 = require("../common/serviceFactory");
+const logger_1 = require("@midwayjs/logger");
+const levelTransform = level => {
+    if (!level) {
+        return undefined;
+    }
+    switch (level) {
+        case 'NONE':
+        case Infinity: // egg logger 的 none 是这个等级
+            return null;
+        case 0:
+        case 'DEBUG':
+        case 'debug':
+            return 'debug';
+        case 1:
+        case 'INFO':
+        case 'info':
+            return 'info';
+        case 2:
+        case 'WARN':
+        case 'warn':
+            return 'warn';
+        case 3:
+        case 'ERROR':
+        case 'error':
+            return 'error';
+        default:
+            return 'silly';
+    }
+};
+let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.ServiceFactory {
+    constructor(applicationContext) {
+        super();
+        this.applicationContext = applicationContext;
+    }
+    async init() {
+        var _a;
+        const eggLoggerConfig = this.transformEggConfig();
+        if (eggLoggerConfig) {
+            this.configService.addObject(eggLoggerConfig);
+        }
+        await this.initClients(this.configService.getConfiguration('midwayLogger'));
+        // alias inject logger
+        (_a = this.applicationContext) === null || _a === void 0 ? void 0 : _a.registerObject('logger', this.getLogger('appLogger'));
+    }
+    transformEggConfig() {
+        if (this.configService.getConfiguration('customLogger')) {
+            // use egg module
+            return this.transformEggLogger(this.configService.getConfiguration());
+        }
+        else {
+            // it will be use other logger
+            return;
+        }
+    }
+    async createClient(config, name) {
+        logger_1.loggers.createLogger(name, config);
+    }
+    getName() {
+        return 'logger';
+    }
+    createLogger(name, config) {
+        return logger_1.loggers.createLogger(name, config);
+    }
+    getLogger(name) {
+        return logger_1.loggers.getLogger(name);
+    }
+    transformEggLogger(options) {
+        var _a, _b, _c;
+        const transformLoggerConfig = {
+            midwayLogger: {
+                default: {},
+                clients: {},
+            },
+        };
+        if (options.midwayLogger && !options.midwayLogger.default) {
+            transformLoggerConfig.midwayLogger.default = {
+                dir: options.logger.dir,
+                level: levelTransform(options.logger.level),
+                consoleLevel: levelTransform(options.logger.consoleLevel),
+            };
+        }
+        const eggCustomLogger = options['customLogger'];
+        for (const name in eggCustomLogger) {
+            transformLoggerConfig.midwayLogger.clients[name] = {
+                fileLogName: (_a = eggCustomLogger[name]) === null || _a === void 0 ? void 0 : _a.file,
+                level: levelTransform((_b = eggCustomLogger[name]) === null || _b === void 0 ? void 0 : _b.level),
+                consoleLevel: levelTransform((_c = eggCustomLogger[name]) === null || _c === void 0 ? void 0 : _c.consoleLevel),
+            };
+            cleanUndefinedProperty(transformLoggerConfig.midwayLogger.clients[name]);
+        }
+        return transformLoggerConfig;
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayLoggerService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayLoggerService.prototype, "init", null);
+MidwayLoggerService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayLoggerService);
+exports.MidwayLoggerService = MidwayLoggerService;
+function cleanUndefinedProperty(obj) {
+    Object.keys(obj).forEach(key => {
+        if (obj[key] === undefined) {
+            delete obj[key];
+        }
+    });
+}
+//# sourceMappingURL=loggerService.js.map

package/dist/service/middlewareService.d.ts

@@ -0,0 +1,10 @@
+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>, app: IMidwayApplication, name?: string): Promise<{
+        (context: any, next?: any): Promise<any>;
+        _name: string;
+    }>;
+}
+//# sourceMappingURL=middlewareService.d.ts.map

package/dist/service/middlewareService.js

@@ -0,0 +1,123 @@
+"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.MidwayMiddlewareService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const error_1 = require("../error");
+const util_1 = require("../util");
+let MidwayMiddlewareService = class MidwayMiddlewareService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+    }
+    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 (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(app);
+                    if (!classMiddleware.match && !classMiddleware.ignore) {
+                        if (!fn.name) {
+                            fn._name = classMiddleware.constructor.name;
+                        }
+                        // just got fn
+                        newMiddlewareArr.push(fn);
+                    }
+                    else {
+                        // wrap ignore and match
+                        const mw = fn;
+                        const match = (0, util_1.pathMatching)({
+                            match: classMiddleware.match,
+                            ignore: classMiddleware.ignore,
+                        });
+                        fn = (ctx, next, options) => {
+                            if (!match(ctx))
+                                return next();
+                            return mw(ctx, next, options);
+                        };
+                        fn._name = classMiddleware.constructor.name;
+                        newMiddlewareArr.push(fn);
+                    }
+                }
+                else {
+                    throw new error_1.MidwayCommonError('Middleware must have resolve method!');
+                }
+            }
+            else {
+                newMiddlewareArr.push(fn);
+            }
+        }
+        /**
+         * @param {Object} context
+         * @param next
+         * @return {Promise}
+         * @api public
+         */
+        const composeFn = (context, next) => {
+            const supportBody = (0, util_1.isIncludeProperty)(context, 'body');
+            // last called middleware #
+            let index = -1;
+            return dispatch(0);
+            function dispatch(i) {
+                if (i <= index)
+                    return Promise.reject(new error_1.MidwayCommonError('next() called multiple times'));
+                index = i;
+                let fn = newMiddlewareArr[i];
+                if (i === newMiddlewareArr.length)
+                    fn = next;
+                if (!fn)
+                    return Promise.resolve();
+                try {
+                    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);
+                }
+            }
+        };
+        if (name) {
+            composeFn._name = name;
+        }
+        return composeFn;
+    }
+};
+MidwayMiddlewareService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayMiddlewareService);
+exports.MidwayMiddlewareService = MidwayMiddlewareService;
+//# sourceMappingURL=middlewareService.js.map

package/dist/{features/pipeline.d.ts → service/pipelineService.d.ts}

@@ -1,3 +1,35 @@
+import { IMidwayContainer } from '../interface';
+import { ObjectIdentifier } from '@midwayjs/decorator';
+interface IPipelineInfo {
+    /**
+     * 上次执行结果(只有在执行 waterfall 时才有值)
+     */
+    prevValue?: any;
+    /**
+     * 当前执行的 valve 类
+     */
+    current: IValveHandler;
+    /**
+     * 当前执行的 valve 名称(类名)
+     */
+    currentName: string;
+    /**
+     * 之前执行的 valve 类
+     */
+    prev?: IValveHandler;
+    /**
+     * 之前执行的 valve 名称(类名)
+     */
+    prevName?: string;
+    /**
+     * 后一个将执行的 valve 类
+     */
+    next?: IValveHandler;
+    /**
+     * 后一个将执行的 valve 名称(类名)
+     */
+    nextName?: string;
+}
 /**
  * 执行pipeline 时当前上下文存储内容
  */
@@ -9,24 +41,7 @@ export interface IPipelineContext {
     /**
      * valve 执行信息
      */
-    info?: {
-        /**
-         * 上次执行结果(只有在执行 waterfall 时才有值)
-         */
-        prevValue?: any;
-        /**
-         * 当前执行的 valve 名称(类名)
-         */
-        current: string;
-        /**
-         * 之前执行的 valve 名称(类名)
-         */
-        prev?: string;
-        /**
-         * 后一个将执行的 valve 名称(类名)
-         */
-        next?: string;
-    };
+    info?: IPipelineInfo;
     /**
      * 用于缓存当前 pipeline 执行中的中间过程参数
      * @param key 关键词
@@ -68,7 +83,7 @@ export interface IPipelineOptions {
     /**
      * 这次 pipeline 执行那几个 valve 白名单
      */
-    valves?: string[];
+    valves?: valvesType;
 }
 /**
  * pipeline 执行返回结果
@@ -101,6 +116,26 @@ export interface IPipelineResult<T> {
     result: T;
 }
 export interface IPipelineHandler {
+    parallel<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
+    concat<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
+    series<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
+    concatSeries<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
+    waterfall<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
+}
+declare type valvesType = Array<ObjectIdentifier | (new (...args: any[]) => any)>;
+export declare class PipelineContext implements IPipelineContext {
+    args: any;
+    info: IPipelineInfo;
+    constructor(args?: any);
+    private data;
+    get(key: string): any;
+    set(key: string, val: any): void;
+    keys(): string[];
+}
+export declare class MidwayPipelineService implements IPipelineHandler {
+    readonly applicationContext: IMidwayContainer;
+    readonly valves?: valvesType;
+    constructor(applicationContext: IMidwayContainer, valves?: valvesType);
     /**
      * 并行执行，使用 Promise.all
      * @param opts 执行参数
@@ -126,34 +161,9 @@ export interface IPipelineHandler {
      * @param opts 执行参数
      */
     waterfall<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
-}
-import { IApplicationContext } from '../interface';
-export declare class PipelineContext implements IPipelineContext {
-    args: any;
-    info: {
-        prevValue?: any;
-        current: string;
-        prev?: string;
-        next?: string;
-    };
-    constructor(args?: any);
-    private data;
-    get(key: string): any;
-    set(key: string, val: any): void;
-    keys(): string[];
-}
-export declare class PipelineHandler implements IPipelineHandler {
-    private applicationContext;
-    private valves;
-    constructor(applicationContext: IApplicationContext, valves?: string[]);
-    parallel<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
-    concat<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
-    series<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
-    concatSeries<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
-    waterfall<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
     private mergeValves;
     private prepareParallelValves;
     private packResult;
 }
-export declare function pipelineFactory(applicationContext: IApplicationContext, valves?: string[]): PipelineHandler;
-//# sourceMappingURL=pipeline.d.ts.map
+export {};
+//# sourceMappingURL=pipelineService.d.ts.map

package/dist/{features/pipeline.js → service/pipelineService.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pipelineFactory = exports.PipelineHandler = exports.PipelineContext = void 0;
+exports.MidwayPipelineService = exports.PipelineContext = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const providerWrapper_1 = require("../context/providerWrapper");
+////////////// implements ///////////////////////
 class PipelineContext {
     constructor(args) {
-        this.info = { current: null };
+        this.info = { current: null, currentName: null };
         this.data = new Map();
         this.args = args;
     }
@@ -25,21 +25,34 @@ class PipelineContext {
     }
 }
 exports.PipelineContext = PipelineContext;
-class PipelineHandler {
+class MidwayPipelineService {
+    // 默认的 valves (@Pipeline(['test1', 'test2']))
     constructor(applicationContext, valves) {
         this.applicationContext = applicationContext;
         this.valves = valves;
     }
+    /**
+     * 并行执行，使用 Promise.all
+     * @param opts 执行参数
+     */
     async parallel(opts) {
         const valves = this.prepareParallelValves(opts);
         const res = await Promise.all(valves);
         return this.packResult(res, false);
     }
+    /**
+     * 并行执行，最终 result 为数组
+     * @param opts 执行参数
+     */
     async concat(opts) {
         const valves = this.prepareParallelValves(opts);
         const res = await Promise.all(valves);
         return this.packResult(res, true);
     }
+    /**
+     * 串行执行，使用 foreach await
+     * @param opts 执行参数
+     */
     async series(opts) {
         const valves = this.mergeValves(opts.valves);
         const ctx = new PipelineContext(opts.args);
@@ -48,18 +61,25 @@ class PipelineHandler {
         const info = {
             prevValue: null,
             current: null,
+            currentName: null,
             prev: null,
+            prevName: null,
             next: null,
+            nextName: null,
         };
         let nextIdx = 1;
         for (const v of valves) {
             info.prev = info.current;
+            info.prevName = getName(info.prev);
             info.current = v;
+            info.currentName = getName(info.current);
             if (nextIdx < valves.length) {
                 info.next = valves[nextIdx];
+                info.nextName = getName(info.next);
             }
             else {
                 info.next = undefined;
+                info.nextName = undefined;
             }
             nextIdx += 1;
             ctx.info = info;
@@ -76,7 +96,7 @@ class PipelineHandler {
             catch (e) {
                 result.success = false;
                 result.error = {
-                    valveName: v,
+                    valveName: typeof v === 'string' ? v : v.name,
                     message: e.message,
                     error: e,
                 };
@@ -86,6 +106,10 @@ class PipelineHandler {
         result.result = data;
         return result;
     }
+    /**
+     * 串行执行，使用 foreach await，最终 result 为数组
+     * @param opts 执行参数
+     */
     async concatSeries(opts) {
         const valves = this.mergeValves(opts.valves);
         const ctx = new PipelineContext(opts.args);
@@ -94,18 +118,25 @@ class PipelineHandler {
         const info = {
             prevValue: null,
             current: null,
+            currentName: null,
             prev: null,
+            prevName: null,
             next: null,
+            nextName: null,
         };
         let nextIdx = 1;
         for (const v of valves) {
             info.prev = info.current;
+            info.prevName = getName(info.prev);
             info.current = v;
+            info.currentName = getName(info.current);
             if (nextIdx < valves.length) {
                 info.next = valves[nextIdx];
+                info.nextName = getName(info.next);
             }
             else {
                 info.next = undefined;
+                info.nextName = undefined;
             }
             nextIdx += 1;
             ctx.info = info;
@@ -118,7 +149,7 @@ class PipelineHandler {
             catch (e) {
                 result.success = false;
                 result.error = {
-                    valveName: v,
+                    valveName: typeof v === 'string' ? v : v.name,
                     message: e.message,
                     error: e,
                 };
@@ -128,6 +159,10 @@ class PipelineHandler {
         result.result = data;
         return result;
     }
+    /**
+     * 串行执行，但是会把前者执行结果当成入参，传入到下一个执行中去，最后一个执行的 valve 结果会被返回
+     * @param opts 执行参数
+     */
     async waterfall(opts) {
         const result = await this.concatSeries(opts);
         if (result.success) {
@@ -185,7 +220,7 @@ class PipelineHandler {
             if (r.error) {
                 result.success = false;
                 result.error = {
-                    valveName: r.valveName,
+                    valveName: typeof r.valveName === 'string' ? r.valveName : r.valveName.name,
                     message: r.error.message,
                     error: r.error,
                 };
@@ -204,16 +239,16 @@ class PipelineHandler {
         return result;
     }
 }
-exports.PipelineHandler = PipelineHandler;
-function pipelineFactory(applicationContext, valves) {
-    return new PipelineHandler(applicationContext, valves);
+exports.MidwayPipelineService = MidwayPipelineService;
+function getName(target) {
+    if (target) {
+        if (typeof target === 'string') {
+            return target;
+        }
+        else {
+            return (0, decorator_1.getProviderName)(target);
+        }
+    }
+    return null;
 }
-exports.pipelineFactory = pipelineFactory;
-providerWrapper_1.providerWrapper([
-    {
-        id: decorator_1.PIPELINE_IDENTIFIER,
-        provider: pipelineFactory,
-        scope: decorator_1.ScopeEnum.Prototype,
-    },
-]);
-//# sourceMappingURL=pipeline.js.map
+//# sourceMappingURL=pipelineService.js.map

package/dist/setup.d.ts

@@ -0,0 +1,4 @@
+import { IMidwayBootstrapOptions, IMidwayContainer } from './';
+export declare function initializeGlobalApplicationContext(globalOptions: IMidwayBootstrapOptions): Promise<IMidwayContainer>;
+export declare function destroyGlobalApplicationContext(applicationContext: IMidwayContainer): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map