@midwayjs/core 3.1.6 → 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/interface.d.ts

@@ -426,7 +426,6 @@ export interface IMidwayBootstrapOptions {
     globalConfig?: Array<{
         [environmentName: string]: Record<string, any>;
     }> | Record<string, any>;
-    lazyInitializeFramework?: boolean;
 }
 export interface IConfigurationOptions {
     logger?: ILogger;

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.d.ts

@@ -1,4 +1,13 @@
 import { IMidwayBootstrapOptions, IMidwayContainer } from './';
+/**
+ * midway framework main entry, this method bootstrap all service and framework.
+ * @param globalOptions
+ */
 export declare function initializeGlobalApplicationContext(globalOptions: IMidwayBootstrapOptions): Promise<IMidwayContainer>;
 export declare function destroyGlobalApplicationContext(applicationContext: IMidwayContainer): Promise<void>;
+/**
+ * prepare applicationContext, it use in egg framework.
+ * @param globalOptions
+ */
+export declare function prepareGlobalApplicationContext(globalOptions: IMidwayBootstrapOptions): IMidwayContainer;
 //# sourceMappingURL=setup.d.ts.map

package/dist/setup.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.destroyGlobalApplicationContext = exports.initializeGlobalApplicationContext = void 0;
+exports.prepareGlobalApplicationContext = exports.destroyGlobalApplicationContext = exports.initializeGlobalApplicationContext = void 0;
 const _1 = require("./");
 const config_default_1 = require("./config/config.default");
 const decorator_1 = require("@midwayjs/decorator");
@@ -8,7 +8,55 @@ const util = require("util");
 const path_1 = require("path");
 const logger_1 = require("@midwayjs/logger");
 const debug = util.debuglog('midway:debug');
+/**
+ * midway framework main entry, this method bootstrap all service and framework.
+ * @param globalOptions
+ */
 async function initializeGlobalApplicationContext(globalOptions) {
+    const applicationContext = prepareGlobalApplicationContext(globalOptions);
+    // init logger
+    const loggerService = await applicationContext.getAsync(_1.MidwayLoggerService, [
+        applicationContext,
+    ]);
+    if (loggerService.getLogger('appLogger')) {
+        // register global logger
+        applicationContext.registerObject('logger', loggerService.getLogger('appLogger'));
+    }
+    // framework/config/plugin/logger/app decorator support
+    await applicationContext.getAsync(_1.MidwayFrameworkService, [
+        applicationContext,
+        globalOptions,
+    ]);
+    // lifecycle support
+    await applicationContext.getAsync(_1.MidwayLifeCycleService, [
+        applicationContext,
+    ]);
+    // some preload module init
+    const modules = (0, decorator_1.listPreloadModule)();
+    for (const module of modules) {
+        // preload init context
+        await applicationContext.getAsync(module);
+    }
+    return applicationContext;
+}
+exports.initializeGlobalApplicationContext = initializeGlobalApplicationContext;
+async function destroyGlobalApplicationContext(applicationContext) {
+    // stop lifecycle
+    const lifecycleService = await applicationContext.getAsync(_1.MidwayLifeCycleService);
+    await lifecycleService.stop();
+    // stop container
+    await applicationContext.stop();
+    (0, decorator_1.clearBindContainer)();
+    logger_1.loggers.close();
+    global['MIDWAY_APPLICATION_CONTEXT'] = undefined;
+    global['MIDWAY_MAIN_FRAMEWORK'] = undefined;
+}
+exports.destroyGlobalApplicationContext = destroyGlobalApplicationContext;
+/**
+ * prepare applicationContext, it use in egg framework.
+ * @param globalOptions
+ */
+function prepareGlobalApplicationContext(globalOptions) {
     var _a, _b, _c, _d;
     debug('[core]: start "initializeGlobalApplicationContext"');
     debug(`[core]: bootstrap options = ${util.inspect(globalOptions)}`);
@@ -46,6 +94,7 @@ async function initializeGlobalApplicationContext(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) {
@@ -91,43 +140,7 @@ async function initializeGlobalApplicationContext(globalOptions) {
     debug('[core]: Current config = %j', configService.getConfiguration());
     // middleware support
     applicationContext.get(_1.MidwayMiddlewareService, [applicationContext]);
-    // it will be delay framework initialize in egg cluster mode
-    if (!globalOptions.lazyInitializeFramework) {
-        // init logger
-        const loggerService = await applicationContext.getAsync(_1.MidwayLoggerService, [applicationContext]);
-        if (loggerService.getLogger('appLogger')) {
-            // register global logger
-            applicationContext.registerObject('logger', loggerService.getLogger('appLogger'));
-        }
-        // framework/config/plugin/logger/app decorator support
-        await applicationContext.getAsync(_1.MidwayFrameworkService, [
-            applicationContext,
-            globalOptions,
-        ]);
-        // lifecycle support
-        await applicationContext.getAsync(_1.MidwayLifeCycleService, [
-            applicationContext,
-        ]);
-        // some preload module init
-        const modules = (0, decorator_1.listPreloadModule)();
-        for (const module of modules) {
-            // preload init context
-            await applicationContext.getAsync(module);
-        }
-    }
     return applicationContext;
 }
-exports.initializeGlobalApplicationContext = initializeGlobalApplicationContext;
-async function destroyGlobalApplicationContext(applicationContext) {
-    // stop lifecycle
-    const lifecycleService = await applicationContext.getAsync(_1.MidwayLifeCycleService);
-    await lifecycleService.stop();
-    // stop container
-    await applicationContext.stop();
-    (0, decorator_1.clearBindContainer)();
-    logger_1.loggers.close();
-    global['MIDWAY_APPLICATION_CONTEXT'] = undefined;
-    global['MIDWAY_MAIN_FRAMEWORK'] = undefined;
-}
-exports.destroyGlobalApplicationContext = destroyGlobalApplicationContext;
+exports.prepareGlobalApplicationContext = prepareGlobalApplicationContext;
 //# sourceMappingURL=setup.js.map

package/dist/util/httpclient.d.ts

@@ -14,7 +14,13 @@ export interface IResponse extends http.IncomingMessage {
     status: number;
     data: Buffer | string | any;
 }
+export declare function makeHttpRequest(url: string, options?: IOptions): Promise<IResponse>;
+/**
+ * A simple http client
+ */
 export declare class HttpClient {
+    readonly defaultOptions: Pick<IOptions, 'headers' | 'timeout' | 'method'>;
+    constructor(defaultOptions?: Pick<IOptions, 'headers' | 'timeout' | 'method'>);
     request(url: string, options?: IOptions): Promise<IResponse>;
 }
 export {};

package/dist/util/httpclient.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpClient = void 0;
+exports.HttpClient = exports.makeHttpRequest = void 0;
 const http = require("http");
 const https = require("https");
 const url = require("url");
@@ -13,80 +13,90 @@ const mimeMap = {
     json: 'application/json',
     octet: 'application/octet-stream',
 };
-class HttpClient {
-    async request(url, options = {}) {
-        debug(`request '${url}'`);
-        const whatwgUrl = new URL(url);
-        const client = whatwgUrl.protocol === 'https:' ? https : http;
-        const contentType = options.contentType;
-        const dataType = options.dataType;
-        const method = options.method || 'GET';
-        const timeout = options.timeout || 5000;
-        const headers = {
-            Accept: mimeMap[dataType] || mimeMap.octet,
-            ...options.headers,
-        };
-        let data;
-        if (method === 'GET' && options.data) {
-            for (const key of Object.keys(options.data)) {
-                whatwgUrl.searchParams.set(key, options.data[key]);
-            }
-            headers['Content-Length'] = 0;
-        }
-        else if (options.data) {
-            data = Buffer.from(JSON.stringify(options.data));
-            headers['Content-Type'] = mimeMap[contentType] || mimeMap.octet;
-            headers['Content-Length'] = data.byteLength;
+async function makeHttpRequest(url, options = {}) {
+    debug(`request '${url}'`);
+    const whatwgUrl = new URL(url);
+    const client = whatwgUrl.protocol === 'https:' ? https : http;
+    const contentType = options.contentType;
+    const dataType = options.dataType;
+    const method = options.method || 'GET';
+    const timeout = options.timeout || 5000;
+    const headers = {
+        Accept: mimeMap[dataType] || mimeMap.octet,
+        ...options.headers,
+    };
+    let data;
+    if (method === 'GET' && options.data) {
+        for (const key of Object.keys(options.data)) {
+            whatwgUrl.searchParams.set(key, options.data[key]);
         }
-        return new Promise((resolve, reject) => {
-            const req = client.request(whatwgUrl.toString(), {
-                method,
-                headers,
-            }, res => {
-                res.setTimeout(timeout, () => {
-                    res.destroy(new Error('Response Timeout'));
-                });
-                res.on('error', error => {
-                    reject(error);
-                });
-                const chunks = [];
-                res.on('data', chunk => {
-                    chunks.push(chunk);
-                });
-                res.on('end', () => {
-                    let data = Buffer.concat(chunks);
-                    if (dataType === 'text' || dataType === 'json') {
-                        data = data.toString('utf8');
+        headers['Content-Length'] = 0;
+    }
+    else if (options.data) {
+        data = Buffer.from(JSON.stringify(options.data));
+        headers['Content-Type'] = mimeMap[contentType] || mimeMap.octet;
+        headers['Content-Length'] = data.byteLength;
+    }
+    return new Promise((resolve, reject) => {
+        const req = client.request(whatwgUrl.toString(), {
+            method,
+            headers,
+        }, res => {
+            res.setTimeout(timeout, () => {
+                res.destroy(new Error('Response Timeout'));
+            });
+            res.on('error', error => {
+                reject(error);
+            });
+            const chunks = [];
+            res.on('data', chunk => {
+                chunks.push(chunk);
+            });
+            res.on('end', () => {
+                let data = Buffer.concat(chunks);
+                if (dataType === 'text' || dataType === 'json') {
+                    data = data.toString('utf8');
+                }
+                if (dataType === 'json') {
+                    try {
+                        data = JSON.parse(data);
                     }
-                    if (dataType === 'json') {
-                        try {
-                            data = JSON.parse(data);
-                        }
-                        catch (e) {
-                            return reject(new Error('[httpclient] Unable to parse response data'));
-                        }
+                    catch (e) {
+                        return reject(new Error('[httpclient] Unable to parse response data'));
                     }
-                    Object.assign(res, {
-                        status: res.statusCode,
-                        data,
-                    });
-                    debug(`request '${url}' resolved with status ${res.statusCode}`);
-                    resolve(res);
+                }
+                Object.assign(res, {
+                    status: res.statusCode,
+                    data,
                 });
+                debug(`request '${url}' resolved with status ${res.statusCode}`);
+                resolve(res);
             });
-            req.setTimeout(timeout, () => {
-                req.destroy(new error_1.MidwayUtilHttpClientTimeoutError('Request Timeout'));
-            });
-            req.on('error', error => {
-                reject(error);
-            });
-            if (method !== 'GET') {
-                req.end(data);
-            }
-            else {
-                req.end();
-            }
         });
+        req.setTimeout(timeout, () => {
+            req.destroy(new error_1.MidwayUtilHttpClientTimeoutError('Request Timeout'));
+        });
+        req.on('error', error => {
+            reject(error);
+        });
+        if (method !== 'GET') {
+            req.end(data);
+        }
+        else {
+            req.end();
+        }
+    });
+}
+exports.makeHttpRequest = makeHttpRequest;
+/**
+ * A simple http client
+ */
+class HttpClient {
+    constructor(defaultOptions = {}) {
+        this.defaultOptions = defaultOptions;
+    }
+    async request(url, options) {
+        return makeHttpRequest(url, Object.assign(this.defaultOptions, options));
     }
 }
 exports.HttpClient = HttpClient;

package/package.json

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