@midwayjs/core 3.2.0 → 3.2.2

package/dist/baseFramework.d.ts

@@ -7,6 +7,7 @@ import { MidwayLoggerService } from './service/loggerService';
 import { ContextMiddlewareManager } from './common/middlewareManager';
 import { MidwayMiddlewareService } from './service/middlewareService';
 import { FilterManager } from './common/filterManager';
+import { MidwayMockService } from './service/mockService';
 export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next> {
     readonly applicationContext: IMidwayContainer;
     app: APP;
@@ -24,6 +25,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     configService: MidwayConfigService;
     informationService: MidwayInformationService;
     middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
+    mockService: MidwayMockService;
     constructor(applicationContext: IMidwayContainer);
     init(): Promise<this>;
     abstract configure(options?: OPT): any;

package/dist/baseFramework.js

@@ -20,6 +20,7 @@ const loggerService_1 = require("./service/loggerService");
 const middlewareManager_1 = require("./common/middlewareManager");
 const middlewareService_1 = require("./service/middlewareService");
 const filterManager_1 = require("./common/filterManager");
+const mockService_1 = require("./service/mockService");
 const util = require("util");
 const debug = util.debuglog('midway:debug');
 class BaseFramework {
@@ -232,6 +233,7 @@ class BaseFramework {
     async applyMiddleware(lastMiddleware) {
         if (!this.composeMiddleware) {
             this.middlewareManager.insertFirst((async (ctx, next) => {
+                this.mockService.applyContextMocks(this.app, ctx);
                 let returnResult = undefined;
                 try {
                     const result = await next();
@@ -308,6 +310,10 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", middlewareService_1.MidwayMiddlewareService)
 ], BaseFramework.prototype, "middlewareService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", mockService_1.MidwayMockService)
+], BaseFramework.prototype, "mockService", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),

package/dist/context/managedResolverFactory.js

@@ -32,7 +32,12 @@ class RefResolver {
         const mr = managed;
         if (mr.injectMode === decorator_1.InjectModeEnum.Class &&
             !((_a = this.factory.context.parent) !== null && _a !== void 0 ? _a : this.factory.context).hasDefinition(mr.name)) {
-            throw new error_1.MidwayMissingImportComponentError(originName);
+            if (originName === 'loggerService') {
+                throw new error_1.MidwayInconsistentVersionError();
+            }
+            else {
+                throw new error_1.MidwayMissingImportComponentError(originName);
+            }
         }
         return this.factory.context.get(mr.name, mr.args, {
             originName,
@@ -43,7 +48,12 @@ class RefResolver {
         const mr = managed;
         if (mr.injectMode === decorator_1.InjectModeEnum.Class &&
             !((_a = this.factory.context.parent) !== null && _a !== void 0 ? _a : this.factory.context).hasDefinition(mr.name)) {
-            throw new error_1.MidwayMissingImportComponentError(originName);
+            if (originName === 'loggerService') {
+                throw new error_1.MidwayInconsistentVersionError();
+            }
+            else {
+                throw new error_1.MidwayMissingImportComponentError(originName);
+            }
         }
         return this.factory.context.getAsync(mr.name, mr.args, {
             originName,

package/dist/error/framework.d.ts

@@ -14,6 +14,7 @@ export declare const FrameworkErrorEnum: {
     readonly SINGLETON_INJECT_REQUEST: "MIDWAY_10010";
     readonly MISSING_IMPORTS: "MIDWAY_10011";
     readonly UTIL_HTTP_TIMEOUT: "MIDWAY_10012";
+    readonly INCONSISTENT_VERSION: "MIDWAY_10013";
 };
 export declare class MidwayCommonError extends MidwayError {
     constructor(message: string);
@@ -54,4 +55,7 @@ export declare class MidwayMissingImportComponentError extends MidwayError {
 export declare class MidwayUtilHttpClientTimeoutError extends MidwayError {
     constructor(message: string);
 }
+export declare class MidwayInconsistentVersionError extends MidwayError {
+    constructor();
+}
 //# sourceMappingURL=framework.d.ts.map

package/dist/error/framework.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayUtilHttpClientTimeoutError = exports.MidwayMissingImportComponentError = exports.MidwaySingletonInjectRequestError = exports.MidwayUseWrongMethodError = exports.MidwayDuplicateRouteError = exports.MidwayResolverMissingError = exports.MidwayConfigMissingError = exports.MidwayFeatureNotImplementedError = exports.MidwayFeatureNoLongerSupportedError = exports.MidwayDefinitionNotFoundError = exports.MidwayParameterError = exports.MidwayCommonError = exports.FrameworkErrorEnum = void 0;
+exports.MidwayInconsistentVersionError = exports.MidwayUtilHttpClientTimeoutError = exports.MidwayMissingImportComponentError = exports.MidwaySingletonInjectRequestError = exports.MidwayUseWrongMethodError = exports.MidwayDuplicateRouteError = exports.MidwayResolverMissingError = exports.MidwayConfigMissingError = exports.MidwayFeatureNotImplementedError = exports.MidwayFeatureNoLongerSupportedError = exports.MidwayDefinitionNotFoundError = exports.MidwayParameterError = exports.MidwayCommonError = exports.FrameworkErrorEnum = void 0;
 const base_1 = require("./base");
 exports.FrameworkErrorEnum = (0, base_1.registerErrorCode)('midway', {
     UNKNOWN: 10000,
@@ -16,6 +16,7 @@ exports.FrameworkErrorEnum = (0, base_1.registerErrorCode)('midway', {
     SINGLETON_INJECT_REQUEST: 10010,
     MISSING_IMPORTS: 10011,
     UTIL_HTTP_TIMEOUT: 10012,
+    INCONSISTENT_VERSION: 10013,
 });
 class MidwayCommonError extends base_1.MidwayError {
     constructor(message) {
@@ -107,4 +108,11 @@ class MidwayUtilHttpClientTimeoutError extends base_1.MidwayError {
     }
 }
 exports.MidwayUtilHttpClientTimeoutError = MidwayUtilHttpClientTimeoutError;
+class MidwayInconsistentVersionError extends base_1.MidwayError {
+    constructor() {
+        const text = 'We find a latest dependency package installed, please remove the lock file and use "npm update" to upgrade all dependencies first.';
+        super(text, exports.FrameworkErrorEnum.INCONSISTENT_VERSION);
+    }
+}
+exports.MidwayInconsistentVersionError = MidwayInconsistentVersionError;
 //# sourceMappingURL=framework.js.map

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export { MidwayAspectService } from './service/aspectService';
 export { MidwayLifeCycleService } from './service/lifeCycleService';
 export { MidwayMiddlewareService } from './service/middlewareService';
 export { MidwayDecoratorService } from './service/decoratorService';
+export { MidwayMockService } from './service/mockService';
 export * from './service/pipelineService';
 export * from './util/contextUtil';
 export * from './common/serviceFactory';

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.MidwayFrameworkType = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.createConfiguration = exports.extend = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.safeRequire = exports.safelyGet = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
+exports.MidwayFrameworkType = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.createConfiguration = exports.extend = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.safeRequire = exports.safelyGet = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
 __exportStar(require("./interface"), exports);
 __exportStar(require("./context/container"), exports);
 var requestContainer_1 = require("./context/requestContainer");
@@ -59,6 +59,8 @@ var middlewareService_1 = require("./service/middlewareService");
 Object.defineProperty(exports, "MidwayMiddlewareService", { enumerable: true, get: function () { return middlewareService_1.MidwayMiddlewareService; } });
 var decoratorService_1 = require("./service/decoratorService");
 Object.defineProperty(exports, "MidwayDecoratorService", { enumerable: true, get: function () { return decoratorService_1.MidwayDecoratorService; } });
+var mockService_1 = require("./service/mockService");
+Object.defineProperty(exports, "MidwayMockService", { enumerable: true, get: function () { return mockService_1.MidwayMockService; } });
 __exportStar(require("./service/pipelineService"), exports);
 __exportStar(require("./util/contextUtil"), exports);
 __exportStar(require("./common/serviceFactory"), exports);

package/dist/service/middlewareService.js

@@ -18,6 +18,7 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
         this.applicationContext = applicationContext;
     }
     async compose(middleware, app, name) {
+        var _a, _b;
         if (!Array.isArray(middleware)) {
             throw new error_1.MidwayParameterError('Middleware stack must be an array');
         }
@@ -42,8 +43,8 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                         // wrap ignore and match
                         const mw = fn;
                         const match = (0, util_1.pathMatching)({
-                            match: classMiddleware.match,
-                            ignore: classMiddleware.ignore,
+                            match: (_a = classMiddleware.match) === null || _a === void 0 ? void 0 : _a.bind(classMiddleware),
+                            ignore: (_b = classMiddleware.ignore) === null || _b === void 0 ? void 0 : _b.bind(classMiddleware),
                         });
                         fn = (ctx, next, options) => {
                             if (!match(ctx))

package/dist/service/mockService.d.ts

@@ -0,0 +1,22 @@
+import { IMidwayApplication, IMidwayContainer, IMidwayContext } from '../interface';
+export declare class MidwayMockService {
+    readonly applicationContext: IMidwayContainer;
+    protected mocks: any[];
+    protected contextMocks: Array<{
+        app: IMidwayApplication;
+        key: string | ((ctx: IMidwayContext) => void);
+        value: any;
+    }>;
+    protected cache: Map<any, any>;
+    constructor(applicationContext: IMidwayContainer);
+    mockClassProperty(clzz: new (...args: any[]) => any, propertyName: string, value: any): void;
+    mockProperty(obj: any, key: string, value: any): void;
+    mockContext(app: IMidwayApplication, key: string | ((ctx: IMidwayContext) => void), value?: PropertyDescriptor | any): void;
+    restore(): void;
+    isMocked(obj: any, key: any): any;
+    applyContextMocks(app: IMidwayApplication, ctx: IMidwayContext): void;
+    getContextMocksSize(): number;
+    getMocksSize(): number;
+    private overridePropertyDescriptor;
+}
+//# sourceMappingURL=mockService.d.ts.map

package/dist/service/mockService.js

@@ -0,0 +1,126 @@
+"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.MidwayMockService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayMockService = class MidwayMockService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+        this.mocks = [];
+        this.contextMocks = [];
+        this.cache = new Map();
+    }
+    mockClassProperty(clzz, propertyName, value) {
+        return this.mockProperty(clzz.prototype, propertyName, value);
+    }
+    mockProperty(obj, key, value) {
+        // eslint-disable-next-line no-prototype-builtins
+        const hasOwnProperty = obj.hasOwnProperty(key);
+        this.mocks.push({
+            obj,
+            key,
+            descriptor: Object.getOwnPropertyDescriptor(obj, key),
+            // Make sure the key exists on object not the prototype
+            hasOwnProperty,
+        });
+        // Delete the origin key, redefine it below
+        if (hasOwnProperty) {
+            delete obj[key];
+        }
+        // Set a flag that checks if it is mocked
+        let flag = this.cache.get(obj);
+        if (!flag) {
+            flag = new Set();
+            this.cache.set(obj, flag);
+        }
+        flag.add(key);
+        const descriptor = this.overridePropertyDescriptor(value);
+        Object.defineProperty(obj, key, descriptor);
+    }
+    mockContext(app, key, value) {
+        this.contextMocks.push({
+            app,
+            key,
+            value,
+        });
+    }
+    restore() {
+        for (let i = this.mocks.length - 1; i >= 0; i--) {
+            const m = this.mocks[i];
+            if (!m.hasOwnProperty) {
+                // Delete the mock key, use key on the prototype
+                delete m.obj[m.key];
+            }
+            else {
+                // Redefine the origin key instead of the mock key
+                Object.defineProperty(m.obj, m.key, m.descriptor);
+            }
+        }
+        this.mocks = [];
+        this.contextMocks = [];
+        this.cache.clear();
+    }
+    isMocked(obj, key) {
+        const flag = this.cache.get(obj);
+        return flag ? flag.has(key) : false;
+    }
+    applyContextMocks(app, ctx) {
+        if (this.contextMocks.length > 0) {
+            for (const mockItem of this.contextMocks) {
+                if (mockItem.app === app) {
+                    const descriptor = this.overridePropertyDescriptor(mockItem.value);
+                    if (typeof mockItem.key === 'string') {
+                        Object.defineProperty(ctx, mockItem.key, descriptor);
+                    }
+                    else {
+                        mockItem.key(ctx);
+                    }
+                }
+            }
+        }
+    }
+    getContextMocksSize() {
+        return this.contextMocks.length;
+    }
+    getMocksSize() {
+        return this.mocks.length;
+    }
+    overridePropertyDescriptor(value) {
+        const descriptor = {
+            configurable: true,
+            enumerable: true,
+        };
+        if (value && (value.get || value.set)) {
+            // Default to undefined
+            descriptor.get = value.get;
+            descriptor.set = value.set;
+        }
+        else {
+            // Without getter/setter mode
+            descriptor.value = value;
+            descriptor.writable = true;
+        }
+        return descriptor;
+    }
+};
+__decorate([
+    (0, decorator_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], MidwayMockService.prototype, "restore", null);
+MidwayMockService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayMockService);
+exports.MidwayMockService = MidwayMockService;
+//# sourceMappingURL=mockService.js.map

package/dist/setup.js

@@ -94,6 +94,7 @@ function prepareGlobalApplicationContext(globalOptions) {
     applicationContext.bindClass(_1.MidwayFrameworkService);
     applicationContext.bindClass(_1.MidwayMiddlewareService);
     applicationContext.bindClass(_1.MidwayLifeCycleService);
+    applicationContext.bindClass(_1.MidwayMockService);
     // bind preload module
     if (globalOptions.preloadModules && globalOptions.preloadModules.length) {
         for (const preloadModule of globalOptions.preloadModules) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "cee3e5ddbb4f0cc5f80176a7b1e271e809686a97"
+  "gitHead": "6bc097035302d01ae901d76a10e080db8554a864"
 }